diff --git a/BUILD.gn b/BUILD.gn index 9ac89cddc45c62da11025fb0eac9bed0ab398b8f..56aeb0a0de00e5621f60b07dd436c4c8186a7b02 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build_overrides/vulkan_validation_layers.gni") +import("scripts/gn/layers-ohos.gni") vulkan_undefine_configs = [] if (is_win) { @@ -62,6 +62,7 @@ config("vulkan_internal_config") { defines = [ "VK_ENABLE_BETA_EXTENSIONS" ] cflags = [] + cflags_cc = [] if (is_clang || !is_win) { cflags += [ "-Wno-unused-function" ] } @@ -69,6 +70,20 @@ config("vulkan_internal_config") { cflags += [ "-Wno-unguarded-availability-new" ] } + if (is_ohos) { + cflags_cc += [ + "-Wno-unused-but-set-variable", + # "-Wno-c++17-extensions", + "-std=c++17", + "-frtti" + ] + cflags += [ + # "-Werror", + "-Wno-unused-variable", + "-Wno-misleading-indentation" + ] + } + # Suppress warnings the vulkan code doesn't comply with. if (is_fuchsia) { configs = [ "//build/config:Wno-unused-but-set-variable" ] @@ -324,7 +339,7 @@ if (!is_android) { script = "scripts/gn/generate_vulkan_layers_json.py" deps = [ "$vulkan_headers_dir:vulkan_headers" ] - if (!is_fuchsia) { + if (!is_fuchsia && !is_ohos) { # Make sure that the cleanup of old layer JSON files happens before the new ones are generated. deps += [ ":vulkan_clean_old_validation_layer_objects" ] } @@ -340,6 +355,8 @@ if (!is_android) { _platform = "Darwin" } else if (is_fuchsia) { _platform = "Fuchsia" + } else if (is_ohos) { + _platform = "OHOS" } else { _platform = "Other" } @@ -350,7 +367,7 @@ if (!is_android) { rebase_path("layers/", root_build_dir), rebase_path(vulkan_data_dir, root_build_dir), ] + rebase_path(sources, root_build_dir) - if (is_fuchsia) { + if (is_fuchsia || is_ohos) { args += [ "--no-path-prefix" ] } @@ -365,7 +382,8 @@ config("vulkan_memory_allocator_config") { } } -source_set("vulkan_layer_utils") { +ohos_source_set("vulkan_layer_utils") { + configs = [] include_dirs = [ "layers", "layers/external", @@ -419,7 +437,7 @@ source_set("vulkan_layer_utils") { ] configs -= vulkan_undefine_configs - if (!is_fuchsia) { + if (!is_fuchsia && !is_ohos) { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] } @@ -450,6 +468,8 @@ config("vulkan_stateless_validation_config") { if (is_fuchsia) { library_type = "loadable_module" +} else if (is_ohos) { + library_type = "ohos_shared_library" } else { library_type = "shared_library" } @@ -459,10 +479,16 @@ foreach(layer_info, layers) { target(library_type, "VkLayer_$name") { defines = [] ldflags = [] + configs = [] + cflags_cc = [] if (is_fuchsia) { configs -= [ "//build/config:thread_safety_annotations" ] ldflags += [ "-static-libstdc++" ] configs += [ "//build/config:rtti" ] + } else if (is_ohos) { + # configs -= [ "//build/config:thread_safety_annotations" ] + # ldflags += [ "-static-libstdc++" ] + cflags_cc += [ "-frtti" ] } else { configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] @@ -475,8 +501,9 @@ foreach(layer_info, layers) { deps = [ ":vulkan_layer_utils", "$vulkan_utility_libraries_dir:vulkan_layer_settings", + ":vulkan_gen_json_files", ] - if (!is_fuchsia) { + if (!is_fuchsia && !is_ohos) { deps += [ # Make sure the cleanup of old layers happen before the new ones are compiled. ":vulkan_clean_old_validation_layer_objects", @@ -509,7 +536,7 @@ group("vulkan_validation_layers") { data_deps = [] foreach(layer_info, layers) { name = layer_info[0] - if (is_fuchsia) { + if (is_fuchsia || is_ohos) { public_deps += [ ":VkLayer_$name" ] } else { data_deps += [ ":VkLayer_$name" ] diff --git a/OAT.xml b/OAT.xml new file mode 100644 index 0000000000000000000000000000000000000000..6ac6eb7bc0dd30c480c2d06f9e769cf27707f75e --- /dev/null +++ b/OAT.xml @@ -0,0 +1,29 @@ + + + + + + LICENSE.txt + + + + + + + \ No newline at end of file diff --git a/README.OpenSource b/README.OpenSource new file mode 100644 index 0000000000000000000000000000000000000000..035ff830b6b32be9cb62bece46123e04b75acf15 --- /dev/null +++ b/README.OpenSource @@ -0,0 +1,11 @@ +[ + { + "Name": "Vulkan-ValidationLayers", + "License": "Apache-2.0", + "License File": "LICENSE", + "Version Number": "v1.3.275", + "Owner": "wangxutao5@huawei.com", + "Upstream URL": "https://github.com/KhronosGroup/Vulkan-ValidationLayers.git", + "Description": "This project provides Vulkan validation layers that can be enabled to assist development by enabling developers to verify their applications correct use of the Vulkan API." + } +] diff --git a/README_OpenHarmony.md b/README_OpenHarmony.md new file mode 100644 index 0000000000000000000000000000000000000000..c7763a982b06e9eee70af791277aebe371bf0229 --- /dev/null +++ b/README_OpenHarmony.md @@ -0,0 +1,73 @@ +# Vulkan-ValidationLayers + +本仓库包含开源软件Vulkan-ValidationLayers，为OpenHarmony提供了Vulkan验证层，Vulkan验证层可以在应用程序开发期间为开发者提供一些错误检查，帮助开发者正确使用Vulkan API。Vulkan-ValidationLayers的功能请参考[Vulkan-ValidationLayers](docs/khronos_validation_layer.md) + +## Vulkan-ValidationLayers的实现方式 + +Vulkan-ValidationLayers被实现为一个Vulkan Layer，由Vulkan-Loader加载并使用，Vulkan-Loader的功能请参考[Vulkan-Loader](https://gitee.com/openharmony/third_party_vulkan-loader/blob/master/README_OpenHarmony.md)。 + +![vulkan-validationlayers_architecture_in_OH](docs/images/vulkan-validationlayers_architecture_in_OH.png) + + +## Vulkan-Loader加载验证层的方式 + +### 系统侧 +Vulkan-ValidationLayers在系统目录下会提供一个json配置文件`VkLayer_khronos_validation.json`和一个so文件`libVkLayer_khronos_validation.so`。 + +[Vulkan-Loader](https://gitee.com/openharmony/third_party_vulkan-loader/blob/master/README_OpenHarmony.md)会扫描指定目录下的json配置文件，解析出so的位置并加载对应的so文件。 + +![vulkan-validationlayers_load_way_in_OH](docs/images/vulkan-validationlayers_load_way_in_OH.png) + +### 应用侧 +`在调试过程中开启ValidationLayers, 正式版本请不要开启。` + +开启ValidationLayers的示例代码如下 + +``` + // Check if this layer is available at instance level + const char* validationLayerName = "VK_LAYER_KHRONOS_validation"; + uint32_t instanceLayerCount; + vkEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr); + std::vector instanceLayerProperties(instanceLayerCount); + vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayerProperties.data()); + bool validationLayerPresent = false; + for (VkLayerProperties layer : instanceLayerProperties) { + if (strcmp(layer.layerName, validationLayerName) == 0) { + validationLayerPresent = true; + break; + } + } + if (validationLayerPresent) { + instanceCreateInfo.ppEnabledLayerNames = &validationLayerName; + instanceCreateInfo.enabledLayerCount = 1; + } else { + std::cerr << "Validation layer VK_LAYER_KHRONOS_validation not present, validation is disabled"; + } + + VkResult result = vkCreateInstance(&instanceCreateInfo, nullptr, &instance); +``` + +## 构建指导 + +适配OpenHarmony平台的编译脚本请见：[build-openharmony/BUILD.gn](build-openharmony/BUILD.gn) + +由于graphic_2d模块的编译脚本中包含了Vulkan-ValidationLayers（详见：[bundle.json](https://gitee.com/openharmony/graphic_graphic_2d/blob/master/bundle.json)），所以编译graphic_2d模块可以将Vulkan-ValidationLayers同时编译出来，以rk3568平台为例，编译命令： + +```shell +./build.sh --product-name rk3568 --ccache --build-target graphic_2d +``` + +也可以单独编译Vulkan-ValidationLayers： + +```shell +./build.sh --product-name rk3568 --ccache --build-target VkLayer_khronos_validation +``` + +编译完成后会在`out/rk3568/graphic/graphic_2d`目录下生成`libVkLayer_khronos_validation.so` + + +## License + +Apache License 2.0 + +见 [LICENSE](LICENSE.txt). \ No newline at end of file diff --git a/build.patch b/build.patch new file mode 100644 index 0000000000000000000000000000000000000000..488f0e19c335205e547b521484740e3830b1d8d3 --- /dev/null +++ b/build.patch @@ -0,0 +1,13 @@ +diff --git a/compile_standard_whitelist.json b/compile_standard_whitelist.json +index b0bee416..e1177539 100644 +--- a/compile_standard_whitelist.json ++++ b/compile_standard_whitelist.json +@@ -692,6 +692,8 @@ + "//third_party/vk-gl-cts/modules/gles3:libdeqp-gles3", + "//third_party/vk-gl-cts/modules/glshared:deqp-gl-shared_source", + "//third_party/vk-gl-cts/modules/glshared:libdeqp-gl-shared", ++ "//third_party/vulkan-validationlayers:VkLayer_khronos_validation", ++ "//third_party/vulkan-validationlayers:vulkan_layer_utils", + "//third_party/rust/crates/rust-openssl/openssl-sys:lib" + ] + } diff --git a/bundle.json b/bundle.json new file mode 100644 index 0000000000000000000000000000000000000000..5b449a76b8e37ee6c240d12b5ebbb7a46558134a --- /dev/null +++ b/bundle.json @@ -0,0 +1,45 @@ +{ + "name": "@ohos/vulkan-validationlayers", + "description": "validationlayers", + "version": "4.0", + "license": "Apache-2.0", + "publishAs": "code-segment", + "segment": { + "destPath": "third_party/vulkan-validationlayers" + }, + "dirs": {}, + "scripts": {}, + "licensePath": "CODE_OF_CONDUCT.md", + "readmePath": { + "en": "README.md" + }, + "component": { + "name": "vulkan-validationlayers", + "subsystem": "thirdparty", + "syscap": [], + "features": [], + "adapted_system_type": ["standard"], + "rom": "1", + "ram": "1", + "deps": { + "components": ["vulkan-headers"], + "third_party": ["vulkan-headers"] + }, + "build": { + "sub_component": [ + "//third_party/vulkan-validationlayers:VkLayer_khronos_validation" + ], + "inner_kits": [ + { + "type": "so", + "name": "//third_party/vulkan-validationlayers:VkLayer_khronos_validation", + "header": { + "header_files": [ + ], + "header_base": "//third_party/vulkan-validationlayers" + } + } + ] + } + } +} \ No newline at end of file diff --git a/docs/images/vulkan-validationlayers_architecture_in_OH.png b/docs/images/vulkan-validationlayers_architecture_in_OH.png new file mode 100644 index 0000000000000000000000000000000000000000..c32d6be35785db3beb749edfa3daef7926e5a526 Binary files /dev/null and b/docs/images/vulkan-validationlayers_architecture_in_OH.png differ diff --git a/docs/images/vulkan-validationlayers_load_way_in_OH.png b/docs/images/vulkan-validationlayers_load_way_in_OH.png new file mode 100644 index 0000000000000000000000000000000000000000..20802703063bda0fa5118fa40f93ea53291b06ec Binary files /dev/null and b/docs/images/vulkan-validationlayers_load_way_in_OH.png differ diff --git a/graphic_2d.patch b/graphic_2d.patch new file mode 100644 index 0000000000000000000000000000000000000000..4cd33f06d7ba36fc4dc34ebc4f65865b6423d03f --- /dev/null +++ b/graphic_2d.patch @@ -0,0 +1,24 @@ +diff --git a/bundle.json b/bundle.json +index 3c54d54bb1..f6f0e08efb 100644 +--- a/bundle.json ++++ b/bundle.json +@@ -113,7 +113,8 @@ + "egl", + "opengles", + "vulkan-headers", +- "vulkan-loader" ++ "vulkan-loader", ++ "vulkan-validationlayers" + ] + }, + "build": { +@@ -138,7 +139,8 @@ + "//foundation/graphic/graphic_2d/rosen/modules/texgine:libtexgine", + "//foundation/graphic/graphic_2d/frameworks/vulkan_layers:vulkan_swapchain_layer", + "//foundation/graphic/graphic_2d/frameworks/vulkan_layers:vulkan_swapchain_layer_json", +- "//foundation/graphic/graphic_2d/rosen/modules/graphics_effect:libgraphics_effect" ++ "//foundation/graphic/graphic_2d/rosen/modules/graphics_effect:libgraphics_effect", ++ "//third_party/vulkan-validationlayers:VkLayer_khronos_validation" + ], + "fwk_group": [ + "//foundation/graphic/graphic_2d/rosen/modules/render_service_base:librender_service_base", diff --git a/layers/VkLayer_khronos_validation.json.in b/layers/VkLayer_khronos_validation.json.in index de46dda05dc849c000287b78a2c50a0cdcc7ce28..7accd6d8b70a5466c9f419231ab134e6178ea229 100644 --- a/layers/VkLayer_khronos_validation.json.in +++ b/layers/VkLayer_khronos_validation.json.in @@ -12,7 +12,8 @@ "WINDOWS", "LINUX", "ANDROID", - "MACOS" + "MACOS", + "OHOS" ], "url": "https://vulkan.lunarg.com/doc/sdk/latest/windows/khronos_validation_layer.html", "instance_extensions": [ @@ -68,7 +69,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "status": "STABLE", "settings": [ @@ -205,7 +207,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "status": "STABLE", "settings": [ @@ -274,7 +277,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "status": "STABLE", "settings": [ @@ -494,7 +498,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -620,7 +625,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -634,7 +640,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -648,7 +655,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -662,7 +670,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -678,7 +687,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "settings": [ { @@ -986,7 +996,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "settings": [ { @@ -999,7 +1010,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ], "dependence": { "mode": "ALL", @@ -1062,7 +1074,8 @@ "platforms": [ "WINDOWS", "LINUX", - "ANDROID" + "ANDROID", + "OHOS" ], "dependence": { "mode": "ALL", @@ -1303,7 +1316,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -1345,7 +1359,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -1356,7 +1371,8 @@ "WINDOWS", "LINUX", "MACOS", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -1386,7 +1402,8 @@ "platforms": [ "WINDOWS", "LINUX", - "ANDROID" + "ANDROID", + "OHOS" ] }, { @@ -1396,7 +1413,8 @@ "platforms": [ "WINDOWS", "LINUX", - "ANDROID" + "ANDROID", + "OHOS" ] } ], diff --git a/layers/vulkan/generated/best_practices.cpp b/layers/vulkan/generated/best_practices.cpp index 4f6e699bd0a479c119094c7f0e6199754ac57586..b36db00f8e0e31dfa7b91235aa5066a20bbd445b 100644 --- a/layers/vulkan/generated/best_practices.cpp +++ b/layers/vulkan/generated/best_practices.cpp @@ -2825,6 +2825,57 @@ void BestPractices::PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +void BestPractices::PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) { + ValidationStateTracker::PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, record_obj); + + if (record_obj.result < VK_SUCCESS) { + LogErrorCode(record_obj); + } +} + +void BestPractices::PostCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence, const RecordObject& record_obj) { + ValidationStateTracker::PostCallRecordAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence, record_obj); + + if (record_obj.result < VK_SUCCESS) { + LogErrorCode(record_obj); + } +} + +void BestPractices::PostCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd, const RecordObject& record_obj) { + ValidationStateTracker::PostCallRecordQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, + pNativeFenceFd, record_obj); + + if (record_obj.result < VK_SUCCESS) { + LogErrorCode(record_obj); + } +} + +void BestPractices::PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const RecordObject& record_obj) { + ValidationStateTracker::PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, record_obj); + + if (record_obj.result < VK_SUCCESS) { + LogErrorCode(record_obj); + } +} + +void BestPractices::PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) { + ValidationStateTracker::PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, record_obj); + + if (record_obj.result < VK_SUCCESS) { + LogErrorCode(record_obj); + } +} +#endif // VK_USE_PLATFORM_OHOS + void BestPractices::PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, diff --git a/layers/vulkan/generated/best_practices.h b/layers/vulkan/generated/best_practices.h index a2e77f6f713ca8195a8c79402736d516dbf5c420..528c878c756f4c54d915c996591e3a7c473cdbfe 100644 --- a/layers/vulkan/generated/best_practices.h +++ b/layers/vulkan/generated/best_practices.h @@ -984,6 +984,25 @@ void PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _s VkScreenBufferPropertiesQNX* pProperties, const RecordObject& record_obj) override; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) override; + +void PostCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, + const RecordObject& record_obj) override; + +void PostCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd, const RecordObject& record_obj) override; + +void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const RecordObject& record_obj) override; + +void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) override; + +#endif // VK_USE_PLATFORM_OHOS void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, diff --git a/layers/vulkan/generated/chassis.cpp b/layers/vulkan/generated/chassis.cpp index a739a64ee5be25cae82d9f551a9f8806d7af6a8e..461d8e76835580ee3fb3e62a9dd3839b995ce64a 100644 --- a/layers/vulkan/generated/chassis.cpp +++ b/layers/vulkan/generated/chassis.cpp @@ -16348,6 +16348,158 @@ VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, con } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCreateSurfaceOHOS, VulkanTypedHandle(instance, kVulkanObjectTypeInstance)); + for (const ValidationObject* intercept : layer_data->object_dispatch) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkCreateSurfaceOHOS); + for (ValidationObject* intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, record_obj); + } + VkResult result = DispatchCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, record_obj); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkGetSwapchainGrallocUsageOHOS, VulkanTypedHandle(device, kVulkanObjectTypeDevice)); + for (const ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallValidateGetSwapchainGrallocUsageOHOS]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateGetSwapchainGrallocUsageOHOS(device, format, imageUsage, grallocUsage, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkGetSwapchainGrallocUsageOHOS); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetSwapchainGrallocUsageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetSwapchainGrallocUsageOHOS(device, format, imageUsage, grallocUsage, record_obj); + } + VkResult result = DispatchGetSwapchainGrallocUsageOHOS(device, format, imageUsage, grallocUsage); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetSwapchainGrallocUsageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetSwapchainGrallocUsageOHOS(device, format, imageUsage, grallocUsage, record_obj); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL AcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkAcquireImageOHOS, VulkanTypedHandle(device, kVulkanObjectTypeDevice)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateAcquireImageOHOS]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkAcquireImageOHOS); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordAcquireImageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence, record_obj); + } + VkResult result = DispatchAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordAcquireImageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence, record_obj); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL QueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkQueueSignalReleaseImageOHOS, VulkanTypedHandle(queue, kVulkanObjectTypeQueue)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateQueueSignalReleaseImageOHOS]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, + pNativeFenceFd, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkQueueSignalReleaseImageOHOS); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordQueueSignalReleaseImageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd, + record_obj); + } + VkResult result = DispatchQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordQueueSignalReleaseImageOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd, + record_obj); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkGetNativeBufferPropertiesOHOS, VulkanTypedHandle(device, kVulkanObjectTypeDevice)); + for (const ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateGetNativeBufferPropertiesOHOS(device, buffer, pProperties, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkGetNativeBufferPropertiesOHOS); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, record_obj); + } + VkResult result = DispatchGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, record_obj); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkGetMemoryNativeBufferOHOS, VulkanTypedHandle(device, kVulkanObjectTypeDevice)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetMemoryNativeBufferOHOS]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, error_obj); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + RecordObject record_obj(vvl::Func::vkGetMemoryNativeBufferOHOS); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, record_obj); + } + VkResult result = DispatchGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + record_obj.result = result; + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, record_obj); + } + return result; +} + +#endif // VK_USE_PLATFORM_OHOS VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -17728,6 +17880,14 @@ const vvl::unordered_map name_to_funcptr_map = { #ifdef VK_USE_PLATFORM_SCREEN_QNX {"vkGetScreenBufferPropertiesQNX", {kFuncTypeDev, (void*)GetScreenBufferPropertiesQNX}}, #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + {"vkCreateSurfaceOHOS", {kFuncTypeInst, (void*)CreateSurfaceOHOS}}, + {"vkGetSwapchainGrallocUsageOHOS", {kFuncTypeDev, (void*)GetSwapchainGrallocUsageOHOS}}, + {"vkAcquireImageOHOS", {kFuncTypeDev, (void*)AcquireImageOHOS}}, + {"vkQueueSignalReleaseImageOHOS", {kFuncTypeDev, (void*)QueueSignalReleaseImageOHOS}}, + {"vkGetNativeBufferPropertiesOHOS", {kFuncTypeDev, (void*)GetNativeBufferPropertiesOHOS}}, + {"vkGetMemoryNativeBufferOHOS", {kFuncTypeDev, (void*)GetMemoryNativeBufferOHOS}}, +#endif // VK_USE_PLATFORM_OHOS {"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}}, {"vkDestroyAccelerationStructureKHR", {kFuncTypeDev, (void*)DestroyAccelerationStructureKHR}}, {"vkCmdBuildAccelerationStructuresKHR", {kFuncTypeDev, (void*)CmdBuildAccelerationStructuresKHR}}, diff --git a/layers/vulkan/generated/chassis.h b/layers/vulkan/generated/chassis.h index 000ef3b5342bcc636ffcdf27360b8af387a69adc..96dace6b58db57aeecc61ec2bf9e684dd5eaff6f 100644 --- a/layers/vulkan/generated/chassis.h +++ b/layers/vulkan/generated/chassis.h @@ -2035,6 +2035,27 @@ VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, con VkScreenBufferPropertiesQNX* pProperties); #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage); + +VKAPI_ATTR VkResult VKAPI_CALL AcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL QueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd); + +VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); + +#endif // VK_USE_PLATFORM_OHOS VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -4454,6 +4475,26 @@ class ValidationObject { virtual void PreCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties, const RecordObject& record_obj) {}; virtual void PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties, const RecordObject& record_obj) {}; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, const RecordObject& record_obj) {}; + virtual void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, const RecordObject& record_obj) {}; + virtual bool PreCallValidateGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage, const RecordObject& record_obj) {}; + virtual void PostCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage, const RecordObject& record_obj) {}; + virtual bool PreCallValidateAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, const RecordObject& record_obj) {}; + virtual void PostCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, const RecordObject& record_obj) {}; + virtual bool PreCallValidateQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd, const RecordObject& record_obj) {}; + virtual void PostCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd, const RecordObject& record_obj) {}; + virtual bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, const RecordObject& record_obj) {}; + virtual void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, const RecordObject& record_obj) {}; + virtual bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) {}; + virtual void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) {}; +#endif // VK_USE_PLATFORM_OHOS virtual bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, const RecordObject& record_obj) {}; virtual void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, const RecordObject& record_obj) {}; diff --git a/layers/vulkan/generated/chassis_dispatch_helper.h b/layers/vulkan/generated/chassis_dispatch_helper.h index 98fe714e31d0a062d4828948735eed0f5bfaf368..a6be9b8fa1202a7f2db215ea84be96cfc47c2535 100644 --- a/layers/vulkan/generated/chassis_dispatch_helper.h +++ b/layers/vulkan/generated/chassis_dispatch_helper.h @@ -1620,6 +1620,21 @@ typedef enum InterceptId { InterceptIdPreCallValidateGetScreenBufferPropertiesQNX, InterceptIdPreCallRecordGetScreenBufferPropertiesQNX, InterceptIdPostCallRecordGetScreenBufferPropertiesQNX, + InterceptIdPreCallValidateGetSwapchainGrallocUsageOHOS, + InterceptIdPreCallRecordGetSwapchainGrallocUsageOHOS, + InterceptIdPostCallRecordGetSwapchainGrallocUsageOHOS, + InterceptIdPreCallValidateAcquireImageOHOS, + InterceptIdPreCallRecordAcquireImageOHOS, + InterceptIdPostCallRecordAcquireImageOHOS, + InterceptIdPreCallValidateQueueSignalReleaseImageOHOS, + InterceptIdPreCallRecordQueueSignalReleaseImageOHOS, + InterceptIdPostCallRecordQueueSignalReleaseImageOHOS, + InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS, + InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPreCallValidateGetMemoryNativeBufferOHOS, + InterceptIdPreCallRecordGetMemoryNativeBufferOHOS, + InterceptIdPostCallRecordGetMemoryNativeBufferOHOS, InterceptIdPreCallValidateCreateAccelerationStructureKHR, InterceptIdPreCallRecordCreateAccelerationStructureKHR, InterceptIdPostCallRecordCreateAccelerationStructureKHR, @@ -3366,6 +3381,23 @@ void ValidationObject::InitObjectDispatchVectors() { BUILD_DISPATCH_VECTOR(PreCallRecordGetScreenBufferPropertiesQNX); BUILD_DISPATCH_VECTOR(PostCallRecordGetScreenBufferPropertiesQNX); #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + BUILD_DISPATCH_VECTOR(PreCallValidateGetSwapchainGrallocUsageOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetSwapchainGrallocUsageOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetSwapchainGrallocUsageOHOS); + BUILD_DISPATCH_VECTOR(PreCallValidateAcquireImageOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordAcquireImageOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordAcquireImageOHOS); + BUILD_DISPATCH_VECTOR(PreCallValidateQueueSignalReleaseImageOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordQueueSignalReleaseImageOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordQueueSignalReleaseImageOHOS); + BUILD_DISPATCH_VECTOR(PreCallValidateGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryNativeBufferOHOS); +#endif // VK_USE_PLATFORM_OHOS BUILD_DISPATCH_VECTOR(PreCallValidateCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PreCallRecordCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PostCallRecordCreateAccelerationStructureKHR); diff --git a/layers/vulkan/generated/enum_flag_bits.h b/layers/vulkan/generated/enum_flag_bits.h index 68910f65e6168e7d28342482f0035f6f9a062a00..654062bd24c8fa1b8047da06bec3aa0e5eb27388 100644 --- a/layers/vulkan/generated/enum_flag_bits.h +++ b/layers/vulkan/generated/enum_flag_bits.h @@ -60,7 +60,7 @@ const VkCommandPoolCreateFlags AllVkCommandPoolCreateFlagBits = VK_COMMAND_POOL_ const VkQueryControlFlags AllVkQueryControlFlagBits = VK_QUERY_CONTROL_PRECISE_BIT; const VkCommandBufferUsageFlags AllVkCommandBufferUsageFlagBits = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT|VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT|VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; const VkMemoryAllocateFlags AllVkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT; -const VkExternalMemoryHandleTypeFlags AllVkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID|VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA|VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX; +const VkExternalMemoryHandleTypeFlags AllVkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID|VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT|VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA|VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OHOS; const VkExternalFenceHandleTypeFlags AllVkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT; const VkExternalSemaphoreHandleTypeFlags AllVkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA; const VkDescriptorBindingFlags AllVkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT|VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT|VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT|VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT; @@ -126,6 +126,9 @@ const VkOpticalFlowGridSizeFlagsNV AllVkOpticalFlowGridSizeFlagBitsNV = VK_OPTIC const VkOpticalFlowSessionCreateFlagsNV AllVkOpticalFlowSessionCreateFlagBitsNV = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV|VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV|VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV|VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV|VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV; const VkOpticalFlowExecuteFlagsNV AllVkOpticalFlowExecuteFlagBitsNV = VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV; const VkShaderCreateFlagsEXT AllVkShaderCreateFlagBitsEXT = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT|VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT|VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT|VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT|VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT|VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT|VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT; +#ifdef VK_USE_PLATFORM_OHOS +const VkSwapchainImageUsageFlagsOHOS AllVkSwapchainImageUsageFlagBitsOHOS = VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS; +#endif // VK_USE_PLATFORM_OHOS const VkBuildAccelerationStructureFlagsKHR AllVkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR|VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR|VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR|VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR|VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV|VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR; const VkAccelerationStructureCreateFlagsKHR AllVkAccelerationStructureCreateFlagBitsKHR = VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR|VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV; const VkQueryResultFlags AllVkQueryResultFlagBits = VK_QUERY_RESULT_64_BIT|VK_QUERY_RESULT_WAIT_BIT|VK_QUERY_RESULT_WITH_AVAILABILITY_BIT|VK_QUERY_RESULT_PARTIAL_BIT|VK_QUERY_RESULT_WITH_STATUS_BIT_KHR; diff --git a/layers/vulkan/generated/error_location_helper.cpp b/layers/vulkan/generated/error_location_helper.cpp index 8dc9c69dcae49388329730f15a75a54d2c6552e4..7dc11a468d29ee90b3e0fe3c0efd685a215128a4 100644 --- a/layers/vulkan/generated/error_location_helper.cpp +++ b/layers/vulkan/generated/error_location_helper.cpp @@ -33,6 +33,7 @@ const char* String(Func func) { {"INVALID_EMPTY", 15}, // Func::Empty {"vkAcquireDrmDisplayEXT", 23}, {"vkAcquireFullScreenExclusiveModeEXT", 36}, + {"vkAcquireImageOHOS", 19}, {"vkAcquireNextImage2KHR", 23}, {"vkAcquireNextImageKHR", 22}, {"vkAcquirePerformanceConfigurationINTEL", 39}, @@ -372,6 +373,7 @@ const char* String(Func func) { {"vkCreateShadersEXT", 19}, {"vkCreateSharedSwapchainsKHR", 28}, {"vkCreateStreamDescriptorSurfaceGGP", 35}, + {"vkCreateSurfaceOHOS", 20}, {"vkCreateSwapchainKHR", 21}, {"vkCreateValidationCacheEXT", 27}, {"vkCreateViSurfaceNN", 20}, @@ -533,6 +535,7 @@ const char* String(Func func) { {"vkGetMemoryFdKHR", 17}, {"vkGetMemoryFdPropertiesKHR", 27}, {"vkGetMemoryHostPointerPropertiesEXT", 36}, + {"vkGetMemoryNativeBufferOHOS", 28}, {"vkGetMemoryRemoteAddressNV", 27}, {"vkGetMemoryWin32HandleKHR", 26}, {"vkGetMemoryWin32HandleNV", 25}, @@ -540,6 +543,7 @@ const char* String(Func func) { {"vkGetMemoryZirconHandleFUCHSIA", 31}, {"vkGetMemoryZirconHandlePropertiesFUCHSIA", 41}, {"vkGetMicromapBuildSizesEXT", 27}, + {"vkGetNativeBufferPropertiesOHOS", 32}, {"vkGetPastPresentationTimingGOOGLE", 34}, {"vkGetPerformanceParameterINTEL", 31}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", 47}, @@ -635,6 +639,7 @@ const char* String(Func func) { {"vkGetShaderModuleCreateInfoIdentifierEXT", 41}, {"vkGetShaderModuleIdentifierEXT", 31}, {"vkGetSwapchainCounterEXT", 25}, + {"vkGetSwapchainGrallocUsageOHOS", 31}, {"vkGetSwapchainImagesKHR", 24}, {"vkGetSwapchainStatusKHR", 24}, {"vkGetValidationCacheDataEXT", 28}, @@ -659,6 +664,7 @@ const char* String(Func func) { {"vkQueueNotifyOutOfBandNV", 25}, {"vkQueuePresentKHR", 18}, {"vkQueueSetPerformanceConfigurationINTEL", 40}, + {"vkQueueSignalReleaseImageOHOS", 30}, {"vkQueueSubmit", 14}, {"vkQueueSubmit2", 15}, {"vkQueueSubmit2KHR", 18}, @@ -975,6 +981,7 @@ const char* String(Struct structure) { {"VkExternalBufferProperties", 27}, {"VkExternalFenceProperties", 26}, {"VkExternalFormatANDROID", 24}, + {"VkExternalFormatOHOS", 21}, {"VkExternalFormatQNX", 20}, {"VkExternalImageFormatProperties", 32}, {"VkExternalImageFormatPropertiesNV", 34}, @@ -1066,6 +1073,7 @@ const char* String(Struct structure) { {"VkImportMetalIOSurfaceInfoEXT", 30}, {"VkImportMetalSharedEventInfoEXT", 32}, {"VkImportMetalTextureInfoEXT", 28}, + {"VkImportNativeBufferInfoOHOS", 29}, {"VkImportScreenBufferInfoQNX", 28}, {"VkImportSemaphoreFdInfoKHR", 27}, {"VkImportSemaphoreWin32HandleInfoKHR", 36}, @@ -1095,6 +1103,7 @@ const char* String(Struct structure) { {"VkMemoryFdPropertiesKHR", 24}, {"VkMemoryGetAndroidHardwareBufferInfoANDROID", 44}, {"VkMemoryGetFdInfoKHR", 21}, + {"VkMemoryGetNativeBufferInfoOHOS", 32}, {"VkMemoryGetRemoteAddressInfoNV", 31}, {"VkMemoryGetWin32HandleInfoKHR", 30}, {"VkMemoryGetZirconHandleInfoFUCHSIA", 35}, @@ -1125,6 +1134,10 @@ const char* String(Struct structure) { {"VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM", 53}, {"VkMutableDescriptorTypeCreateInfoEXT", 37}, {"VkMutableDescriptorTypeListEXT", 31}, + {"VkNativeBufferFormatPropertiesOHOS", 35}, + {"VkNativeBufferOHOS", 19}, + {"VkNativeBufferPropertiesOHOS", 29}, + {"VkNativeBufferUsageOHOS", 24}, {"VkOffset2D", 11}, {"VkOffset3D", 11}, {"VkOpaqueCaptureDescriptorDataCreateInfoEXT", 43}, @@ -1326,6 +1339,7 @@ const char* String(Struct structure) { {"VkPhysicalDevicePresentBarrierFeaturesNV", 41}, {"VkPhysicalDevicePresentIdFeaturesKHR", 37}, {"VkPhysicalDevicePresentWaitFeaturesKHR", 39}, + {"VkPhysicalDevicePresentationPropertiesOHOS", 43}, {"VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", 56}, {"VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT", 52}, {"VkPhysicalDevicePrivateDataFeatures", 36}, @@ -1618,6 +1632,7 @@ const char* String(Struct structure) { {"VkSurfaceCapabilitiesFullScreenExclusiveEXT", 44}, {"VkSurfaceCapabilitiesKHR", 25}, {"VkSurfaceCapabilitiesPresentBarrierNV", 38}, + {"VkSurfaceCreateInfoOHOS", 24}, {"VkSurfaceFormat2KHR", 20}, {"VkSurfaceFormatKHR", 19}, {"VkSurfaceFullScreenExclusiveInfoEXT", 36}, @@ -1629,6 +1644,7 @@ const char* String(Struct structure) { {"VkSwapchainCounterCreateInfoEXT", 32}, {"VkSwapchainCreateInfoKHR", 25}, {"VkSwapchainDisplayNativeHdrCreateInfoAMD", 41}, + {"VkSwapchainImageCreateInfoOHOS", 31}, {"VkSwapchainLatencyCreateInfoNV", 31}, {"VkSwapchainPresentBarrierCreateInfoNV", 38}, {"VkSwapchainPresentFenceInfoEXT", 31}, @@ -1749,6 +1765,7 @@ const char* String(Field field) { {"KSize", 6}, {"MSize", 6}, {"NSize", 6}, + {"OHOSNativeBufferUsage", 22}, {"ResultType", 11}, {"a", 2}, {"aabbData", 9}, @@ -2367,6 +2384,7 @@ const char* String(Field field) { {"gopRemainingP", 14}, {"gpuRenderEndTimeUs", 19}, {"gpuRenderStartTimeUs", 21}, + {"grallocUsage", 13}, {"graphicsPipelineLibrary", 24}, {"graphicsPipelineLibraryFastLinking", 35}, {"graphicsPipelineLibraryIndependentInterpolationDecoration", 58}, @@ -2960,6 +2978,7 @@ const char* String(Field field) { {"naluSliceEntryCount", 20}, {"naluSliceSegmentEntryCount", 27}, {"name", 5}, + {"nativeFenceFd", 14}, {"negativeOneToOne", 17}, {"nestedCommandBuffer", 20}, {"nestedCommandBufferRendering", 29}, @@ -3287,6 +3306,7 @@ const char* String(Field field) { {"pNaluSliceSegmentEntries", 25}, {"pName", 6}, {"pNameInfo", 10}, + {"pNativeFenceFd", 15}, {"pNext", 6}, {"pNodeIndex", 11}, {"pNodeInfo", 10}, @@ -3967,6 +3987,7 @@ const char* String(Field field) { {"shadingRatePaletteSize", 23}, {"shadingRateTexelSize", 21}, {"shadingRateType", 16}, + {"sharedImage", 12}, {"sharedMemBytes", 15}, {"sharedPresentSupportedUsageFlags", 33}, {"sharingMode", 12}, @@ -4335,6 +4356,8 @@ bool IsFieldPointer(Field field) { case Field::dfb: case Field::displayName: case Field::dpy: + case Field::grallocUsage: + case Field::handle: case Field::hostAddress: case Field::opaqueCaptureDescriptorData: case Field::pAccelerationStructure: @@ -4618,6 +4641,7 @@ bool IsFieldPointer(Field field) { case Field::pNaluSliceSegmentEntries: case Field::pName: case Field::pNameInfo: + case Field::pNativeFenceFd: case Field::pNext: case Field::pNodeIndex: case Field::pNodeInfo: diff --git a/layers/vulkan/generated/error_location_helper.h b/layers/vulkan/generated/error_location_helper.h index 56511423a154e24d172ac04338b4cf824167b488..7970b1e8ad9f003980443a4c3880ca580bad7825 100644 --- a/layers/vulkan/generated/error_location_helper.h +++ b/layers/vulkan/generated/error_location_helper.h @@ -30,681 +30,687 @@ enum class Func { Empty = 0, vkAcquireDrmDisplayEXT = 1, vkAcquireFullScreenExclusiveModeEXT = 2, - vkAcquireNextImage2KHR = 3, - vkAcquireNextImageKHR = 4, - vkAcquirePerformanceConfigurationINTEL = 5, - vkAcquireProfilingLockKHR = 6, - vkAcquireWinrtDisplayNV = 7, - vkAcquireXlibDisplayEXT = 8, - vkAllocateCommandBuffers = 9, - vkAllocateDescriptorSets = 10, - vkAllocateMemory = 11, - vkBeginCommandBuffer = 12, - vkBindAccelerationStructureMemoryNV = 13, - vkBindBufferMemory = 14, - vkBindBufferMemory2 = 15, - vkBindBufferMemory2KHR = 16, - vkBindImageMemory = 17, - vkBindImageMemory2 = 18, - vkBindImageMemory2KHR = 19, - vkBindOpticalFlowSessionImageNV = 20, - vkBindVideoSessionMemoryKHR = 21, - vkBuildAccelerationStructuresKHR = 22, - vkBuildMicromapsEXT = 23, - vkCmdBeginConditionalRenderingEXT = 24, - vkCmdBeginDebugUtilsLabelEXT = 25, - vkCmdBeginQuery = 26, - vkCmdBeginQueryIndexedEXT = 27, - vkCmdBeginRenderPass = 28, - vkCmdBeginRenderPass2 = 29, - vkCmdBeginRenderPass2KHR = 30, - vkCmdBeginRendering = 31, - vkCmdBeginRenderingKHR = 32, - vkCmdBeginTransformFeedbackEXT = 33, - vkCmdBeginVideoCodingKHR = 34, - vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 35, - vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 36, - vkCmdBindDescriptorBuffersEXT = 37, - vkCmdBindDescriptorSets = 38, - vkCmdBindDescriptorSets2KHR = 39, - vkCmdBindIndexBuffer = 40, - vkCmdBindIndexBuffer2KHR = 41, - vkCmdBindInvocationMaskHUAWEI = 42, - vkCmdBindPipeline = 43, - vkCmdBindPipelineShaderGroupNV = 44, - vkCmdBindShadersEXT = 45, - vkCmdBindShadingRateImageNV = 46, - vkCmdBindTransformFeedbackBuffersEXT = 47, - vkCmdBindVertexBuffers = 48, - vkCmdBindVertexBuffers2 = 49, - vkCmdBindVertexBuffers2EXT = 50, - vkCmdBlitImage = 51, - vkCmdBlitImage2 = 52, - vkCmdBlitImage2KHR = 53, - vkCmdBuildAccelerationStructureNV = 54, - vkCmdBuildAccelerationStructuresIndirectKHR = 55, - vkCmdBuildAccelerationStructuresKHR = 56, - vkCmdBuildMicromapsEXT = 57, - vkCmdClearAttachments = 58, - vkCmdClearColorImage = 59, - vkCmdClearDepthStencilImage = 60, - vkCmdControlVideoCodingKHR = 61, - vkCmdCopyAccelerationStructureKHR = 62, - vkCmdCopyAccelerationStructureNV = 63, - vkCmdCopyAccelerationStructureToMemoryKHR = 64, - vkCmdCopyBuffer = 65, - vkCmdCopyBuffer2 = 66, - vkCmdCopyBuffer2KHR = 67, - vkCmdCopyBufferToImage = 68, - vkCmdCopyBufferToImage2 = 69, - vkCmdCopyBufferToImage2KHR = 70, - vkCmdCopyImage = 71, - vkCmdCopyImage2 = 72, - vkCmdCopyImage2KHR = 73, - vkCmdCopyImageToBuffer = 74, - vkCmdCopyImageToBuffer2 = 75, - vkCmdCopyImageToBuffer2KHR = 76, - vkCmdCopyMemoryIndirectNV = 77, - vkCmdCopyMemoryToAccelerationStructureKHR = 78, - vkCmdCopyMemoryToImageIndirectNV = 79, - vkCmdCopyMemoryToMicromapEXT = 80, - vkCmdCopyMicromapEXT = 81, - vkCmdCopyMicromapToMemoryEXT = 82, - vkCmdCopyQueryPoolResults = 83, - vkCmdCuLaunchKernelNVX = 84, - vkCmdCudaLaunchKernelNV = 85, - vkCmdDebugMarkerBeginEXT = 86, - vkCmdDebugMarkerEndEXT = 87, - vkCmdDebugMarkerInsertEXT = 88, - vkCmdDecodeVideoKHR = 89, - vkCmdDecompressMemoryIndirectCountNV = 90, - vkCmdDecompressMemoryNV = 91, - vkCmdDispatch = 92, - vkCmdDispatchBase = 93, - vkCmdDispatchBaseKHR = 94, - vkCmdDispatchGraphAMDX = 95, - vkCmdDispatchGraphIndirectAMDX = 96, - vkCmdDispatchGraphIndirectCountAMDX = 97, - vkCmdDispatchIndirect = 98, - vkCmdDraw = 99, - vkCmdDrawClusterHUAWEI = 100, - vkCmdDrawClusterIndirectHUAWEI = 101, - vkCmdDrawIndexed = 102, - vkCmdDrawIndexedIndirect = 103, - vkCmdDrawIndexedIndirectCount = 104, - vkCmdDrawIndexedIndirectCountAMD = 105, - vkCmdDrawIndexedIndirectCountKHR = 106, - vkCmdDrawIndirect = 107, - vkCmdDrawIndirectByteCountEXT = 108, - vkCmdDrawIndirectCount = 109, - vkCmdDrawIndirectCountAMD = 110, - vkCmdDrawIndirectCountKHR = 111, - vkCmdDrawMeshTasksEXT = 112, - vkCmdDrawMeshTasksIndirectCountEXT = 113, - vkCmdDrawMeshTasksIndirectCountNV = 114, - vkCmdDrawMeshTasksIndirectEXT = 115, - vkCmdDrawMeshTasksIndirectNV = 116, - vkCmdDrawMeshTasksNV = 117, - vkCmdDrawMultiEXT = 118, - vkCmdDrawMultiIndexedEXT = 119, - vkCmdEncodeVideoKHR = 120, - vkCmdEndConditionalRenderingEXT = 121, - vkCmdEndDebugUtilsLabelEXT = 122, - vkCmdEndQuery = 123, - vkCmdEndQueryIndexedEXT = 124, - vkCmdEndRenderPass = 125, - vkCmdEndRenderPass2 = 126, - vkCmdEndRenderPass2KHR = 127, - vkCmdEndRendering = 128, - vkCmdEndRenderingKHR = 129, - vkCmdEndTransformFeedbackEXT = 130, - vkCmdEndVideoCodingKHR = 131, - vkCmdExecuteCommands = 132, - vkCmdExecuteGeneratedCommandsNV = 133, - vkCmdFillBuffer = 134, - vkCmdInitializeGraphScratchMemoryAMDX = 135, - vkCmdInsertDebugUtilsLabelEXT = 136, - vkCmdNextSubpass = 137, - vkCmdNextSubpass2 = 138, - vkCmdNextSubpass2KHR = 139, - vkCmdOpticalFlowExecuteNV = 140, - vkCmdPipelineBarrier = 141, - vkCmdPipelineBarrier2 = 142, - vkCmdPipelineBarrier2KHR = 143, - vkCmdPreprocessGeneratedCommandsNV = 144, - vkCmdPushConstants = 145, - vkCmdPushConstants2KHR = 146, - vkCmdPushDescriptorSet2KHR = 147, - vkCmdPushDescriptorSetKHR = 148, - vkCmdPushDescriptorSetWithTemplate2KHR = 149, - vkCmdPushDescriptorSetWithTemplateKHR = 150, - vkCmdResetEvent = 151, - vkCmdResetEvent2 = 152, - vkCmdResetEvent2KHR = 153, - vkCmdResetQueryPool = 154, - vkCmdResolveImage = 155, - vkCmdResolveImage2 = 156, - vkCmdResolveImage2KHR = 157, - vkCmdSetAlphaToCoverageEnableEXT = 158, - vkCmdSetAlphaToOneEnableEXT = 159, - vkCmdSetAttachmentFeedbackLoopEnableEXT = 160, - vkCmdSetBlendConstants = 161, - vkCmdSetCheckpointNV = 162, - vkCmdSetCoarseSampleOrderNV = 163, - vkCmdSetColorBlendAdvancedEXT = 164, - vkCmdSetColorBlendEnableEXT = 165, - vkCmdSetColorBlendEquationEXT = 166, - vkCmdSetColorWriteEnableEXT = 167, - vkCmdSetColorWriteMaskEXT = 168, - vkCmdSetConservativeRasterizationModeEXT = 169, - vkCmdSetCoverageModulationModeNV = 170, - vkCmdSetCoverageModulationTableEnableNV = 171, - vkCmdSetCoverageModulationTableNV = 172, - vkCmdSetCoverageReductionModeNV = 173, - vkCmdSetCoverageToColorEnableNV = 174, - vkCmdSetCoverageToColorLocationNV = 175, - vkCmdSetCullMode = 176, - vkCmdSetCullModeEXT = 177, - vkCmdSetDepthBias = 178, - vkCmdSetDepthBias2EXT = 179, - vkCmdSetDepthBiasEnable = 180, - vkCmdSetDepthBiasEnableEXT = 181, - vkCmdSetDepthBounds = 182, - vkCmdSetDepthBoundsTestEnable = 183, - vkCmdSetDepthBoundsTestEnableEXT = 184, - vkCmdSetDepthClampEnableEXT = 185, - vkCmdSetDepthClipEnableEXT = 186, - vkCmdSetDepthClipNegativeOneToOneEXT = 187, - vkCmdSetDepthCompareOp = 188, - vkCmdSetDepthCompareOpEXT = 189, - vkCmdSetDepthTestEnable = 190, - vkCmdSetDepthTestEnableEXT = 191, - vkCmdSetDepthWriteEnable = 192, - vkCmdSetDepthWriteEnableEXT = 193, - vkCmdSetDescriptorBufferOffsets2EXT = 194, - vkCmdSetDescriptorBufferOffsetsEXT = 195, - vkCmdSetDeviceMask = 196, - vkCmdSetDeviceMaskKHR = 197, - vkCmdSetDiscardRectangleEXT = 198, - vkCmdSetDiscardRectangleEnableEXT = 199, - vkCmdSetDiscardRectangleModeEXT = 200, - vkCmdSetEvent = 201, - vkCmdSetEvent2 = 202, - vkCmdSetEvent2KHR = 203, - vkCmdSetExclusiveScissorEnableNV = 204, - vkCmdSetExclusiveScissorNV = 205, - vkCmdSetExtraPrimitiveOverestimationSizeEXT = 206, - vkCmdSetFragmentShadingRateEnumNV = 207, - vkCmdSetFragmentShadingRateKHR = 208, - vkCmdSetFrontFace = 209, - vkCmdSetFrontFaceEXT = 210, - vkCmdSetLineRasterizationModeEXT = 211, - vkCmdSetLineStippleEXT = 212, - vkCmdSetLineStippleEnableEXT = 213, - vkCmdSetLineWidth = 214, - vkCmdSetLogicOpEXT = 215, - vkCmdSetLogicOpEnableEXT = 216, - vkCmdSetPatchControlPointsEXT = 217, - vkCmdSetPerformanceMarkerINTEL = 218, - vkCmdSetPerformanceOverrideINTEL = 219, - vkCmdSetPerformanceStreamMarkerINTEL = 220, - vkCmdSetPolygonModeEXT = 221, - vkCmdSetPrimitiveRestartEnable = 222, - vkCmdSetPrimitiveRestartEnableEXT = 223, - vkCmdSetPrimitiveTopology = 224, - vkCmdSetPrimitiveTopologyEXT = 225, - vkCmdSetProvokingVertexModeEXT = 226, - vkCmdSetRasterizationSamplesEXT = 227, - vkCmdSetRasterizationStreamEXT = 228, - vkCmdSetRasterizerDiscardEnable = 229, - vkCmdSetRasterizerDiscardEnableEXT = 230, - vkCmdSetRayTracingPipelineStackSizeKHR = 231, - vkCmdSetRepresentativeFragmentTestEnableNV = 232, - vkCmdSetSampleLocationsEXT = 233, - vkCmdSetSampleLocationsEnableEXT = 234, - vkCmdSetSampleMaskEXT = 235, - vkCmdSetScissor = 236, - vkCmdSetScissorWithCount = 237, - vkCmdSetScissorWithCountEXT = 238, - vkCmdSetShadingRateImageEnableNV = 239, - vkCmdSetStencilCompareMask = 240, - vkCmdSetStencilOp = 241, - vkCmdSetStencilOpEXT = 242, - vkCmdSetStencilReference = 243, - vkCmdSetStencilTestEnable = 244, - vkCmdSetStencilTestEnableEXT = 245, - vkCmdSetStencilWriteMask = 246, - vkCmdSetTessellationDomainOriginEXT = 247, - vkCmdSetVertexInputEXT = 248, - vkCmdSetViewport = 249, - vkCmdSetViewportShadingRatePaletteNV = 250, - vkCmdSetViewportSwizzleNV = 251, - vkCmdSetViewportWScalingEnableNV = 252, - vkCmdSetViewportWScalingNV = 253, - vkCmdSetViewportWithCount = 254, - vkCmdSetViewportWithCountEXT = 255, - vkCmdSubpassShadingHUAWEI = 256, - vkCmdTraceRaysIndirect2KHR = 257, - vkCmdTraceRaysIndirectKHR = 258, - vkCmdTraceRaysKHR = 259, - vkCmdTraceRaysNV = 260, - vkCmdUpdateBuffer = 261, - vkCmdUpdatePipelineIndirectBufferNV = 262, - vkCmdWaitEvents = 263, - vkCmdWaitEvents2 = 264, - vkCmdWaitEvents2KHR = 265, - vkCmdWriteAccelerationStructuresPropertiesKHR = 266, - vkCmdWriteAccelerationStructuresPropertiesNV = 267, - vkCmdWriteBufferMarker2AMD = 268, - vkCmdWriteBufferMarkerAMD = 269, - vkCmdWriteMicromapsPropertiesEXT = 270, - vkCmdWriteTimestamp = 271, - vkCmdWriteTimestamp2 = 272, - vkCmdWriteTimestamp2KHR = 273, - vkCompileDeferredNV = 274, - vkCopyAccelerationStructureKHR = 275, - vkCopyAccelerationStructureToMemoryKHR = 276, - vkCopyImageToImageEXT = 277, - vkCopyImageToMemoryEXT = 278, - vkCopyMemoryToAccelerationStructureKHR = 279, - vkCopyMemoryToImageEXT = 280, - vkCopyMemoryToMicromapEXT = 281, - vkCopyMicromapEXT = 282, - vkCopyMicromapToMemoryEXT = 283, - vkCreateAccelerationStructureKHR = 284, - vkCreateAccelerationStructureNV = 285, - vkCreateAndroidSurfaceKHR = 286, - vkCreateBuffer = 287, - vkCreateBufferCollectionFUCHSIA = 288, - vkCreateBufferView = 289, - vkCreateCommandPool = 290, - vkCreateComputePipelines = 291, - vkCreateCuFunctionNVX = 292, - vkCreateCuModuleNVX = 293, - vkCreateCudaFunctionNV = 294, - vkCreateCudaModuleNV = 295, - vkCreateDebugReportCallbackEXT = 296, - vkCreateDebugUtilsMessengerEXT = 297, - vkCreateDeferredOperationKHR = 298, - vkCreateDescriptorPool = 299, - vkCreateDescriptorSetLayout = 300, - vkCreateDescriptorUpdateTemplate = 301, - vkCreateDescriptorUpdateTemplateKHR = 302, - vkCreateDevice = 303, - vkCreateDirectFBSurfaceEXT = 304, - vkCreateDisplayModeKHR = 305, - vkCreateDisplayPlaneSurfaceKHR = 306, - vkCreateEvent = 307, - vkCreateExecutionGraphPipelinesAMDX = 308, - vkCreateFence = 309, - vkCreateFramebuffer = 310, - vkCreateGraphicsPipelines = 311, - vkCreateHeadlessSurfaceEXT = 312, - vkCreateIOSSurfaceMVK = 313, - vkCreateImage = 314, - vkCreateImagePipeSurfaceFUCHSIA = 315, - vkCreateImageView = 316, - vkCreateIndirectCommandsLayoutNV = 317, - vkCreateInstance = 318, - vkCreateMacOSSurfaceMVK = 319, - vkCreateMetalSurfaceEXT = 320, - vkCreateMicromapEXT = 321, - vkCreateOpticalFlowSessionNV = 322, - vkCreatePipelineCache = 323, - vkCreatePipelineLayout = 324, - vkCreatePrivateDataSlot = 325, - vkCreatePrivateDataSlotEXT = 326, - vkCreateQueryPool = 327, - vkCreateRayTracingPipelinesKHR = 328, - vkCreateRayTracingPipelinesNV = 329, - vkCreateRenderPass = 330, - vkCreateRenderPass2 = 331, - vkCreateRenderPass2KHR = 332, - vkCreateSampler = 333, - vkCreateSamplerYcbcrConversion = 334, - vkCreateSamplerYcbcrConversionKHR = 335, - vkCreateScreenSurfaceQNX = 336, - vkCreateSemaphore = 337, - vkCreateShaderModule = 338, - vkCreateShadersEXT = 339, - vkCreateSharedSwapchainsKHR = 340, - vkCreateStreamDescriptorSurfaceGGP = 341, - vkCreateSwapchainKHR = 342, - vkCreateValidationCacheEXT = 343, - vkCreateViSurfaceNN = 344, - vkCreateVideoSessionKHR = 345, - vkCreateVideoSessionParametersKHR = 346, - vkCreateWaylandSurfaceKHR = 347, - vkCreateWin32SurfaceKHR = 348, - vkCreateXcbSurfaceKHR = 349, - vkCreateXlibSurfaceKHR = 350, - vkDebugMarkerSetObjectNameEXT = 351, - vkDebugMarkerSetObjectTagEXT = 352, - vkDebugReportMessageEXT = 353, - vkDeferredOperationJoinKHR = 354, - vkDestroyAccelerationStructureKHR = 355, - vkDestroyAccelerationStructureNV = 356, - vkDestroyBuffer = 357, - vkDestroyBufferCollectionFUCHSIA = 358, - vkDestroyBufferView = 359, - vkDestroyCommandPool = 360, - vkDestroyCuFunctionNVX = 361, - vkDestroyCuModuleNVX = 362, - vkDestroyCudaFunctionNV = 363, - vkDestroyCudaModuleNV = 364, - vkDestroyDebugReportCallbackEXT = 365, - vkDestroyDebugUtilsMessengerEXT = 366, - vkDestroyDeferredOperationKHR = 367, - vkDestroyDescriptorPool = 368, - vkDestroyDescriptorSetLayout = 369, - vkDestroyDescriptorUpdateTemplate = 370, - vkDestroyDescriptorUpdateTemplateKHR = 371, - vkDestroyDevice = 372, - vkDestroyEvent = 373, - vkDestroyFence = 374, - vkDestroyFramebuffer = 375, - vkDestroyImage = 376, - vkDestroyImageView = 377, - vkDestroyIndirectCommandsLayoutNV = 378, - vkDestroyInstance = 379, - vkDestroyMicromapEXT = 380, - vkDestroyOpticalFlowSessionNV = 381, - vkDestroyPipeline = 382, - vkDestroyPipelineCache = 383, - vkDestroyPipelineLayout = 384, - vkDestroyPrivateDataSlot = 385, - vkDestroyPrivateDataSlotEXT = 386, - vkDestroyQueryPool = 387, - vkDestroyRenderPass = 388, - vkDestroySampler = 389, - vkDestroySamplerYcbcrConversion = 390, - vkDestroySamplerYcbcrConversionKHR = 391, - vkDestroySemaphore = 392, - vkDestroyShaderEXT = 393, - vkDestroyShaderModule = 394, - vkDestroySurfaceKHR = 395, - vkDestroySwapchainKHR = 396, - vkDestroyValidationCacheEXT = 397, - vkDestroyVideoSessionKHR = 398, - vkDestroyVideoSessionParametersKHR = 399, - vkDeviceWaitIdle = 400, - vkDisplayPowerControlEXT = 401, - vkEndCommandBuffer = 402, - vkEnumerateDeviceExtensionProperties = 403, - vkEnumerateDeviceLayerProperties = 404, - vkEnumerateInstanceExtensionProperties = 405, - vkEnumerateInstanceLayerProperties = 406, - vkEnumerateInstanceVersion = 407, - vkEnumeratePhysicalDeviceGroups = 408, - vkEnumeratePhysicalDeviceGroupsKHR = 409, - vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 410, - vkEnumeratePhysicalDevices = 411, - vkExportMetalObjectsEXT = 412, - vkFlushMappedMemoryRanges = 413, - vkFreeCommandBuffers = 414, - vkFreeDescriptorSets = 415, - vkFreeMemory = 416, - vkGetAccelerationStructureBuildSizesKHR = 417, - vkGetAccelerationStructureDeviceAddressKHR = 418, - vkGetAccelerationStructureHandleNV = 419, - vkGetAccelerationStructureMemoryRequirementsNV = 420, - vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 421, - vkGetAndroidHardwareBufferPropertiesANDROID = 422, - vkGetBufferCollectionPropertiesFUCHSIA = 423, - vkGetBufferDeviceAddress = 424, - vkGetBufferDeviceAddressEXT = 425, - vkGetBufferDeviceAddressKHR = 426, - vkGetBufferMemoryRequirements = 427, - vkGetBufferMemoryRequirements2 = 428, - vkGetBufferMemoryRequirements2KHR = 429, - vkGetBufferOpaqueCaptureAddress = 430, - vkGetBufferOpaqueCaptureAddressKHR = 431, - vkGetBufferOpaqueCaptureDescriptorDataEXT = 432, - vkGetCalibratedTimestampsEXT = 433, - vkGetCalibratedTimestampsKHR = 434, - vkGetCudaModuleCacheNV = 435, - vkGetDeferredOperationMaxConcurrencyKHR = 436, - vkGetDeferredOperationResultKHR = 437, - vkGetDescriptorEXT = 438, - vkGetDescriptorSetHostMappingVALVE = 439, - vkGetDescriptorSetLayoutBindingOffsetEXT = 440, - vkGetDescriptorSetLayoutHostMappingInfoVALVE = 441, - vkGetDescriptorSetLayoutSizeEXT = 442, - vkGetDescriptorSetLayoutSupport = 443, - vkGetDescriptorSetLayoutSupportKHR = 444, - vkGetDeviceAccelerationStructureCompatibilityKHR = 445, - vkGetDeviceBufferMemoryRequirements = 446, - vkGetDeviceBufferMemoryRequirementsKHR = 447, - vkGetDeviceFaultInfoEXT = 448, - vkGetDeviceGroupPeerMemoryFeatures = 449, - vkGetDeviceGroupPeerMemoryFeaturesKHR = 450, - vkGetDeviceGroupPresentCapabilitiesKHR = 451, - vkGetDeviceGroupSurfacePresentModes2EXT = 452, - vkGetDeviceGroupSurfacePresentModesKHR = 453, - vkGetDeviceImageMemoryRequirements = 454, - vkGetDeviceImageMemoryRequirementsKHR = 455, - vkGetDeviceImageSparseMemoryRequirements = 456, - vkGetDeviceImageSparseMemoryRequirementsKHR = 457, - vkGetDeviceImageSubresourceLayoutKHR = 458, - vkGetDeviceMemoryCommitment = 459, - vkGetDeviceMemoryOpaqueCaptureAddress = 460, - vkGetDeviceMemoryOpaqueCaptureAddressKHR = 461, - vkGetDeviceMicromapCompatibilityEXT = 462, - vkGetDeviceProcAddr = 463, - vkGetDeviceQueue = 464, - vkGetDeviceQueue2 = 465, - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 466, - vkGetDisplayModeProperties2KHR = 467, - vkGetDisplayModePropertiesKHR = 468, - vkGetDisplayPlaneCapabilities2KHR = 469, - vkGetDisplayPlaneCapabilitiesKHR = 470, - vkGetDisplayPlaneSupportedDisplaysKHR = 471, - vkGetDrmDisplayEXT = 472, - vkGetDynamicRenderingTilePropertiesQCOM = 473, - vkGetEncodedVideoSessionParametersKHR = 474, - vkGetEventStatus = 475, - vkGetExecutionGraphPipelineNodeIndexAMDX = 476, - vkGetExecutionGraphPipelineScratchSizeAMDX = 477, - vkGetFenceFdKHR = 478, - vkGetFenceStatus = 479, - vkGetFenceWin32HandleKHR = 480, - vkGetFramebufferTilePropertiesQCOM = 481, - vkGetGeneratedCommandsMemoryRequirementsNV = 482, - vkGetImageDrmFormatModifierPropertiesEXT = 483, - vkGetImageMemoryRequirements = 484, - vkGetImageMemoryRequirements2 = 485, - vkGetImageMemoryRequirements2KHR = 486, - vkGetImageOpaqueCaptureDescriptorDataEXT = 487, - vkGetImageSparseMemoryRequirements = 488, - vkGetImageSparseMemoryRequirements2 = 489, - vkGetImageSparseMemoryRequirements2KHR = 490, - vkGetImageSubresourceLayout = 491, - vkGetImageSubresourceLayout2EXT = 492, - vkGetImageSubresourceLayout2KHR = 493, - vkGetImageViewAddressNVX = 494, - vkGetImageViewHandleNVX = 495, - vkGetImageViewOpaqueCaptureDescriptorDataEXT = 496, - vkGetInstanceProcAddr = 497, - vkGetLatencyTimingsNV = 498, - vkGetMemoryAndroidHardwareBufferANDROID = 499, - vkGetMemoryFdKHR = 500, - vkGetMemoryFdPropertiesKHR = 501, - vkGetMemoryHostPointerPropertiesEXT = 502, - vkGetMemoryRemoteAddressNV = 503, - vkGetMemoryWin32HandleKHR = 504, - vkGetMemoryWin32HandleNV = 505, - vkGetMemoryWin32HandlePropertiesKHR = 506, - vkGetMemoryZirconHandleFUCHSIA = 507, - vkGetMemoryZirconHandlePropertiesFUCHSIA = 508, - vkGetMicromapBuildSizesEXT = 509, - vkGetPastPresentationTimingGOOGLE = 510, - vkGetPerformanceParameterINTEL = 511, - vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 512, - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 513, - vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 514, - vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 515, - vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 516, - vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 517, - vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 518, - vkGetPhysicalDeviceDisplayProperties2KHR = 519, - vkGetPhysicalDeviceDisplayPropertiesKHR = 520, - vkGetPhysicalDeviceExternalBufferProperties = 521, - vkGetPhysicalDeviceExternalBufferPropertiesKHR = 522, - vkGetPhysicalDeviceExternalFenceProperties = 523, - vkGetPhysicalDeviceExternalFencePropertiesKHR = 524, - vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 525, - vkGetPhysicalDeviceExternalSemaphoreProperties = 526, - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 527, - vkGetPhysicalDeviceFeatures = 528, - vkGetPhysicalDeviceFeatures2 = 529, - vkGetPhysicalDeviceFeatures2KHR = 530, - vkGetPhysicalDeviceFormatProperties = 531, - vkGetPhysicalDeviceFormatProperties2 = 532, - vkGetPhysicalDeviceFormatProperties2KHR = 533, - vkGetPhysicalDeviceFragmentShadingRatesKHR = 534, - vkGetPhysicalDeviceImageFormatProperties = 535, - vkGetPhysicalDeviceImageFormatProperties2 = 536, - vkGetPhysicalDeviceImageFormatProperties2KHR = 537, - vkGetPhysicalDeviceMemoryProperties = 538, - vkGetPhysicalDeviceMemoryProperties2 = 539, - vkGetPhysicalDeviceMemoryProperties2KHR = 540, - vkGetPhysicalDeviceMultisamplePropertiesEXT = 541, - vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 542, - vkGetPhysicalDevicePresentRectanglesKHR = 543, - vkGetPhysicalDeviceProperties = 544, - vkGetPhysicalDeviceProperties2 = 545, - vkGetPhysicalDeviceProperties2KHR = 546, - vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 547, - vkGetPhysicalDeviceQueueFamilyProperties = 548, - vkGetPhysicalDeviceQueueFamilyProperties2 = 549, - vkGetPhysicalDeviceQueueFamilyProperties2KHR = 550, - vkGetPhysicalDeviceScreenPresentationSupportQNX = 551, - vkGetPhysicalDeviceSparseImageFormatProperties = 552, - vkGetPhysicalDeviceSparseImageFormatProperties2 = 553, - vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 554, - vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 555, - vkGetPhysicalDeviceSurfaceCapabilities2EXT = 556, - vkGetPhysicalDeviceSurfaceCapabilities2KHR = 557, - vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 558, - vkGetPhysicalDeviceSurfaceFormats2KHR = 559, - vkGetPhysicalDeviceSurfaceFormatsKHR = 560, - vkGetPhysicalDeviceSurfacePresentModes2EXT = 561, - vkGetPhysicalDeviceSurfacePresentModesKHR = 562, - vkGetPhysicalDeviceSurfaceSupportKHR = 563, - vkGetPhysicalDeviceToolProperties = 564, - vkGetPhysicalDeviceToolPropertiesEXT = 565, - vkGetPhysicalDeviceVideoCapabilitiesKHR = 566, - vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 567, - vkGetPhysicalDeviceVideoFormatPropertiesKHR = 568, - vkGetPhysicalDeviceWaylandPresentationSupportKHR = 569, - vkGetPhysicalDeviceWin32PresentationSupportKHR = 570, - vkGetPhysicalDeviceXcbPresentationSupportKHR = 571, - vkGetPhysicalDeviceXlibPresentationSupportKHR = 572, - vkGetPipelineCacheData = 573, - vkGetPipelineExecutableInternalRepresentationsKHR = 574, - vkGetPipelineExecutablePropertiesKHR = 575, - vkGetPipelineExecutableStatisticsKHR = 576, - vkGetPipelineIndirectDeviceAddressNV = 577, - vkGetPipelineIndirectMemoryRequirementsNV = 578, - vkGetPipelinePropertiesEXT = 579, - vkGetPrivateData = 580, - vkGetPrivateDataEXT = 581, - vkGetQueryPoolResults = 582, - vkGetQueueCheckpointData2NV = 583, - vkGetQueueCheckpointDataNV = 584, - vkGetRandROutputDisplayEXT = 585, - vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 586, - vkGetRayTracingShaderGroupHandlesKHR = 587, - vkGetRayTracingShaderGroupHandlesNV = 588, - vkGetRayTracingShaderGroupStackSizeKHR = 589, - vkGetRefreshCycleDurationGOOGLE = 590, - vkGetRenderAreaGranularity = 591, - vkGetRenderingAreaGranularityKHR = 592, - vkGetSamplerOpaqueCaptureDescriptorDataEXT = 593, - vkGetScreenBufferPropertiesQNX = 594, - vkGetSemaphoreCounterValue = 595, - vkGetSemaphoreCounterValueKHR = 596, - vkGetSemaphoreFdKHR = 597, - vkGetSemaphoreWin32HandleKHR = 598, - vkGetSemaphoreZirconHandleFUCHSIA = 599, - vkGetShaderBinaryDataEXT = 600, - vkGetShaderInfoAMD = 601, - vkGetShaderModuleCreateInfoIdentifierEXT = 602, - vkGetShaderModuleIdentifierEXT = 603, - vkGetSwapchainCounterEXT = 604, - vkGetSwapchainImagesKHR = 605, - vkGetSwapchainStatusKHR = 606, - vkGetValidationCacheDataEXT = 607, - vkGetVideoSessionMemoryRequirementsKHR = 608, - vkGetWinrtDisplayNV = 609, - vkImportFenceFdKHR = 610, - vkImportFenceWin32HandleKHR = 611, - vkImportSemaphoreFdKHR = 612, - vkImportSemaphoreWin32HandleKHR = 613, - vkImportSemaphoreZirconHandleFUCHSIA = 614, - vkInitializePerformanceApiINTEL = 615, - vkInvalidateMappedMemoryRanges = 616, - vkLatencySleepNV = 617, - vkMapMemory = 618, - vkMapMemory2KHR = 619, - vkMergePipelineCaches = 620, - vkMergeValidationCachesEXT = 621, - vkQueueBeginDebugUtilsLabelEXT = 622, - vkQueueBindSparse = 623, - vkQueueEndDebugUtilsLabelEXT = 624, - vkQueueInsertDebugUtilsLabelEXT = 625, - vkQueueNotifyOutOfBandNV = 626, - vkQueuePresentKHR = 627, - vkQueueSetPerformanceConfigurationINTEL = 628, - vkQueueSubmit = 629, - vkQueueSubmit2 = 630, - vkQueueSubmit2KHR = 631, - vkQueueWaitIdle = 632, - vkRegisterDeviceEventEXT = 633, - vkRegisterDisplayEventEXT = 634, - vkReleaseDisplayEXT = 635, - vkReleaseFullScreenExclusiveModeEXT = 636, - vkReleasePerformanceConfigurationINTEL = 637, - vkReleaseProfilingLockKHR = 638, - vkReleaseSwapchainImagesEXT = 639, - vkResetCommandBuffer = 640, - vkResetCommandPool = 641, - vkResetDescriptorPool = 642, - vkResetEvent = 643, - vkResetFences = 644, - vkResetQueryPool = 645, - vkResetQueryPoolEXT = 646, - vkSetBufferCollectionBufferConstraintsFUCHSIA = 647, - vkSetBufferCollectionImageConstraintsFUCHSIA = 648, - vkSetDebugUtilsObjectNameEXT = 649, - vkSetDebugUtilsObjectTagEXT = 650, - vkSetDeviceMemoryPriorityEXT = 651, - vkSetEvent = 652, - vkSetHdrMetadataEXT = 653, - vkSetLatencyMarkerNV = 654, - vkSetLatencySleepModeNV = 655, - vkSetLocalDimmingAMD = 656, - vkSetPrivateData = 657, - vkSetPrivateDataEXT = 658, - vkSignalSemaphore = 659, - vkSignalSemaphoreKHR = 660, - vkSubmitDebugUtilsMessageEXT = 661, - vkTransitionImageLayoutEXT = 662, - vkTrimCommandPool = 663, - vkTrimCommandPoolKHR = 664, - vkUninitializePerformanceApiINTEL = 665, - vkUnmapMemory = 666, - vkUnmapMemory2KHR = 667, - vkUpdateDescriptorSetWithTemplate = 668, - vkUpdateDescriptorSetWithTemplateKHR = 669, - vkUpdateDescriptorSets = 670, - vkUpdateVideoSessionParametersKHR = 671, - vkWaitForFences = 672, - vkWaitForPresentKHR = 673, - vkWaitSemaphores = 674, - vkWaitSemaphoresKHR = 675, - vkWriteAccelerationStructuresPropertiesKHR = 676, - vkWriteMicromapsPropertiesEXT = 677, + vkAcquireImageOHOS = 3, + vkAcquireNextImage2KHR = 4, + vkAcquireNextImageKHR = 5, + vkAcquirePerformanceConfigurationINTEL = 6, + vkAcquireProfilingLockKHR = 7, + vkAcquireWinrtDisplayNV = 8, + vkAcquireXlibDisplayEXT = 9, + vkAllocateCommandBuffers = 10, + vkAllocateDescriptorSets = 11, + vkAllocateMemory = 12, + vkBeginCommandBuffer = 13, + vkBindAccelerationStructureMemoryNV = 14, + vkBindBufferMemory = 15, + vkBindBufferMemory2 = 16, + vkBindBufferMemory2KHR = 17, + vkBindImageMemory = 18, + vkBindImageMemory2 = 19, + vkBindImageMemory2KHR = 20, + vkBindOpticalFlowSessionImageNV = 21, + vkBindVideoSessionMemoryKHR = 22, + vkBuildAccelerationStructuresKHR = 23, + vkBuildMicromapsEXT = 24, + vkCmdBeginConditionalRenderingEXT = 25, + vkCmdBeginDebugUtilsLabelEXT = 26, + vkCmdBeginQuery = 27, + vkCmdBeginQueryIndexedEXT = 28, + vkCmdBeginRenderPass = 29, + vkCmdBeginRenderPass2 = 30, + vkCmdBeginRenderPass2KHR = 31, + vkCmdBeginRendering = 32, + vkCmdBeginRenderingKHR = 33, + vkCmdBeginTransformFeedbackEXT = 34, + vkCmdBeginVideoCodingKHR = 35, + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 36, + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 37, + vkCmdBindDescriptorBuffersEXT = 38, + vkCmdBindDescriptorSets = 39, + vkCmdBindDescriptorSets2KHR = 40, + vkCmdBindIndexBuffer = 41, + vkCmdBindIndexBuffer2KHR = 42, + vkCmdBindInvocationMaskHUAWEI = 43, + vkCmdBindPipeline = 44, + vkCmdBindPipelineShaderGroupNV = 45, + vkCmdBindShadersEXT = 46, + vkCmdBindShadingRateImageNV = 47, + vkCmdBindTransformFeedbackBuffersEXT = 48, + vkCmdBindVertexBuffers = 49, + vkCmdBindVertexBuffers2 = 50, + vkCmdBindVertexBuffers2EXT = 51, + vkCmdBlitImage = 52, + vkCmdBlitImage2 = 53, + vkCmdBlitImage2KHR = 54, + vkCmdBuildAccelerationStructureNV = 55, + vkCmdBuildAccelerationStructuresIndirectKHR = 56, + vkCmdBuildAccelerationStructuresKHR = 57, + vkCmdBuildMicromapsEXT = 58, + vkCmdClearAttachments = 59, + vkCmdClearColorImage = 60, + vkCmdClearDepthStencilImage = 61, + vkCmdControlVideoCodingKHR = 62, + vkCmdCopyAccelerationStructureKHR = 63, + vkCmdCopyAccelerationStructureNV = 64, + vkCmdCopyAccelerationStructureToMemoryKHR = 65, + vkCmdCopyBuffer = 66, + vkCmdCopyBuffer2 = 67, + vkCmdCopyBuffer2KHR = 68, + vkCmdCopyBufferToImage = 69, + vkCmdCopyBufferToImage2 = 70, + vkCmdCopyBufferToImage2KHR = 71, + vkCmdCopyImage = 72, + vkCmdCopyImage2 = 73, + vkCmdCopyImage2KHR = 74, + vkCmdCopyImageToBuffer = 75, + vkCmdCopyImageToBuffer2 = 76, + vkCmdCopyImageToBuffer2KHR = 77, + vkCmdCopyMemoryIndirectNV = 78, + vkCmdCopyMemoryToAccelerationStructureKHR = 79, + vkCmdCopyMemoryToImageIndirectNV = 80, + vkCmdCopyMemoryToMicromapEXT = 81, + vkCmdCopyMicromapEXT = 82, + vkCmdCopyMicromapToMemoryEXT = 83, + vkCmdCopyQueryPoolResults = 84, + vkCmdCuLaunchKernelNVX = 85, + vkCmdCudaLaunchKernelNV = 86, + vkCmdDebugMarkerBeginEXT = 87, + vkCmdDebugMarkerEndEXT = 88, + vkCmdDebugMarkerInsertEXT = 89, + vkCmdDecodeVideoKHR = 90, + vkCmdDecompressMemoryIndirectCountNV = 91, + vkCmdDecompressMemoryNV = 92, + vkCmdDispatch = 93, + vkCmdDispatchBase = 94, + vkCmdDispatchBaseKHR = 95, + vkCmdDispatchGraphAMDX = 96, + vkCmdDispatchGraphIndirectAMDX = 97, + vkCmdDispatchGraphIndirectCountAMDX = 98, + vkCmdDispatchIndirect = 99, + vkCmdDraw = 100, + vkCmdDrawClusterHUAWEI = 101, + vkCmdDrawClusterIndirectHUAWEI = 102, + vkCmdDrawIndexed = 103, + vkCmdDrawIndexedIndirect = 104, + vkCmdDrawIndexedIndirectCount = 105, + vkCmdDrawIndexedIndirectCountAMD = 106, + vkCmdDrawIndexedIndirectCountKHR = 107, + vkCmdDrawIndirect = 108, + vkCmdDrawIndirectByteCountEXT = 109, + vkCmdDrawIndirectCount = 110, + vkCmdDrawIndirectCountAMD = 111, + vkCmdDrawIndirectCountKHR = 112, + vkCmdDrawMeshTasksEXT = 113, + vkCmdDrawMeshTasksIndirectCountEXT = 114, + vkCmdDrawMeshTasksIndirectCountNV = 115, + vkCmdDrawMeshTasksIndirectEXT = 116, + vkCmdDrawMeshTasksIndirectNV = 117, + vkCmdDrawMeshTasksNV = 118, + vkCmdDrawMultiEXT = 119, + vkCmdDrawMultiIndexedEXT = 120, + vkCmdEncodeVideoKHR = 121, + vkCmdEndConditionalRenderingEXT = 122, + vkCmdEndDebugUtilsLabelEXT = 123, + vkCmdEndQuery = 124, + vkCmdEndQueryIndexedEXT = 125, + vkCmdEndRenderPass = 126, + vkCmdEndRenderPass2 = 127, + vkCmdEndRenderPass2KHR = 128, + vkCmdEndRendering = 129, + vkCmdEndRenderingKHR = 130, + vkCmdEndTransformFeedbackEXT = 131, + vkCmdEndVideoCodingKHR = 132, + vkCmdExecuteCommands = 133, + vkCmdExecuteGeneratedCommandsNV = 134, + vkCmdFillBuffer = 135, + vkCmdInitializeGraphScratchMemoryAMDX = 136, + vkCmdInsertDebugUtilsLabelEXT = 137, + vkCmdNextSubpass = 138, + vkCmdNextSubpass2 = 139, + vkCmdNextSubpass2KHR = 140, + vkCmdOpticalFlowExecuteNV = 141, + vkCmdPipelineBarrier = 142, + vkCmdPipelineBarrier2 = 143, + vkCmdPipelineBarrier2KHR = 144, + vkCmdPreprocessGeneratedCommandsNV = 145, + vkCmdPushConstants = 146, + vkCmdPushConstants2KHR = 147, + vkCmdPushDescriptorSet2KHR = 148, + vkCmdPushDescriptorSetKHR = 149, + vkCmdPushDescriptorSetWithTemplate2KHR = 150, + vkCmdPushDescriptorSetWithTemplateKHR = 151, + vkCmdResetEvent = 152, + vkCmdResetEvent2 = 153, + vkCmdResetEvent2KHR = 154, + vkCmdResetQueryPool = 155, + vkCmdResolveImage = 156, + vkCmdResolveImage2 = 157, + vkCmdResolveImage2KHR = 158, + vkCmdSetAlphaToCoverageEnableEXT = 159, + vkCmdSetAlphaToOneEnableEXT = 160, + vkCmdSetAttachmentFeedbackLoopEnableEXT = 161, + vkCmdSetBlendConstants = 162, + vkCmdSetCheckpointNV = 163, + vkCmdSetCoarseSampleOrderNV = 164, + vkCmdSetColorBlendAdvancedEXT = 165, + vkCmdSetColorBlendEnableEXT = 166, + vkCmdSetColorBlendEquationEXT = 167, + vkCmdSetColorWriteEnableEXT = 168, + vkCmdSetColorWriteMaskEXT = 169, + vkCmdSetConservativeRasterizationModeEXT = 170, + vkCmdSetCoverageModulationModeNV = 171, + vkCmdSetCoverageModulationTableEnableNV = 172, + vkCmdSetCoverageModulationTableNV = 173, + vkCmdSetCoverageReductionModeNV = 174, + vkCmdSetCoverageToColorEnableNV = 175, + vkCmdSetCoverageToColorLocationNV = 176, + vkCmdSetCullMode = 177, + vkCmdSetCullModeEXT = 178, + vkCmdSetDepthBias = 179, + vkCmdSetDepthBias2EXT = 180, + vkCmdSetDepthBiasEnable = 181, + vkCmdSetDepthBiasEnableEXT = 182, + vkCmdSetDepthBounds = 183, + vkCmdSetDepthBoundsTestEnable = 184, + vkCmdSetDepthBoundsTestEnableEXT = 185, + vkCmdSetDepthClampEnableEXT = 186, + vkCmdSetDepthClipEnableEXT = 187, + vkCmdSetDepthClipNegativeOneToOneEXT = 188, + vkCmdSetDepthCompareOp = 189, + vkCmdSetDepthCompareOpEXT = 190, + vkCmdSetDepthTestEnable = 191, + vkCmdSetDepthTestEnableEXT = 192, + vkCmdSetDepthWriteEnable = 193, + vkCmdSetDepthWriteEnableEXT = 194, + vkCmdSetDescriptorBufferOffsets2EXT = 195, + vkCmdSetDescriptorBufferOffsetsEXT = 196, + vkCmdSetDeviceMask = 197, + vkCmdSetDeviceMaskKHR = 198, + vkCmdSetDiscardRectangleEXT = 199, + vkCmdSetDiscardRectangleEnableEXT = 200, + vkCmdSetDiscardRectangleModeEXT = 201, + vkCmdSetEvent = 202, + vkCmdSetEvent2 = 203, + vkCmdSetEvent2KHR = 204, + vkCmdSetExclusiveScissorEnableNV = 205, + vkCmdSetExclusiveScissorNV = 206, + vkCmdSetExtraPrimitiveOverestimationSizeEXT = 207, + vkCmdSetFragmentShadingRateEnumNV = 208, + vkCmdSetFragmentShadingRateKHR = 209, + vkCmdSetFrontFace = 210, + vkCmdSetFrontFaceEXT = 211, + vkCmdSetLineRasterizationModeEXT = 212, + vkCmdSetLineStippleEXT = 213, + vkCmdSetLineStippleEnableEXT = 214, + vkCmdSetLineWidth = 215, + vkCmdSetLogicOpEXT = 216, + vkCmdSetLogicOpEnableEXT = 217, + vkCmdSetPatchControlPointsEXT = 218, + vkCmdSetPerformanceMarkerINTEL = 219, + vkCmdSetPerformanceOverrideINTEL = 220, + vkCmdSetPerformanceStreamMarkerINTEL = 221, + vkCmdSetPolygonModeEXT = 222, + vkCmdSetPrimitiveRestartEnable = 223, + vkCmdSetPrimitiveRestartEnableEXT = 224, + vkCmdSetPrimitiveTopology = 225, + vkCmdSetPrimitiveTopologyEXT = 226, + vkCmdSetProvokingVertexModeEXT = 227, + vkCmdSetRasterizationSamplesEXT = 228, + vkCmdSetRasterizationStreamEXT = 229, + vkCmdSetRasterizerDiscardEnable = 230, + vkCmdSetRasterizerDiscardEnableEXT = 231, + vkCmdSetRayTracingPipelineStackSizeKHR = 232, + vkCmdSetRepresentativeFragmentTestEnableNV = 233, + vkCmdSetSampleLocationsEXT = 234, + vkCmdSetSampleLocationsEnableEXT = 235, + vkCmdSetSampleMaskEXT = 236, + vkCmdSetScissor = 237, + vkCmdSetScissorWithCount = 238, + vkCmdSetScissorWithCountEXT = 239, + vkCmdSetShadingRateImageEnableNV = 240, + vkCmdSetStencilCompareMask = 241, + vkCmdSetStencilOp = 242, + vkCmdSetStencilOpEXT = 243, + vkCmdSetStencilReference = 244, + vkCmdSetStencilTestEnable = 245, + vkCmdSetStencilTestEnableEXT = 246, + vkCmdSetStencilWriteMask = 247, + vkCmdSetTessellationDomainOriginEXT = 248, + vkCmdSetVertexInputEXT = 249, + vkCmdSetViewport = 250, + vkCmdSetViewportShadingRatePaletteNV = 251, + vkCmdSetViewportSwizzleNV = 252, + vkCmdSetViewportWScalingEnableNV = 253, + vkCmdSetViewportWScalingNV = 254, + vkCmdSetViewportWithCount = 255, + vkCmdSetViewportWithCountEXT = 256, + vkCmdSubpassShadingHUAWEI = 257, + vkCmdTraceRaysIndirect2KHR = 258, + vkCmdTraceRaysIndirectKHR = 259, + vkCmdTraceRaysKHR = 260, + vkCmdTraceRaysNV = 261, + vkCmdUpdateBuffer = 262, + vkCmdUpdatePipelineIndirectBufferNV = 263, + vkCmdWaitEvents = 264, + vkCmdWaitEvents2 = 265, + vkCmdWaitEvents2KHR = 266, + vkCmdWriteAccelerationStructuresPropertiesKHR = 267, + vkCmdWriteAccelerationStructuresPropertiesNV = 268, + vkCmdWriteBufferMarker2AMD = 269, + vkCmdWriteBufferMarkerAMD = 270, + vkCmdWriteMicromapsPropertiesEXT = 271, + vkCmdWriteTimestamp = 272, + vkCmdWriteTimestamp2 = 273, + vkCmdWriteTimestamp2KHR = 274, + vkCompileDeferredNV = 275, + vkCopyAccelerationStructureKHR = 276, + vkCopyAccelerationStructureToMemoryKHR = 277, + vkCopyImageToImageEXT = 278, + vkCopyImageToMemoryEXT = 279, + vkCopyMemoryToAccelerationStructureKHR = 280, + vkCopyMemoryToImageEXT = 281, + vkCopyMemoryToMicromapEXT = 282, + vkCopyMicromapEXT = 283, + vkCopyMicromapToMemoryEXT = 284, + vkCreateAccelerationStructureKHR = 285, + vkCreateAccelerationStructureNV = 286, + vkCreateAndroidSurfaceKHR = 287, + vkCreateBuffer = 288, + vkCreateBufferCollectionFUCHSIA = 289, + vkCreateBufferView = 290, + vkCreateCommandPool = 291, + vkCreateComputePipelines = 292, + vkCreateCuFunctionNVX = 293, + vkCreateCuModuleNVX = 294, + vkCreateCudaFunctionNV = 295, + vkCreateCudaModuleNV = 296, + vkCreateDebugReportCallbackEXT = 297, + vkCreateDebugUtilsMessengerEXT = 298, + vkCreateDeferredOperationKHR = 299, + vkCreateDescriptorPool = 300, + vkCreateDescriptorSetLayout = 301, + vkCreateDescriptorUpdateTemplate = 302, + vkCreateDescriptorUpdateTemplateKHR = 303, + vkCreateDevice = 304, + vkCreateDirectFBSurfaceEXT = 305, + vkCreateDisplayModeKHR = 306, + vkCreateDisplayPlaneSurfaceKHR = 307, + vkCreateEvent = 308, + vkCreateExecutionGraphPipelinesAMDX = 309, + vkCreateFence = 310, + vkCreateFramebuffer = 311, + vkCreateGraphicsPipelines = 312, + vkCreateHeadlessSurfaceEXT = 313, + vkCreateIOSSurfaceMVK = 314, + vkCreateImage = 315, + vkCreateImagePipeSurfaceFUCHSIA = 316, + vkCreateImageView = 317, + vkCreateIndirectCommandsLayoutNV = 318, + vkCreateInstance = 319, + vkCreateMacOSSurfaceMVK = 320, + vkCreateMetalSurfaceEXT = 321, + vkCreateMicromapEXT = 322, + vkCreateOpticalFlowSessionNV = 323, + vkCreatePipelineCache = 324, + vkCreatePipelineLayout = 325, + vkCreatePrivateDataSlot = 326, + vkCreatePrivateDataSlotEXT = 327, + vkCreateQueryPool = 328, + vkCreateRayTracingPipelinesKHR = 329, + vkCreateRayTracingPipelinesNV = 330, + vkCreateRenderPass = 331, + vkCreateRenderPass2 = 332, + vkCreateRenderPass2KHR = 333, + vkCreateSampler = 334, + vkCreateSamplerYcbcrConversion = 335, + vkCreateSamplerYcbcrConversionKHR = 336, + vkCreateScreenSurfaceQNX = 337, + vkCreateSemaphore = 338, + vkCreateShaderModule = 339, + vkCreateShadersEXT = 340, + vkCreateSharedSwapchainsKHR = 341, + vkCreateStreamDescriptorSurfaceGGP = 342, + vkCreateSurfaceOHOS = 343, + vkCreateSwapchainKHR = 344, + vkCreateValidationCacheEXT = 345, + vkCreateViSurfaceNN = 346, + vkCreateVideoSessionKHR = 347, + vkCreateVideoSessionParametersKHR = 348, + vkCreateWaylandSurfaceKHR = 349, + vkCreateWin32SurfaceKHR = 350, + vkCreateXcbSurfaceKHR = 351, + vkCreateXlibSurfaceKHR = 352, + vkDebugMarkerSetObjectNameEXT = 353, + vkDebugMarkerSetObjectTagEXT = 354, + vkDebugReportMessageEXT = 355, + vkDeferredOperationJoinKHR = 356, + vkDestroyAccelerationStructureKHR = 357, + vkDestroyAccelerationStructureNV = 358, + vkDestroyBuffer = 359, + vkDestroyBufferCollectionFUCHSIA = 360, + vkDestroyBufferView = 361, + vkDestroyCommandPool = 362, + vkDestroyCuFunctionNVX = 363, + vkDestroyCuModuleNVX = 364, + vkDestroyCudaFunctionNV = 365, + vkDestroyCudaModuleNV = 366, + vkDestroyDebugReportCallbackEXT = 367, + vkDestroyDebugUtilsMessengerEXT = 368, + vkDestroyDeferredOperationKHR = 369, + vkDestroyDescriptorPool = 370, + vkDestroyDescriptorSetLayout = 371, + vkDestroyDescriptorUpdateTemplate = 372, + vkDestroyDescriptorUpdateTemplateKHR = 373, + vkDestroyDevice = 374, + vkDestroyEvent = 375, + vkDestroyFence = 376, + vkDestroyFramebuffer = 377, + vkDestroyImage = 378, + vkDestroyImageView = 379, + vkDestroyIndirectCommandsLayoutNV = 380, + vkDestroyInstance = 381, + vkDestroyMicromapEXT = 382, + vkDestroyOpticalFlowSessionNV = 383, + vkDestroyPipeline = 384, + vkDestroyPipelineCache = 385, + vkDestroyPipelineLayout = 386, + vkDestroyPrivateDataSlot = 387, + vkDestroyPrivateDataSlotEXT = 388, + vkDestroyQueryPool = 389, + vkDestroyRenderPass = 390, + vkDestroySampler = 391, + vkDestroySamplerYcbcrConversion = 392, + vkDestroySamplerYcbcrConversionKHR = 393, + vkDestroySemaphore = 394, + vkDestroyShaderEXT = 395, + vkDestroyShaderModule = 396, + vkDestroySurfaceKHR = 397, + vkDestroySwapchainKHR = 398, + vkDestroyValidationCacheEXT = 399, + vkDestroyVideoSessionKHR = 400, + vkDestroyVideoSessionParametersKHR = 401, + vkDeviceWaitIdle = 402, + vkDisplayPowerControlEXT = 403, + vkEndCommandBuffer = 404, + vkEnumerateDeviceExtensionProperties = 405, + vkEnumerateDeviceLayerProperties = 406, + vkEnumerateInstanceExtensionProperties = 407, + vkEnumerateInstanceLayerProperties = 408, + vkEnumerateInstanceVersion = 409, + vkEnumeratePhysicalDeviceGroups = 410, + vkEnumeratePhysicalDeviceGroupsKHR = 411, + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 412, + vkEnumeratePhysicalDevices = 413, + vkExportMetalObjectsEXT = 414, + vkFlushMappedMemoryRanges = 415, + vkFreeCommandBuffers = 416, + vkFreeDescriptorSets = 417, + vkFreeMemory = 418, + vkGetAccelerationStructureBuildSizesKHR = 419, + vkGetAccelerationStructureDeviceAddressKHR = 420, + vkGetAccelerationStructureHandleNV = 421, + vkGetAccelerationStructureMemoryRequirementsNV = 422, + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 423, + vkGetAndroidHardwareBufferPropertiesANDROID = 424, + vkGetBufferCollectionPropertiesFUCHSIA = 425, + vkGetBufferDeviceAddress = 426, + vkGetBufferDeviceAddressEXT = 427, + vkGetBufferDeviceAddressKHR = 428, + vkGetBufferMemoryRequirements = 429, + vkGetBufferMemoryRequirements2 = 430, + vkGetBufferMemoryRequirements2KHR = 431, + vkGetBufferOpaqueCaptureAddress = 432, + vkGetBufferOpaqueCaptureAddressKHR = 433, + vkGetBufferOpaqueCaptureDescriptorDataEXT = 434, + vkGetCalibratedTimestampsEXT = 435, + vkGetCalibratedTimestampsKHR = 436, + vkGetCudaModuleCacheNV = 437, + vkGetDeferredOperationMaxConcurrencyKHR = 438, + vkGetDeferredOperationResultKHR = 439, + vkGetDescriptorEXT = 440, + vkGetDescriptorSetHostMappingVALVE = 441, + vkGetDescriptorSetLayoutBindingOffsetEXT = 442, + vkGetDescriptorSetLayoutHostMappingInfoVALVE = 443, + vkGetDescriptorSetLayoutSizeEXT = 444, + vkGetDescriptorSetLayoutSupport = 445, + vkGetDescriptorSetLayoutSupportKHR = 446, + vkGetDeviceAccelerationStructureCompatibilityKHR = 447, + vkGetDeviceBufferMemoryRequirements = 448, + vkGetDeviceBufferMemoryRequirementsKHR = 449, + vkGetDeviceFaultInfoEXT = 450, + vkGetDeviceGroupPeerMemoryFeatures = 451, + vkGetDeviceGroupPeerMemoryFeaturesKHR = 452, + vkGetDeviceGroupPresentCapabilitiesKHR = 453, + vkGetDeviceGroupSurfacePresentModes2EXT = 454, + vkGetDeviceGroupSurfacePresentModesKHR = 455, + vkGetDeviceImageMemoryRequirements = 456, + vkGetDeviceImageMemoryRequirementsKHR = 457, + vkGetDeviceImageSparseMemoryRequirements = 458, + vkGetDeviceImageSparseMemoryRequirementsKHR = 459, + vkGetDeviceImageSubresourceLayoutKHR = 460, + vkGetDeviceMemoryCommitment = 461, + vkGetDeviceMemoryOpaqueCaptureAddress = 462, + vkGetDeviceMemoryOpaqueCaptureAddressKHR = 463, + vkGetDeviceMicromapCompatibilityEXT = 464, + vkGetDeviceProcAddr = 465, + vkGetDeviceQueue = 466, + vkGetDeviceQueue2 = 467, + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 468, + vkGetDisplayModeProperties2KHR = 469, + vkGetDisplayModePropertiesKHR = 470, + vkGetDisplayPlaneCapabilities2KHR = 471, + vkGetDisplayPlaneCapabilitiesKHR = 472, + vkGetDisplayPlaneSupportedDisplaysKHR = 473, + vkGetDrmDisplayEXT = 474, + vkGetDynamicRenderingTilePropertiesQCOM = 475, + vkGetEncodedVideoSessionParametersKHR = 476, + vkGetEventStatus = 477, + vkGetExecutionGraphPipelineNodeIndexAMDX = 478, + vkGetExecutionGraphPipelineScratchSizeAMDX = 479, + vkGetFenceFdKHR = 480, + vkGetFenceStatus = 481, + vkGetFenceWin32HandleKHR = 482, + vkGetFramebufferTilePropertiesQCOM = 483, + vkGetGeneratedCommandsMemoryRequirementsNV = 484, + vkGetImageDrmFormatModifierPropertiesEXT = 485, + vkGetImageMemoryRequirements = 486, + vkGetImageMemoryRequirements2 = 487, + vkGetImageMemoryRequirements2KHR = 488, + vkGetImageOpaqueCaptureDescriptorDataEXT = 489, + vkGetImageSparseMemoryRequirements = 490, + vkGetImageSparseMemoryRequirements2 = 491, + vkGetImageSparseMemoryRequirements2KHR = 492, + vkGetImageSubresourceLayout = 493, + vkGetImageSubresourceLayout2EXT = 494, + vkGetImageSubresourceLayout2KHR = 495, + vkGetImageViewAddressNVX = 496, + vkGetImageViewHandleNVX = 497, + vkGetImageViewOpaqueCaptureDescriptorDataEXT = 498, + vkGetInstanceProcAddr = 499, + vkGetLatencyTimingsNV = 500, + vkGetMemoryAndroidHardwareBufferANDROID = 501, + vkGetMemoryFdKHR = 502, + vkGetMemoryFdPropertiesKHR = 503, + vkGetMemoryHostPointerPropertiesEXT = 504, + vkGetMemoryNativeBufferOHOS = 505, + vkGetMemoryRemoteAddressNV = 506, + vkGetMemoryWin32HandleKHR = 507, + vkGetMemoryWin32HandleNV = 508, + vkGetMemoryWin32HandlePropertiesKHR = 509, + vkGetMemoryZirconHandleFUCHSIA = 510, + vkGetMemoryZirconHandlePropertiesFUCHSIA = 511, + vkGetMicromapBuildSizesEXT = 512, + vkGetNativeBufferPropertiesOHOS = 513, + vkGetPastPresentationTimingGOOGLE = 514, + vkGetPerformanceParameterINTEL = 515, + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 516, + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 517, + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 518, + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 519, + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 520, + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 521, + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 522, + vkGetPhysicalDeviceDisplayProperties2KHR = 523, + vkGetPhysicalDeviceDisplayPropertiesKHR = 524, + vkGetPhysicalDeviceExternalBufferProperties = 525, + vkGetPhysicalDeviceExternalBufferPropertiesKHR = 526, + vkGetPhysicalDeviceExternalFenceProperties = 527, + vkGetPhysicalDeviceExternalFencePropertiesKHR = 528, + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 529, + vkGetPhysicalDeviceExternalSemaphoreProperties = 530, + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 531, + vkGetPhysicalDeviceFeatures = 532, + vkGetPhysicalDeviceFeatures2 = 533, + vkGetPhysicalDeviceFeatures2KHR = 534, + vkGetPhysicalDeviceFormatProperties = 535, + vkGetPhysicalDeviceFormatProperties2 = 536, + vkGetPhysicalDeviceFormatProperties2KHR = 537, + vkGetPhysicalDeviceFragmentShadingRatesKHR = 538, + vkGetPhysicalDeviceImageFormatProperties = 539, + vkGetPhysicalDeviceImageFormatProperties2 = 540, + vkGetPhysicalDeviceImageFormatProperties2KHR = 541, + vkGetPhysicalDeviceMemoryProperties = 542, + vkGetPhysicalDeviceMemoryProperties2 = 543, + vkGetPhysicalDeviceMemoryProperties2KHR = 544, + vkGetPhysicalDeviceMultisamplePropertiesEXT = 545, + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 546, + vkGetPhysicalDevicePresentRectanglesKHR = 547, + vkGetPhysicalDeviceProperties = 548, + vkGetPhysicalDeviceProperties2 = 549, + vkGetPhysicalDeviceProperties2KHR = 550, + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 551, + vkGetPhysicalDeviceQueueFamilyProperties = 552, + vkGetPhysicalDeviceQueueFamilyProperties2 = 553, + vkGetPhysicalDeviceQueueFamilyProperties2KHR = 554, + vkGetPhysicalDeviceScreenPresentationSupportQNX = 555, + vkGetPhysicalDeviceSparseImageFormatProperties = 556, + vkGetPhysicalDeviceSparseImageFormatProperties2 = 557, + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 558, + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 559, + vkGetPhysicalDeviceSurfaceCapabilities2EXT = 560, + vkGetPhysicalDeviceSurfaceCapabilities2KHR = 561, + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 562, + vkGetPhysicalDeviceSurfaceFormats2KHR = 563, + vkGetPhysicalDeviceSurfaceFormatsKHR = 564, + vkGetPhysicalDeviceSurfacePresentModes2EXT = 565, + vkGetPhysicalDeviceSurfacePresentModesKHR = 566, + vkGetPhysicalDeviceSurfaceSupportKHR = 567, + vkGetPhysicalDeviceToolProperties = 568, + vkGetPhysicalDeviceToolPropertiesEXT = 569, + vkGetPhysicalDeviceVideoCapabilitiesKHR = 570, + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 571, + vkGetPhysicalDeviceVideoFormatPropertiesKHR = 572, + vkGetPhysicalDeviceWaylandPresentationSupportKHR = 573, + vkGetPhysicalDeviceWin32PresentationSupportKHR = 574, + vkGetPhysicalDeviceXcbPresentationSupportKHR = 575, + vkGetPhysicalDeviceXlibPresentationSupportKHR = 576, + vkGetPipelineCacheData = 577, + vkGetPipelineExecutableInternalRepresentationsKHR = 578, + vkGetPipelineExecutablePropertiesKHR = 579, + vkGetPipelineExecutableStatisticsKHR = 580, + vkGetPipelineIndirectDeviceAddressNV = 581, + vkGetPipelineIndirectMemoryRequirementsNV = 582, + vkGetPipelinePropertiesEXT = 583, + vkGetPrivateData = 584, + vkGetPrivateDataEXT = 585, + vkGetQueryPoolResults = 586, + vkGetQueueCheckpointData2NV = 587, + vkGetQueueCheckpointDataNV = 588, + vkGetRandROutputDisplayEXT = 589, + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 590, + vkGetRayTracingShaderGroupHandlesKHR = 591, + vkGetRayTracingShaderGroupHandlesNV = 592, + vkGetRayTracingShaderGroupStackSizeKHR = 593, + vkGetRefreshCycleDurationGOOGLE = 594, + vkGetRenderAreaGranularity = 595, + vkGetRenderingAreaGranularityKHR = 596, + vkGetSamplerOpaqueCaptureDescriptorDataEXT = 597, + vkGetScreenBufferPropertiesQNX = 598, + vkGetSemaphoreCounterValue = 599, + vkGetSemaphoreCounterValueKHR = 600, + vkGetSemaphoreFdKHR = 601, + vkGetSemaphoreWin32HandleKHR = 602, + vkGetSemaphoreZirconHandleFUCHSIA = 603, + vkGetShaderBinaryDataEXT = 604, + vkGetShaderInfoAMD = 605, + vkGetShaderModuleCreateInfoIdentifierEXT = 606, + vkGetShaderModuleIdentifierEXT = 607, + vkGetSwapchainCounterEXT = 608, + vkGetSwapchainGrallocUsageOHOS = 609, + vkGetSwapchainImagesKHR = 610, + vkGetSwapchainStatusKHR = 611, + vkGetValidationCacheDataEXT = 612, + vkGetVideoSessionMemoryRequirementsKHR = 613, + vkGetWinrtDisplayNV = 614, + vkImportFenceFdKHR = 615, + vkImportFenceWin32HandleKHR = 616, + vkImportSemaphoreFdKHR = 617, + vkImportSemaphoreWin32HandleKHR = 618, + vkImportSemaphoreZirconHandleFUCHSIA = 619, + vkInitializePerformanceApiINTEL = 620, + vkInvalidateMappedMemoryRanges = 621, + vkLatencySleepNV = 622, + vkMapMemory = 623, + vkMapMemory2KHR = 624, + vkMergePipelineCaches = 625, + vkMergeValidationCachesEXT = 626, + vkQueueBeginDebugUtilsLabelEXT = 627, + vkQueueBindSparse = 628, + vkQueueEndDebugUtilsLabelEXT = 629, + vkQueueInsertDebugUtilsLabelEXT = 630, + vkQueueNotifyOutOfBandNV = 631, + vkQueuePresentKHR = 632, + vkQueueSetPerformanceConfigurationINTEL = 633, + vkQueueSignalReleaseImageOHOS = 634, + vkQueueSubmit = 635, + vkQueueSubmit2 = 636, + vkQueueSubmit2KHR = 637, + vkQueueWaitIdle = 638, + vkRegisterDeviceEventEXT = 639, + vkRegisterDisplayEventEXT = 640, + vkReleaseDisplayEXT = 641, + vkReleaseFullScreenExclusiveModeEXT = 642, + vkReleasePerformanceConfigurationINTEL = 643, + vkReleaseProfilingLockKHR = 644, + vkReleaseSwapchainImagesEXT = 645, + vkResetCommandBuffer = 646, + vkResetCommandPool = 647, + vkResetDescriptorPool = 648, + vkResetEvent = 649, + vkResetFences = 650, + vkResetQueryPool = 651, + vkResetQueryPoolEXT = 652, + vkSetBufferCollectionBufferConstraintsFUCHSIA = 653, + vkSetBufferCollectionImageConstraintsFUCHSIA = 654, + vkSetDebugUtilsObjectNameEXT = 655, + vkSetDebugUtilsObjectTagEXT = 656, + vkSetDeviceMemoryPriorityEXT = 657, + vkSetEvent = 658, + vkSetHdrMetadataEXT = 659, + vkSetLatencyMarkerNV = 660, + vkSetLatencySleepModeNV = 661, + vkSetLocalDimmingAMD = 662, + vkSetPrivateData = 663, + vkSetPrivateDataEXT = 664, + vkSignalSemaphore = 665, + vkSignalSemaphoreKHR = 666, + vkSubmitDebugUtilsMessageEXT = 667, + vkTransitionImageLayoutEXT = 668, + vkTrimCommandPool = 669, + vkTrimCommandPoolKHR = 670, + vkUninitializePerformanceApiINTEL = 671, + vkUnmapMemory = 672, + vkUnmapMemory2KHR = 673, + vkUpdateDescriptorSetWithTemplate = 674, + vkUpdateDescriptorSetWithTemplateKHR = 675, + vkUpdateDescriptorSets = 676, + vkUpdateVideoSessionParametersKHR = 677, + vkWaitForFences = 678, + vkWaitForPresentKHR = 679, + vkWaitSemaphores = 680, + vkWaitSemaphoresKHR = 681, + vkWriteAccelerationStructuresPropertiesKHR = 682, + vkWriteMicromapsPropertiesEXT = 683, }; enum class Struct { @@ -969,6 +975,7 @@ enum class Struct { VkExternalBufferProperties, VkExternalFenceProperties, VkExternalFormatANDROID, + VkExternalFormatOHOS, VkExternalFormatQNX, VkExternalImageFormatProperties, VkExternalImageFormatPropertiesNV, @@ -1060,6 +1067,7 @@ enum class Struct { VkImportMetalIOSurfaceInfoEXT, VkImportMetalSharedEventInfoEXT, VkImportMetalTextureInfoEXT, + VkImportNativeBufferInfoOHOS, VkImportScreenBufferInfoQNX, VkImportSemaphoreFdInfoKHR, VkImportSemaphoreWin32HandleInfoKHR, @@ -1089,6 +1097,7 @@ enum class Struct { VkMemoryFdPropertiesKHR, VkMemoryGetAndroidHardwareBufferInfoANDROID, VkMemoryGetFdInfoKHR, + VkMemoryGetNativeBufferInfoOHOS, VkMemoryGetRemoteAddressInfoNV, VkMemoryGetWin32HandleInfoKHR, VkMemoryGetZirconHandleInfoFUCHSIA, @@ -1119,6 +1128,10 @@ enum class Struct { VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, VkMutableDescriptorTypeCreateInfoEXT, VkMutableDescriptorTypeListEXT, + VkNativeBufferFormatPropertiesOHOS, + VkNativeBufferOHOS, + VkNativeBufferPropertiesOHOS, + VkNativeBufferUsageOHOS, VkOffset2D, VkOffset3D, VkOpaqueCaptureDescriptorDataCreateInfoEXT, @@ -1320,6 +1333,7 @@ enum class Struct { VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, + VkPhysicalDevicePresentationPropertiesOHOS, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, @@ -1612,6 +1626,7 @@ enum class Struct { VkSurfaceCapabilitiesFullScreenExclusiveEXT, VkSurfaceCapabilitiesKHR, VkSurfaceCapabilitiesPresentBarrierNV, + VkSurfaceCreateInfoOHOS, VkSurfaceFormat2KHR, VkSurfaceFormatKHR, VkSurfaceFullScreenExclusiveInfoEXT, @@ -1623,6 +1638,7 @@ enum class Struct { VkSwapchainCounterCreateInfoEXT, VkSwapchainCreateInfoKHR, VkSwapchainDisplayNativeHdrCreateInfoAMD, + VkSwapchainImageCreateInfoOHOS, VkSwapchainLatencyCreateInfoNV, VkSwapchainPresentBarrierCreateInfoNV, VkSwapchainPresentFenceInfoEXT, @@ -1740,6 +1756,7 @@ enum class Field { KSize, MSize, NSize, + OHOSNativeBufferUsage, ResultType, a, aabbData, @@ -2358,6 +2375,7 @@ enum class Field { gopRemainingP, gpuRenderEndTimeUs, gpuRenderStartTimeUs, + grallocUsage, graphicsPipelineLibrary, graphicsPipelineLibraryFastLinking, graphicsPipelineLibraryIndependentInterpolationDecoration, @@ -2951,6 +2969,7 @@ enum class Field { naluSliceEntryCount, naluSliceSegmentEntryCount, name, + nativeFenceFd, negativeOneToOne, nestedCommandBuffer, nestedCommandBufferRendering, @@ -3278,6 +3297,7 @@ enum class Field { pNaluSliceSegmentEntries, pName, pNameInfo, + pNativeFenceFd, pNext, pNodeIndex, pNodeInfo, @@ -3958,6 +3978,7 @@ enum class Field { shadingRatePaletteSize, shadingRateTexelSize, shadingRateType, + sharedImage, sharedMemBytes, sharedPresentSupportedUsageFlags, sharingMode, diff --git a/layers/vulkan/generated/layer_chassis_dispatch.cpp b/layers/vulkan/generated/layer_chassis_dispatch.cpp index 40c75d168c8b566a640065f5656f06cd576cc201..2d33b68c81aa9ee0250d01aa8d1c975da600e23c 100644 --- a/layers/vulkan/generated/layer_chassis_dispatch.cpp +++ b/layers/vulkan/generated/layer_chassis_dispatch.cpp @@ -8756,6 +8756,97 @@ VkResult DispatchGetScreenBufferPropertiesQNX(VkDevice device, const struct _scr return result; } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + +VkResult DispatchCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); + if (!wrap_handles) return layer_data->instance_dispatch_table.CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + + VkResult result = layer_data->instance_dispatch_table.CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + if (VK_SUCCESS == result) { + *pSurface = layer_data->WrapNew(*pSurface); + } + return result; +} + +VkResult DispatchGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + + VkResult result = layer_data->device_dispatch_table.GetSwapchainGrallocUsageOHOS(device, format, imageUsage, grallocUsage); + + return result; +} + +VkResult DispatchAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.AcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence); + { + image = layer_data->Unwrap(image); + semaphore = layer_data->Unwrap(semaphore); + fence = layer_data->Unwrap(fence); + } + VkResult result = layer_data->device_dispatch_table.AcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence); + + return result; +} + +VkResult DispatchQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); + if (!wrap_handles) + return layer_data->device_dispatch_table.QueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, + pNativeFenceFd); + VkSemaphore var_local_pWaitSemaphores[DISPATCH_MAX_STACK_ALLOCATIONS]; + VkSemaphore* local_pWaitSemaphores = nullptr; + { + if (pWaitSemaphores) { + local_pWaitSemaphores = waitSemaphoreCount > DISPATCH_MAX_STACK_ALLOCATIONS ? new VkSemaphore[waitSemaphoreCount] + : var_local_pWaitSemaphores; + for (uint32_t index0 = 0; index0 < waitSemaphoreCount; ++index0) { + local_pWaitSemaphores[index0] = layer_data->Unwrap(pWaitSemaphores[index0]); + } + } + image = layer_data->Unwrap(image); + } + VkResult result = layer_data->device_dispatch_table.QueueSignalReleaseImageOHOS( + queue, waitSemaphoreCount, (const VkSemaphore*)local_pWaitSemaphores, image, pNativeFenceFd); + if (local_pWaitSemaphores != var_local_pWaitSemaphores) delete[] local_pWaitSemaphores; + return result; +} + +VkResult DispatchGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + + VkResult result = layer_data->device_dispatch_table.GetNativeBufferPropertiesOHOS(device, buffer, pProperties); + + return result; +} + +VkResult DispatchGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + safe_VkMemoryGetNativeBufferInfoOHOS var_local_pInfo; + safe_VkMemoryGetNativeBufferInfoOHOS* local_pInfo = nullptr; + { + if (pInfo) { + local_pInfo = &var_local_pInfo; + local_pInfo->initialize(pInfo); + + if (pInfo->memory) { + local_pInfo->memory = layer_data->Unwrap(pInfo->memory); + } + } + } + VkResult result = layer_data->device_dispatch_table.GetMemoryNativeBufferOHOS( + device, (const VkMemoryGetNativeBufferInfoOHOS*)local_pInfo, pBuffer); + + return result; +} +#endif // VK_USE_PLATFORM_OHOS VkResult DispatchCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, diff --git a/layers/vulkan/generated/layer_chassis_dispatch.h b/layers/vulkan/generated/layer_chassis_dispatch.h index 9c7d4e963563f77621365dcd26e4cc7ed8a62f97..aedacd02f6520d1436a2487527c6cd5761566961 100644 --- a/layers/vulkan/generated/layer_chassis_dispatch.h +++ b/layers/vulkan/generated/layer_chassis_dispatch.h @@ -1165,6 +1165,19 @@ void DispatchCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer VkResult DispatchGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties); #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VkResult DispatchGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage); +VkResult DispatchAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence); +VkResult DispatchQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd); +VkResult DispatchGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); +VkResult DispatchGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif // VK_USE_PLATFORM_OHOS VkResult DispatchCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); diff --git a/layers/vulkan/generated/object_tracker.cpp b/layers/vulkan/generated/object_tracker.cpp index 789312f117de9880e626fab1eedffbdee184c162..30d41cfd52f824594ceffe4118bbc484d8f41622 100644 --- a/layers/vulkan/generated/object_tracker.cpp +++ b/layers/vulkan/generated/object_tracker.cpp @@ -7320,6 +7320,72 @@ bool ObjectLifetimes::PreCallValidateGetLatencyTimingsNV(VkDevice device, VkSwap // Checked by chassis: device: "VUID-vkGetScreenBufferPropertiesQNX-device-parameter" #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + +// vkCreateSurfaceOHOS: +// Checked by chassis: instance: "VUID-vkCreateSurfaceOHOS-instance-parameter" + +void ObjectLifetimes::PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) { + if (record_obj.result != VK_SUCCESS) return; + CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator, record_obj.location); +} + +// vkGetSwapchainGrallocUsageOHOS: +// Checked by chassis: device: kVUIDUndefined + +bool ObjectLifetimes::PreCallValidateAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence, const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: device: kVUIDUndefined + skip |= ValidateObject(image, kVulkanObjectTypeImage, false, kVUIDUndefined, "UNASSIGNED-vkAcquireImageOHOS-commonparent", + error_obj.location.dot(Field::image)); + skip |= ValidateObject(semaphore, kVulkanObjectTypeSemaphore, false, kVUIDUndefined, + "UNASSIGNED-vkAcquireImageOHOS-commonparent", error_obj.location.dot(Field::semaphore)); + skip |= ValidateObject(fence, kVulkanObjectTypeFence, false, kVUIDUndefined, "UNASSIGNED-vkAcquireImageOHOS-commonparent", + error_obj.location.dot(Field::fence)); + + return skip; +} + +bool ObjectLifetimes::PreCallValidateQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd, const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: queue: kVUIDUndefined + // Checked by chassis: queue: "UNASSIGNED-vkQueueSignalReleaseImageOHOS-commonparent" + + if ((waitSemaphoreCount > 0) && (pWaitSemaphores)) { + for (uint32_t index0 = 0; index0 < waitSemaphoreCount; ++index0) { + skip |= ValidateObject(pWaitSemaphores[index0], kVulkanObjectTypeSemaphore, false, kVUIDUndefined, + "UNASSIGNED-vkQueueSignalReleaseImageOHOS-commonparent", + error_obj.location.dot(Field::pWaitSemaphores, index0)); + } + } + skip |= ValidateObject(image, kVulkanObjectTypeImage, false, kVUIDUndefined, + "UNASSIGNED-vkQueueSignalReleaseImageOHOS-commonparent", error_obj.location.dot(Field::image)); + + return skip; +} + +// vkGetNativeBufferPropertiesOHOS: +// Checked by chassis: device: kVUIDUndefined + +bool ObjectLifetimes::PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: device: kVUIDUndefined + if (pInfo) { + [[maybe_unused]] const Location pInfo_loc = error_obj.location.dot(Field::pInfo); + skip |= ValidateObject(pInfo->memory, kVulkanObjectTypeDeviceMemory, false, kVUIDUndefined, + "UNASSIGNED-VkMemoryGetNativeBufferInfoOHOS-memory-parent", pInfo_loc.dot(Field::memory)); + } + + return skip; +} +#endif // VK_USE_PLATFORM_OHOS bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/vulkan/generated/object_tracker.h b/layers/vulkan/generated/object_tracker.h index 00345297e4b8bb7a734a35b384a0217cd2678045..8910a5ed0ba2e43117d3fcf674581e43f69805b6 100644 --- a/layers/vulkan/generated/object_tracker.h +++ b/layers/vulkan/generated/object_tracker.h @@ -1365,6 +1365,18 @@ bool PreCallValidateGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchai const ErrorObject& error_obj) const override; #ifdef VK_USE_PLATFORM_SCREEN_QNX #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) override; +bool PreCallValidateAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, + const ErrorObject& error_obj) const override; +bool PreCallValidateQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd, + const ErrorObject& error_obj) const override; +bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const ErrorObject& error_obj) const override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, diff --git a/layers/vulkan/generated/pnext_chain_extraction.cpp b/layers/vulkan/generated/pnext_chain_extraction.cpp index 6675d3573204b5adb33e9f51ee139c2d9d405578..76a78feedd3aeb443dcaf1c71b67c1f6df33f1a8 100644 --- a/layers/vulkan/generated/pnext_chain_extraction.cpp +++ b/layers/vulkan/generated/pnext_chain_extraction.cpp @@ -2818,6 +2818,28 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_OHOS case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: PnextChainFree(header->pNext); header->pNext = nullptr; diff --git a/layers/vulkan/generated/stateless_validation_helper.cpp b/layers/vulkan/generated/stateless_validation_helper.cpp index bb21eb8d2c529f3c055b752916e2fc329a391589..503a517933af0e04b23f7787a28b33f352945fb2 100644 --- a/layers/vulkan/generated/stateless_validation_helper.cpp +++ b/layers/vulkan/generated/stateless_validation_helper.cpp @@ -7234,6 +7234,24 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const skip |= ValidateBool32(pNext_loc.dot(Field::descriptorPoolOverallocation), structure->descriptorPoolOverallocation); } } break; +#ifdef VK_USE_PLATFORM_OHOS + + // No Validation code for VkNativeBufferUsageOHOS structure members -- Covers VUID-VkNativeBufferUsageOHOS-sType-sType + + // No Validation code for VkNativeBufferFormatPropertiesOHOS structure members -- Covers + // VUID-VkNativeBufferFormatPropertiesOHOS-sType-sType + + // Validation code for VkImportNativeBufferInfoOHOS structure members + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: { // Covers VUID-VkImportNativeBufferInfoOHOS-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkImportNativeBufferInfoOHOS); + VkImportNativeBufferInfoOHOS* structure = (VkImportNativeBufferInfoOHOS*)header; + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::buffer), structure->buffer, kVUIDUndefined); + } + } break; + + // No Validation code for VkExternalFormatOHOS structure members -- Covers VUID-VkExternalFormatOHOS-sType-sType +#endif // VK_USE_PLATFORM_OHOS // Validation code for VkWriteDescriptorSetAccelerationStructureKHR structure members case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { // Covers @@ -8111,6 +8129,7 @@ bool StatelessValidation::PreCallValidateAllocateMemory(VkDevice device, const V VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, + VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS, VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, @@ -9086,6 +9105,7 @@ bool StatelessValidation::PreCallValidateCreateImage(VkDevice device, const VkIm VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, @@ -12028,6 +12048,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD}; @@ -12196,8 +12217,8 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversion(VkDevice d if (pCreateInfo != nullptr) { [[maybe_unused]] const Location pCreateInfo_loc = loc.dot(Field::pCreateInfo); constexpr std::array allowed_structs_VkSamplerYcbcrConversionCreateInfo = { - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM}; + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM}; skip |= ValidateStructPnext(pCreateInfo_loc, pCreateInfo->pNext, allowed_structs_VkSamplerYcbcrConversionCreateInfo.size(), allowed_structs_VkSamplerYcbcrConversionCreateInfo.data(), GeneratedVulkanHeaderVersion, @@ -14556,6 +14577,7 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirements(VkDevi VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, @@ -14650,6 +14672,7 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirements( VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, @@ -18272,6 +18295,7 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSubresourceLayoutKHR(VkDe VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, @@ -23354,6 +23378,7 @@ bool StatelessValidation::PreCallValidateSetBufferCollectionImageConstraintsFUCH VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, @@ -25602,6 +25627,132 @@ bool StatelessValidation::PreCallValidateGetScreenBufferPropertiesQNX(VkDevice d } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +bool StatelessValidation::PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!instance_extensions.vk_ohos_surface) skip |= OutputExtensionError(loc, "VK_OHOS_surface"); + skip |= ValidateStructType(loc.dot(Field::pCreateInfo), "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", pCreateInfo, + VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS, true, "VUID-vkCreateSurfaceOHOS-pCreateInfo-parameter", + "VUID-VkSurfaceCreateInfoOHOS-sType-sType"); + if (pCreateInfo != nullptr) { + [[maybe_unused]] const Location pCreateInfo_loc = loc.dot(Field::pCreateInfo); + skip |= ValidateStructPnext(pCreateInfo_loc, pCreateInfo->pNext, 0, nullptr, GeneratedVulkanHeaderVersion, + "VUID-VkSurfaceCreateInfoOHOS-pNext-pNext", kVUIDUndefined, false, true); + + skip |= ValidateReservedFlags(pCreateInfo_loc.dot(Field::flags), pCreateInfo->flags, + "VUID-VkSurfaceCreateInfoOHOS-flags-zerobitmask"); + } + if (pAllocator != nullptr) { + [[maybe_unused]] const Location pAllocator_loc = loc.dot(Field::pAllocator); + skip |= ValidateRequiredPointer(pAllocator_loc.dot(Field::pfnAllocation), + reinterpret_cast(pAllocator->pfnAllocation), + "VUID-VkAllocationCallbacks-pfnAllocation-00632"); + + skip |= ValidateRequiredPointer(pAllocator_loc.dot(Field::pfnReallocation), + reinterpret_cast(pAllocator->pfnReallocation), + "VUID-VkAllocationCallbacks-pfnReallocation-00633"); + + skip |= ValidateRequiredPointer(pAllocator_loc.dot(Field::pfnFree), reinterpret_cast(pAllocator->pfnFree), + "VUID-VkAllocationCallbacks-pfnFree-00634"); + + if (pAllocator->pfnInternalAllocation != nullptr) { + skip |= ValidateRequiredPointer(pAllocator_loc.dot(Field::pfnInternalAllocation), + reinterpret_cast(pAllocator->pfnInternalFree), + "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + } + + if (pAllocator->pfnInternalFree != nullptr) { + skip |= ValidateRequiredPointer(pAllocator_loc.dot(Field::pfnInternalFree), + reinterpret_cast(pAllocator->pfnInternalAllocation), + "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + } + } + skip |= ValidateRequiredPointer(loc.dot(Field::pSurface), pSurface, "VUID-vkCreateSurfaceOHOS-pSurface-parameter"); + return skip; +} + +bool StatelessValidation::PreCallValidateGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, + VkImageUsageFlags imageUsage, uint64_t* grallocUsage, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_ohos_native_buffer)) skip |= OutputExtensionError(loc, "VK_OHOS_native_buffer"); + skip |= ValidateRangedEnum(loc.dot(Field::format), "VkFormat", format, kVUIDUndefined); + skip |= ValidateFlags(loc.dot(Field::imageUsage), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, imageUsage, kRequiredFlags, + kVUIDUndefined, kVUIDUndefined); + skip |= ValidateRequiredPointer(loc.dot(Field::grallocUsage), grallocUsage, kVUIDUndefined); + return skip; +} + +bool StatelessValidation::PreCallValidateAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, + VkSemaphore semaphore, VkFence fence, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_ohos_native_buffer)) skip |= OutputExtensionError(loc, "VK_OHOS_native_buffer"); + skip |= ValidateRequiredHandle(loc.dot(Field::image), image); + skip |= ValidateRequiredHandle(loc.dot(Field::semaphore), semaphore); + skip |= ValidateRequiredHandle(loc.dot(Field::fence), fence); + return skip; +} + +bool StatelessValidation::PreCallValidateQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd, const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_ohos_native_buffer)) skip |= OutputExtensionError(loc, "VK_OHOS_native_buffer"); + skip |= ValidateHandleArray(loc.dot(Field::waitSemaphoreCount), loc.dot(Field::pWaitSemaphores), waitSemaphoreCount, + pWaitSemaphores, true, true, kVUIDUndefined); + skip |= ValidateRequiredHandle(loc.dot(Field::image), image); + skip |= ValidateRequiredPointer(loc.dot(Field::pNativeFenceFd), pNativeFenceFd, kVUIDUndefined); + return skip; +} + +bool StatelessValidation::PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError(loc, "VK_OHOS_external_memory"); + skip |= ValidateRequiredPointer(loc.dot(Field::buffer), buffer, kVUIDUndefined); + skip |= ValidateStructType(loc.dot(Field::pProperties), "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS", pProperties, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, true, kVUIDUndefined, kVUIDUndefined); + if (pProperties != nullptr) { + [[maybe_unused]] const Location pProperties_loc = loc.dot(Field::pProperties); + constexpr std::array allowed_structs_VkNativeBufferPropertiesOHOS = { + VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS}; + + skip |= ValidateStructPnext(pProperties_loc, pProperties->pNext, allowed_structs_VkNativeBufferPropertiesOHOS.size(), + allowed_structs_VkNativeBufferPropertiesOHOS.data(), GeneratedVulkanHeaderVersion, + kVUIDUndefined, kVUIDUndefined, false, false); + } + return skip; +} + +bool StatelessValidation::PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError(loc, "VK_OHOS_external_memory"); + skip |= ValidateStructType(loc.dot(Field::pInfo), "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS", pInfo, + VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS, true, kVUIDUndefined, kVUIDUndefined); + if (pInfo != nullptr) { + [[maybe_unused]] const Location pInfo_loc = loc.dot(Field::pInfo); + skip |= ValidateStructPnext(pInfo_loc, pInfo->pNext, 0, nullptr, GeneratedVulkanHeaderVersion, kVUIDUndefined, + kVUIDUndefined, false, true); + + skip |= ValidateRequiredHandle(pInfo_loc.dot(Field::memory), pInfo->memory); + } + skip |= ValidateRequiredPointer(loc.dot(Field::pBuffer), pBuffer, kVUIDUndefined); + return skip; +} +#endif // VK_USE_PLATFORM_OHOS + bool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, diff --git a/layers/vulkan/generated/stateless_validation_helper.h b/layers/vulkan/generated/stateless_validation_helper.h index 63787b2db9b53fa64fa94ee642cd7228e342ad22..2ee704dff3ea54161755c68b4015363de7f0e19b 100644 --- a/layers/vulkan/generated/stateless_validation_helper.h +++ b/layers/vulkan/generated/stateless_validation_helper.h @@ -1722,6 +1722,23 @@ bool PreCallValidateGetScreenBufferPropertiesQNX(VkDevice device, const struct _ VkScreenBufferPropertiesQNX* pProperties, const ErrorObject& error_obj) const override; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const ErrorObject& error_obj) const override; +bool PreCallValidateGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage, const ErrorObject& error_obj) const override; +bool PreCallValidateAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, + const ErrorObject& error_obj) const override; +bool PreCallValidateQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd, + const ErrorObject& error_obj) const override; +bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const ErrorObject& error_obj) const override; +bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const ErrorObject& error_obj) const override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, diff --git a/layers/vulkan/generated/thread_safety.cpp b/layers/vulkan/generated/thread_safety.cpp index fbec2b479e3427f05348d2c5a07fb74052050abc..ec299d6966c8f303613e4844fa088ce386eb5caf 100644 --- a/layers/vulkan/generated/thread_safety.cpp +++ b/layers/vulkan/generated/thread_safety.cpp @@ -7768,6 +7768,97 @@ void ThreadSafety::PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, c } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +void ThreadSafety::PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) { + StartReadObjectParentInstance(instance, record_obj.location); +} + +void ThreadSafety::PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) { + FinishReadObjectParentInstance(instance, record_obj.location); + if (record_obj.result == VK_SUCCESS) { + CreateObjectParentInstance(*pSurface); + } +} + +void ThreadSafety::PreCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage, const RecordObject& record_obj) { + StartReadObjectParentInstance(device, record_obj.location); +} + +void ThreadSafety::PostCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage, const RecordObject& record_obj) { + FinishReadObjectParentInstance(device, record_obj.location); +} + +void ThreadSafety::PreCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence, const RecordObject& record_obj) { + StartReadObjectParentInstance(device, record_obj.location); + StartReadObject(image, record_obj.location); + StartReadObject(semaphore, record_obj.location); + StartReadObject(fence, record_obj.location); +} + +void ThreadSafety::PostCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, + VkFence fence, const RecordObject& record_obj) { + FinishReadObjectParentInstance(device, record_obj.location); + FinishReadObject(image, record_obj.location); + FinishReadObject(semaphore, record_obj.location); + FinishReadObject(fence, record_obj.location); +} + +void ThreadSafety::PreCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd, const RecordObject& record_obj) { + StartReadObject(queue, record_obj.location); + + if (pWaitSemaphores) { + for (uint32_t index = 0; index < waitSemaphoreCount; index++) { + StartReadObject(pWaitSemaphores[index], record_obj.location); + } + } + StartReadObject(image, record_obj.location); +} + +void ThreadSafety::PostCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd, const RecordObject& record_obj) { + FinishReadObject(queue, record_obj.location); + + if (pWaitSemaphores) { + for (uint32_t index = 0; index < waitSemaphoreCount; index++) { + FinishReadObject(pWaitSemaphores[index], record_obj.location); + } + } + FinishReadObject(image, record_obj.location); +} + +void ThreadSafety::PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const RecordObject& record_obj) { + StartReadObjectParentInstance(device, record_obj.location); +} + +void ThreadSafety::PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const RecordObject& record_obj) { + FinishReadObjectParentInstance(device, record_obj.location); +} + +void ThreadSafety::PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) { + StartReadObjectParentInstance(device, record_obj.location); +} + +void ThreadSafety::PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) { + FinishReadObjectParentInstance(device, record_obj.location); +} + +#endif // VK_USE_PLATFORM_OHOS void ThreadSafety::PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, diff --git a/layers/vulkan/generated/thread_safety_commands.h b/layers/vulkan/generated/thread_safety_commands.h index 1746dbb617d529f9bb6b586dbf314c2a27ab30c9..8934ba7d0a52a66af815c659c5b03b36d9dd330c 100644 --- a/layers/vulkan/generated/thread_safety_commands.h +++ b/layers/vulkan/generated/thread_safety_commands.h @@ -3977,6 +3977,47 @@ void PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _s VkScreenBufferPropertiesQNX* pProperties, const RecordObject& record_obj) override; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) override; + +void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, + const RecordObject& record_obj) override; + +void PreCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage, const RecordObject& record_obj) override; + +void PostCallRecordGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, + uint64_t* grallocUsage, const RecordObject& record_obj) override; + +void PreCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, + const RecordObject& record_obj) override; + +void PostCallRecordAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence, + const RecordObject& record_obj) override; + +void PreCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd, const RecordObject& record_obj) override; + +void PostCallRecordQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, + VkImage image, int32_t* pNativeFenceFd, const RecordObject& record_obj) override; + +void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, const RecordObject& record_obj) override; + +void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + const RecordObject& record_obj) override; + +void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) override; + +void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, const RecordObject& record_obj) override; + +#endif // VK_USE_PLATFORM_OHOS void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, diff --git a/layers/vulkan/generated/vk_dispatch_table_helper.h b/layers/vulkan/generated/vk_dispatch_table_helper.h index b306ac0863a3eaf93d5a0aede363394abf5f5276..97ed3b17aff7d482908d43f81a6133684cb6ef5d 100644 --- a/layers/vulkan/generated/vk_dispatch_table_helper.h +++ b/layers/vulkan/generated/vk_dispatch_table_helper.h @@ -1689,6 +1689,33 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubGetScreenBufferPropertiesQNX(VkDevice return VK_SUCCESS; } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL StubCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL StubGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, + VkImageUsageFlags imageUsage, uint64_t* grallocUsage) { + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL StubAcquireImageOHOS(VkDevice device, VkImage image, int32_t nativeFenceFd, + VkSemaphore semaphore, VkFence fence) { + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL StubQueueSignalReleaseImageOHOS(VkQueue queue, uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, VkImage image, + int32_t* pNativeFenceFd) { + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL StubGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + return VK_SUCCESS; +} +static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + return VK_SUCCESS; +} +#endif // VK_USE_PLATFORM_OHOS static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -2210,6 +2237,11 @@ const vvl::unordered_map> api_ {"vkQueueNotifyOutOfBandNV", {"VK_NV_low_latency2"}}, {"vkCmdSetAttachmentFeedbackLoopEnableEXT", {"VK_EXT_attachment_feedback_loop_dynamic_state"}}, {"vkGetScreenBufferPropertiesQNX", {"VK_QNX_external_memory_screen_buffer"}}, + {"vkGetSwapchainGrallocUsageOHOS", {"VK_OHOS_native_buffer"}}, + {"vkAcquireImageOHOS", {"VK_OHOS_native_buffer"}}, + {"vkQueueSignalReleaseImageOHOS", {"VK_OHOS_native_buffer"}}, + {"vkGetNativeBufferPropertiesOHOS", {"VK_OHOS_external_memory"}}, + {"vkGetMemoryNativeBufferOHOS", {"VK_OHOS_external_memory"}}, {"vkCreateAccelerationStructureKHR", {"VK_KHR_acceleration_structure"}}, {"vkDestroyAccelerationStructureKHR", {"VK_KHR_acceleration_structure"}}, {"vkCmdBuildAccelerationStructuresKHR", {"VK_KHR_acceleration_structure"}}, @@ -4280,6 +4312,28 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)StubGetScreenBufferPropertiesQNX; } #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + table->GetSwapchainGrallocUsageOHOS = (PFN_vkGetSwapchainGrallocUsageOHOS)gpa(device, "vkGetSwapchainGrallocUsageOHOS"); + if (table->GetSwapchainGrallocUsageOHOS == nullptr) { + table->GetSwapchainGrallocUsageOHOS = (PFN_vkGetSwapchainGrallocUsageOHOS)StubGetSwapchainGrallocUsageOHOS; + } + table->AcquireImageOHOS = (PFN_vkAcquireImageOHOS)gpa(device, "vkAcquireImageOHOS"); + if (table->AcquireImageOHOS == nullptr) { + table->AcquireImageOHOS = (PFN_vkAcquireImageOHOS)StubAcquireImageOHOS; + } + table->QueueSignalReleaseImageOHOS = (PFN_vkQueueSignalReleaseImageOHOS)gpa(device, "vkQueueSignalReleaseImageOHOS"); + if (table->QueueSignalReleaseImageOHOS == nullptr) { + table->QueueSignalReleaseImageOHOS = (PFN_vkQueueSignalReleaseImageOHOS)StubQueueSignalReleaseImageOHOS; + } + table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS)gpa(device, "vkGetNativeBufferPropertiesOHOS"); + if (table->GetNativeBufferPropertiesOHOS == nullptr) { + table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS)StubGetNativeBufferPropertiesOHOS; + } + table->GetMemoryNativeBufferOHOS = (PFN_vkGetMemoryNativeBufferOHOS)gpa(device, "vkGetMemoryNativeBufferOHOS"); + if (table->GetMemoryNativeBufferOHOS == nullptr) { + table->GetMemoryNativeBufferOHOS = (PFN_vkGetMemoryNativeBufferOHOS)StubGetMemoryNativeBufferOHOS; + } +#endif // VK_USE_PLATFORM_OHOS table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gpa(device, "vkCreateAccelerationStructureKHR"); if (table->CreateAccelerationStructureKHR == nullptr) { table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)StubCreateAccelerationStructureKHR; @@ -4946,5 +5000,11 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)StubGetPhysicalDeviceOpticalFlowImageFormatsNV; } +#ifdef VK_USE_PLATFORM_OHOS + table->CreateSurfaceOHOS = (PFN_vkCreateSurfaceOHOS)gpa(instance, "vkCreateSurfaceOHOS"); + if (table->CreateSurfaceOHOS == nullptr) { + table->CreateSurfaceOHOS = (PFN_vkCreateSurfaceOHOS)StubCreateSurfaceOHOS; + } +#endif // VK_USE_PLATFORM_OHOS } // NOLINTEND diff --git a/layers/vulkan/generated/vk_extension_helper.h b/layers/vulkan/generated/vk_extension_helper.h index 39c14c3162ebedc370092929c41a2273919c9f6e..69138f02698c46a3c2d7c446df0ada04ab444550 100644 --- a/layers/vulkan/generated/vk_extension_helper.h +++ b/layers/vulkan/generated/vk_extension_helper.h @@ -114,6 +114,7 @@ struct InstanceExtensions { ExtEnabled vk_google_surfaceless_query{kNotEnabled}; ExtEnabled vk_lunarg_direct_driver_loading{kNotEnabled}; ExtEnabled vk_ext_layer_settings{kNotEnabled}; + ExtEnabled vk_ohos_surface{kNotEnabled}; static const PromotedExtensionInfoMap &get_promotion_info_map() { static const PromotedExtensionInfoMap promoted_map = { @@ -281,6 +282,9 @@ struct InstanceExtensions { {VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_lunarg_direct_driver_loading, {})}, {VK_EXT_LAYER_SETTINGS_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_ext_layer_settings, {})}, +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_ohos_surface, {})}, +#endif // VK_USE_PLATFORM_OHOS }; return info_map; @@ -393,6 +397,9 @@ static const std::set kInstanceExtensionNames = { VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME, VK_EXT_LAYER_SETTINGS_EXTENSION_NAME, +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_SURFACE_EXTENSION_NAME, +#endif // VK_USE_PLATFORM_OHOS }; struct DeviceExtensions : public InstanceExtensions { @@ -712,6 +719,8 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_qnx_external_memory_screen_buffer{kNotEnabled}; ExtEnabled vk_msft_layered_driver{kNotEnabled}; ExtEnabled vk_nv_descriptor_pool_overallocation{kNotEnabled}; + ExtEnabled vk_ohos_native_buffer{kNotEnabled}; + ExtEnabled vk_ohos_external_memory{kNotEnabled}; ExtEnabled vk_khr_acceleration_structure{kNotEnabled}; ExtEnabled vk_khr_ray_tracing_pipeline{kNotEnabled}; ExtEnabled vk_khr_ray_query{kNotEnabled}; @@ -1830,6 +1839,10 @@ struct DeviceExtensions : public InstanceExtensions { {VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_nv_descriptor_pool_overallocation, {{{&DeviceExtensions::vk_feature_version_1_1, "VK_VERSION_1_1"}}})}, +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ohos_native_buffer, {})}, + {VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ohos_external_memory, {})}, +#endif // VK_USE_PLATFORM_OHOS {VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_acceleration_structure, {{{&DeviceExtensions::vk_feature_version_1_1, "VK_VERSION_1_1"}, @@ -2271,6 +2284,10 @@ static const std::set kDeviceExtensionNames = { #endif // VK_USE_PLATFORM_SCREEN_QNX VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME, VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME, +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME, + VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, +#endif // VK_USE_PLATFORM_OHOS VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME, VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME, VK_KHR_RAY_QUERY_EXTENSION_NAME, diff --git a/layers/vulkan/generated/vk_function_pointers.cpp b/layers/vulkan/generated/vk_function_pointers.cpp index db157bdd6c5e07def0b18ecdce628c0a335f2a24..190df4bfb9b0db3e86e4c2b425fe102c6f87bd7f 100644 --- a/layers/vulkan/generated/vk_function_pointers.cpp +++ b/layers/vulkan/generated/vk_function_pointers.cpp @@ -778,6 +778,14 @@ PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT CmdSetAttachmentFeedbackLoopEnableEX #ifdef VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +PFN_vkCreateSurfaceOHOS CreateSurfaceOHOS; +PFN_vkGetSwapchainGrallocUsageOHOS GetSwapchainGrallocUsageOHOS; +PFN_vkAcquireImageOHOS AcquireImageOHOS; +PFN_vkQueueSignalReleaseImageOHOS QueueSignalReleaseImageOHOS; +PFN_vkGetNativeBufferPropertiesOHOS GetNativeBufferPropertiesOHOS; +PFN_vkGetMemoryNativeBufferOHOS GetMemoryNativeBufferOHOS; +#endif // VK_USE_PLATFORM_OHOS PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR; @@ -1461,6 +1469,13 @@ void InitInstanceExtension(VkInstance instance, const char* extension_name) { } }, #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + { + "VK_OHOS_surface", [](VkInstance instance) { + CreateSurfaceOHOS = reinterpret_cast(GetInstanceProcAddr(instance, "vkCreateSurfaceOHOS")); + } + }, +#endif // VK_USE_PLATFORM_OHOS }; @@ -2365,6 +2380,21 @@ void InitDeviceExtension(VkInstance instance, VkDevice device, const char* exten } }, #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + { + "VK_OHOS_native_buffer", [](VkInstance , VkDevice device) { + GetSwapchainGrallocUsageOHOS = reinterpret_cast(GetDeviceProcAddr(device, "vkGetSwapchainGrallocUsageOHOS")); + AcquireImageOHOS = reinterpret_cast(GetDeviceProcAddr(device, "vkAcquireImageOHOS")); + QueueSignalReleaseImageOHOS = reinterpret_cast(GetDeviceProcAddr(device, "vkQueueSignalReleaseImageOHOS")); + } + }, + { + "VK_OHOS_external_memory", [](VkInstance , VkDevice device) { + GetNativeBufferPropertiesOHOS = reinterpret_cast(GetDeviceProcAddr(device, "vkGetNativeBufferPropertiesOHOS")); + GetMemoryNativeBufferOHOS = reinterpret_cast(GetDeviceProcAddr(device, "vkGetMemoryNativeBufferOHOS")); + } + }, +#endif // VK_USE_PLATFORM_OHOS { "VK_KHR_acceleration_structure", [](VkInstance , VkDevice device) { CreateAccelerationStructureKHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR")); @@ -2897,6 +2927,14 @@ void ResetAllExtensions() { #ifdef VK_USE_PLATFORM_SCREEN_QNX GetScreenBufferPropertiesQNX = nullptr; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + CreateSurfaceOHOS = nullptr; + GetSwapchainGrallocUsageOHOS = nullptr; + AcquireImageOHOS = nullptr; + QueueSignalReleaseImageOHOS = nullptr; + GetNativeBufferPropertiesOHOS = nullptr; + GetMemoryNativeBufferOHOS = nullptr; +#endif // VK_USE_PLATFORM_OHOS CreateAccelerationStructureKHR = nullptr; DestroyAccelerationStructureKHR = nullptr; CmdBuildAccelerationStructuresKHR = nullptr; diff --git a/layers/vulkan/generated/vk_function_pointers.h b/layers/vulkan/generated/vk_function_pointers.h index 96a29930929369118356e93506953bce5d986bdb..83bff7f64c54e2d15235b2962cabb60851668a59 100644 --- a/layers/vulkan/generated/vk_function_pointers.h +++ b/layers/vulkan/generated/vk_function_pointers.h @@ -741,6 +741,14 @@ extern PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT CmdSetAttachmentFeedbackLoopE #ifdef VK_USE_PLATFORM_SCREEN_QNX extern PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS +extern PFN_vkCreateSurfaceOHOS CreateSurfaceOHOS; +extern PFN_vkGetSwapchainGrallocUsageOHOS GetSwapchainGrallocUsageOHOS; +extern PFN_vkAcquireImageOHOS AcquireImageOHOS; +extern PFN_vkQueueSignalReleaseImageOHOS QueueSignalReleaseImageOHOS; +extern PFN_vkGetNativeBufferPropertiesOHOS GetNativeBufferPropertiesOHOS; +extern PFN_vkGetMemoryNativeBufferOHOS GetMemoryNativeBufferOHOS; +#endif // VK_USE_PLATFORM_OHOS extern PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; extern PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; extern PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR; diff --git a/layers/vulkan/generated/vk_layer_dispatch_table.h b/layers/vulkan/generated/vk_layer_dispatch_table.h index ca1cbba104d56d5d5269c00b5fa986f749212e8d..ff815d5dda0ed797e25732705143838135a7f668 100644 --- a/layers/vulkan/generated/vk_layer_dispatch_table.h +++ b/layers/vulkan/generated/vk_layer_dispatch_table.h @@ -172,6 +172,9 @@ typedef struct VkLayerInstanceDispatchTable_ { PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkCreateSurfaceOHOS CreateSurfaceOHOS; +#endif // VK_USE_PLATFORM_OHOS } VkLayerInstanceDispatchTable; // Device function pointer dispatch table @@ -739,6 +742,13 @@ typedef struct VkLayerDispatchTable_ { #ifdef VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkGetSwapchainGrallocUsageOHOS GetSwapchainGrallocUsageOHOS; + PFN_vkAcquireImageOHOS AcquireImageOHOS; + PFN_vkQueueSignalReleaseImageOHOS QueueSignalReleaseImageOHOS; + PFN_vkGetNativeBufferPropertiesOHOS GetNativeBufferPropertiesOHOS; + PFN_vkGetMemoryNativeBufferOHOS GetMemoryNativeBufferOHOS; +#endif // VK_USE_PLATFORM_OHOS PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR; diff --git a/layers/vulkan/generated/vk_safe_struct.h b/layers/vulkan/generated/vk_safe_struct.h index f04c0db2f90e745c644b92561371212c540de7c9..1d310529dfeb8feb8d28642ec0fc85ffbfa21b87 100644 --- a/layers/vulkan/generated/vk_safe_struct.h +++ b/layers/vulkan/generated/vk_safe_struct.h @@ -17688,6 +17688,179 @@ struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { return reinterpret_cast(this); } }; +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkSurfaceCreateInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkSurfaceCreateFlagsOHOS flags; + OHNativeWindow* window{}; + + safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS& operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS(); + ~safe_VkSurfaceCreateInfoOHOS(); + void initialize(const VkSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCreateInfoOHOS* ptr() { return reinterpret_cast(this); } + VkSurfaceCreateInfoOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkNativeBufferOHOS { + VkStructureType sType; + const void* pNext{}; + BufferHandle* handle{}; + + safe_VkNativeBufferOHOS(const VkNativeBufferOHOS* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkNativeBufferOHOS(const safe_VkNativeBufferOHOS& copy_src); + safe_VkNativeBufferOHOS& operator=(const safe_VkNativeBufferOHOS& copy_src); + safe_VkNativeBufferOHOS(); + ~safe_VkNativeBufferOHOS(); + void initialize(const VkNativeBufferOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkNativeBufferOHOS* copy_src, PNextCopyState* copy_state = {}); + VkNativeBufferOHOS* ptr() { return reinterpret_cast(this); } + VkNativeBufferOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainImageCreateInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkSwapchainImageUsageFlagsOHOS usage; + + safe_VkSwapchainImageCreateInfoOHOS(const VkSwapchainImageCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainImageCreateInfoOHOS(const safe_VkSwapchainImageCreateInfoOHOS& copy_src); + safe_VkSwapchainImageCreateInfoOHOS& operator=(const safe_VkSwapchainImageCreateInfoOHOS& copy_src); + safe_VkSwapchainImageCreateInfoOHOS(); + ~safe_VkSwapchainImageCreateInfoOHOS(); + void initialize(const VkSwapchainImageCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainImageCreateInfoOHOS* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainImageCreateInfoOHOS* ptr() { return reinterpret_cast(this); } + VkSwapchainImageCreateInfoOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevicePresentationPropertiesOHOS { + VkStructureType sType; + const void* pNext{}; + VkBool32 sharedImage; + + safe_VkPhysicalDevicePresentationPropertiesOHOS(const VkPhysicalDevicePresentationPropertiesOHOS* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentationPropertiesOHOS(const safe_VkPhysicalDevicePresentationPropertiesOHOS& copy_src); + safe_VkPhysicalDevicePresentationPropertiesOHOS& operator=(const safe_VkPhysicalDevicePresentationPropertiesOHOS& copy_src); + safe_VkPhysicalDevicePresentationPropertiesOHOS(); + ~safe_VkPhysicalDevicePresentationPropertiesOHOS(); + void initialize(const VkPhysicalDevicePresentationPropertiesOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentationPropertiesOHOS* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentationPropertiesOHOS* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePresentationPropertiesOHOS const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkNativeBufferUsageOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t OHOSNativeBufferUsage; + + safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkNativeBufferUsageOHOS(const safe_VkNativeBufferUsageOHOS& copy_src); + safe_VkNativeBufferUsageOHOS& operator=(const safe_VkNativeBufferUsageOHOS& copy_src); + safe_VkNativeBufferUsageOHOS(); + ~safe_VkNativeBufferUsageOHOS(); + void initialize(const VkNativeBufferUsageOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkNativeBufferUsageOHOS* copy_src, PNextCopyState* copy_state = {}); + VkNativeBufferUsageOHOS* ptr() { return reinterpret_cast(this); } + VkNativeBufferUsageOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkNativeBufferPropertiesOHOS { + VkStructureType sType; + void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; + + safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkNativeBufferPropertiesOHOS(const safe_VkNativeBufferPropertiesOHOS& copy_src); + safe_VkNativeBufferPropertiesOHOS& operator=(const safe_VkNativeBufferPropertiesOHOS& copy_src); + safe_VkNativeBufferPropertiesOHOS(); + ~safe_VkNativeBufferPropertiesOHOS(); + void initialize(const VkNativeBufferPropertiesOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src, PNextCopyState* copy_state = {}); + VkNativeBufferPropertiesOHOS* ptr() { return reinterpret_cast(this); } + VkNativeBufferPropertiesOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkNativeBufferFormatPropertiesOHOS { + VkStructureType sType; + void* pNext{}; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + + safe_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkNativeBufferFormatPropertiesOHOS(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src); + safe_VkNativeBufferFormatPropertiesOHOS& operator=(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src); + safe_VkNativeBufferFormatPropertiesOHOS(); + ~safe_VkNativeBufferFormatPropertiesOHOS(); + void initialize(const VkNativeBufferFormatPropertiesOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkNativeBufferFormatPropertiesOHOS* copy_src, PNextCopyState* copy_state = {}); + VkNativeBufferFormatPropertiesOHOS* ptr() { return reinterpret_cast(this); } + VkNativeBufferFormatPropertiesOHOS const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + struct OH_NativeBuffer* buffer{}; + + safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportNativeBufferInfoOHOS(const safe_VkImportNativeBufferInfoOHOS& copy_src); + safe_VkImportNativeBufferInfoOHOS& operator=(const safe_VkImportNativeBufferInfoOHOS& copy_src); + safe_VkImportNativeBufferInfoOHOS(); + ~safe_VkImportNativeBufferInfoOHOS(); + void initialize(const VkImportNativeBufferInfoOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src, PNextCopyState* copy_state = {}); + VkImportNativeBufferInfoOHOS* ptr() { return reinterpret_cast(this); } + VkImportNativeBufferInfoOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryGetNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + + safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryGetNativeBufferInfoOHOS(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src); + safe_VkMemoryGetNativeBufferInfoOHOS& operator=(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src); + safe_VkMemoryGetNativeBufferInfoOHOS(); + ~safe_VkMemoryGetNativeBufferInfoOHOS(); + void initialize(const VkMemoryGetNativeBufferInfoOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetNativeBufferInfoOHOS* ptr() { return reinterpret_cast(this); } + VkMemoryGetNativeBufferInfoOHOS const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExternalFormatOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t externalFormat; + + safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExternalFormatOHOS(const safe_VkExternalFormatOHOS& copy_src); + safe_VkExternalFormatOHOS& operator=(const safe_VkExternalFormatOHOS& copy_src); + safe_VkExternalFormatOHOS(); + ~safe_VkExternalFormatOHOS(); + void initialize(const VkExternalFormatOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalFormatOHOS* copy_src, PNextCopyState* copy_state = {}); + VkExternalFormatOHOS* ptr() { return reinterpret_cast(this); } + VkExternalFormatOHOS const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { VkStructureType sType; const void* pNext{}; diff --git a/layers/vulkan/generated/vk_safe_struct_utils.cpp b/layers/vulkan/generated/vk_safe_struct_utils.cpp index d4e0688f2f6bb187d92751166e416f309199e4c8..3ca4129555cd1a2a130d8ac0fb905ca90f844a51 100644 --- a/layers/vulkan/generated/vk_safe_struct_utils.cpp +++ b/layers/vulkan/generated/vk_safe_struct_utils.cpp @@ -1732,6 +1732,20 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + safe_pNext = new safe_VkNativeBufferUsageOHOS(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + safe_pNext = new safe_VkNativeBufferFormatPropertiesOHOS(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + safe_pNext = new safe_VkImportNativeBufferInfoOHOS(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + safe_pNext = new safe_VkExternalFormatOHOS(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_OHOS case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -3468,6 +3482,20 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: delete reinterpret_cast(header); break; +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_OHOS case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: delete reinterpret_cast(header); break; diff --git a/layers/vulkan/generated/vk_safe_struct_vendor.cpp b/layers/vulkan/generated/vk_safe_struct_vendor.cpp index 8050dea437840db48a478d0b2c300096a4bdedf3..1ab3731455d7870b8168c10c8c35430dcc245cf5 100644 --- a/layers/vulkan/generated/vk_safe_struct_vendor.cpp +++ b/layers/vulkan/generated/vk_safe_struct_vendor.cpp @@ -15263,5 +15263,595 @@ void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize( descriptorPoolOverallocation = copy_src->descriptorPoolOverallocation; pNext = SafePnextCopy(copy_src->pNext); } +#ifdef VK_USE_PLATFORM_OHOS + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), window(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->window) { + window = new OHNativeWindow(*in_struct->window); + } +} + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS() + : sType(VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS), pNext(nullptr), flags(), window(nullptr) {} + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + window = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.window) { + window = new OHNativeWindow(*copy_src.window); + } +} + +safe_VkSurfaceCreateInfoOHOS& safe_VkSurfaceCreateInfoOHOS::operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src) { + if (©_src == this) return *this; + + if (window) delete window; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + window = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.window) { + window = new OHNativeWindow(*copy_src.window); + } + + return *this; +} + +safe_VkSurfaceCreateInfoOHOS::~safe_VkSurfaceCreateInfoOHOS() { + if (window) delete window; + FreePnextChain(pNext); +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const VkSurfaceCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (window) delete window; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + window = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->window) { + window = new OHNativeWindow(*in_struct->window); + } +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + window = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->window) { + window = new OHNativeWindow(*copy_src->window); + } +} + +safe_VkNativeBufferOHOS::safe_VkNativeBufferOHOS(const VkNativeBufferOHOS* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handle(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->handle) { + handle = new BufferHandle(*in_struct->handle); + } +} + +safe_VkNativeBufferOHOS::safe_VkNativeBufferOHOS() : sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS), pNext(nullptr), handle(nullptr) {} + +safe_VkNativeBufferOHOS::safe_VkNativeBufferOHOS(const safe_VkNativeBufferOHOS& copy_src) { + sType = copy_src.sType; + handle = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.handle) { + handle = new BufferHandle(*copy_src.handle); + } +} + +safe_VkNativeBufferOHOS& safe_VkNativeBufferOHOS::operator=(const safe_VkNativeBufferOHOS& copy_src) { + if (©_src == this) return *this; + + if (handle) delete handle; + FreePnextChain(pNext); + + sType = copy_src.sType; + handle = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.handle) { + handle = new BufferHandle(*copy_src.handle); + } + + return *this; +} + +safe_VkNativeBufferOHOS::~safe_VkNativeBufferOHOS() { + if (handle) delete handle; + FreePnextChain(pNext); +} + +void safe_VkNativeBufferOHOS::initialize(const VkNativeBufferOHOS* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (handle) delete handle; + FreePnextChain(pNext); + sType = in_struct->sType; + handle = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->handle) { + handle = new BufferHandle(*in_struct->handle); + } +} + +void safe_VkNativeBufferOHOS::initialize(const safe_VkNativeBufferOHOS* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handle = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->handle) { + handle = new BufferHandle(*copy_src->handle); + } +} + +safe_VkSwapchainImageCreateInfoOHOS::safe_VkSwapchainImageCreateInfoOHOS(const VkSwapchainImageCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), usage(in_struct->usage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainImageCreateInfoOHOS::safe_VkSwapchainImageCreateInfoOHOS() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS), pNext(nullptr), usage() {} + +safe_VkSwapchainImageCreateInfoOHOS::safe_VkSwapchainImageCreateInfoOHOS(const safe_VkSwapchainImageCreateInfoOHOS& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainImageCreateInfoOHOS& safe_VkSwapchainImageCreateInfoOHOS::operator=( + const safe_VkSwapchainImageCreateInfoOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainImageCreateInfoOHOS::~safe_VkSwapchainImageCreateInfoOHOS() { FreePnextChain(pNext); } + +void safe_VkSwapchainImageCreateInfoOHOS::initialize(const VkSwapchainImageCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainImageCreateInfoOHOS::initialize(const safe_VkSwapchainImageCreateInfoOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePresentationPropertiesOHOS::safe_VkPhysicalDevicePresentationPropertiesOHOS( + const VkPhysicalDevicePresentationPropertiesOHOS* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), sharedImage(in_struct->sharedImage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentationPropertiesOHOS::safe_VkPhysicalDevicePresentationPropertiesOHOS() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS), pNext(nullptr), sharedImage() {} + +safe_VkPhysicalDevicePresentationPropertiesOHOS::safe_VkPhysicalDevicePresentationPropertiesOHOS( + const safe_VkPhysicalDevicePresentationPropertiesOHOS& copy_src) { + sType = copy_src.sType; + sharedImage = copy_src.sharedImage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentationPropertiesOHOS& safe_VkPhysicalDevicePresentationPropertiesOHOS::operator=( + const safe_VkPhysicalDevicePresentationPropertiesOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sharedImage = copy_src.sharedImage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentationPropertiesOHOS::~safe_VkPhysicalDevicePresentationPropertiesOHOS() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentationPropertiesOHOS::initialize(const VkPhysicalDevicePresentationPropertiesOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sharedImage = in_struct->sharedImage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentationPropertiesOHOS::initialize(const safe_VkPhysicalDevicePresentationPropertiesOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sharedImage = copy_src->sharedImage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), OHOSNativeBufferUsage(in_struct->OHOSNativeBufferUsage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS() + : sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS), pNext(nullptr), OHOSNativeBufferUsage() {} + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS(const safe_VkNativeBufferUsageOHOS& copy_src) { + sType = copy_src.sType; + OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferUsageOHOS& safe_VkNativeBufferUsageOHOS::operator=(const safe_VkNativeBufferUsageOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferUsageOHOS::~safe_VkNativeBufferUsageOHOS() { FreePnextChain(pNext); } + +void safe_VkNativeBufferUsageOHOS::initialize(const VkNativeBufferUsageOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + OHOSNativeBufferUsage = in_struct->OHOSNativeBufferUsage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkNativeBufferUsageOHOS::initialize(const safe_VkNativeBufferUsageOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + OHOSNativeBufferUsage = copy_src->OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeBits(in_struct->memoryTypeBits) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS() + : sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS), pNext(nullptr), allocationSize(), memoryTypeBits() {} + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS(const safe_VkNativeBufferPropertiesOHOS& copy_src) { + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferPropertiesOHOS& safe_VkNativeBufferPropertiesOHOS::operator=(const safe_VkNativeBufferPropertiesOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferPropertiesOHOS::~safe_VkNativeBufferPropertiesOHOS() { FreePnextChain(pNext); } + +void safe_VkNativeBufferPropertiesOHOS::initialize(const VkNativeBufferPropertiesOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkNativeBufferPropertiesOHOS::initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS( + const VkNativeBufferFormatPropertiesOHOS* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + externalFormat(in_struct->externalFormat), + formatFeatures(in_struct->formatFeatures), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS() + : sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS), + pNext(nullptr), + format(), + externalFormat(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() {} + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS( + const safe_VkNativeBufferFormatPropertiesOHOS& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferFormatPropertiesOHOS& safe_VkNativeBufferFormatPropertiesOHOS::operator=( + const safe_VkNativeBufferFormatPropertiesOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferFormatPropertiesOHOS::~safe_VkNativeBufferFormatPropertiesOHOS() { FreePnextChain(pNext); } + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(const VkNativeBufferFormatPropertiesOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + externalFormat = in_struct->externalFormat; + formatFeatures = in_struct->formatFeatures; + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(const safe_VkNativeBufferFormatPropertiesOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + externalFormat = copy_src->externalFormat; + formatFeatures = copy_src->formatFeatures; + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->buffer) { + buffer = new OH_NativeBuffer(*in_struct->buffer); + } +} + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS() + : sType(VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS), pNext(nullptr), buffer(nullptr) {} + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS(const safe_VkImportNativeBufferInfoOHOS& copy_src) { + sType = copy_src.sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.buffer) { + buffer = new OH_NativeBuffer(*copy_src.buffer); + } +} + +safe_VkImportNativeBufferInfoOHOS& safe_VkImportNativeBufferInfoOHOS::operator=(const safe_VkImportNativeBufferInfoOHOS& copy_src) { + if (©_src == this) return *this; + + if (buffer) delete buffer; + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.buffer) { + buffer = new OH_NativeBuffer(*copy_src.buffer); + } + + return *this; +} + +safe_VkImportNativeBufferInfoOHOS::~safe_VkImportNativeBufferInfoOHOS() { + if (buffer) delete buffer; + FreePnextChain(pNext); +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const VkImportNativeBufferInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (buffer) delete buffer; + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->buffer) { + buffer = new OH_NativeBuffer(*in_struct->buffer); + } +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->buffer) { + buffer = new OH_NativeBuffer(*copy_src->buffer); + } +} + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS), pNext(nullptr), memory() {} + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetNativeBufferInfoOHOS& safe_VkMemoryGetNativeBufferInfoOHOS::operator=( + const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetNativeBufferInfoOHOS::~safe_VkMemoryGetNativeBufferInfoOHOS() { FreePnextChain(pNext); } + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const VkMemoryGetNativeBufferInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalFormat(in_struct->externalFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS), pNext(nullptr), externalFormat() {} + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS(const safe_VkExternalFormatOHOS& copy_src) { + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalFormatOHOS& safe_VkExternalFormatOHOS::operator=(const safe_VkExternalFormatOHOS& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFormatOHOS::~safe_VkExternalFormatOHOS() { FreePnextChain(pNext); } + +void safe_VkExternalFormatOHOS::initialize(const VkExternalFormatOHOS* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormat = in_struct->externalFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalFormatOHOS::initialize(const safe_VkExternalFormatOHOS* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalFormat = copy_src->externalFormat; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS // NOLINTEND diff --git a/layers/vulkan/generated/vk_validation_error_messages.h b/layers/vulkan/generated/vk_validation_error_messages.h index a9067942ee9ab234283c45e594f61c9d0610136d..2589652882f86632461e2c4232817c4e0770758f 100644 --- a/layers/vulkan/generated/vk_validation_error_messages.h +++ b/layers/vulkan/generated/vk_validation_error_messages.h @@ -6487,6 +6487,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkSurfaceCapabilities2KHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkSurfaceCapabilitiesFullScreenExclusiveEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT", "1.3-extensions"}, {"VUID-VkSurfaceCapabilitiesPresentBarrierNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-sType-sType", "sType must be VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-window-01248", "window must point to a valid OHOS NativeWindow", "1.3-extensions"}, {"VUID-VkSurfaceFormat2KHR-pNext-06750", "If the imageCompressionControlSwapchain feature is not enabled, the pNext chain must not include an VkImageCompressionPropertiesEXT structure", "1.3-extensions"}, {"VUID-VkSurfaceFormat2KHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkImageCompressionPropertiesEXT", "1.3-extensions"}, {"VUID-VkSurfaceFormat2KHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", "1.3-extensions"}, @@ -17767,6 +17771,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCreateStreamDescriptorSurfaceGGP-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateStreamDescriptorSurfaceGGP-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkStreamDescriptorSurfaceCreateInfoGGP structure", "1.3-extensions"}, {"VUID-vkCreateStreamDescriptorSurfaceGGP-pSurface-parameter", "pSurface must be a valid pointer to a VkSurfaceKHR handle", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-instance-parameter", "instance must be a valid VkInstance handle", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkSurfaceCreateInfoOHOS structure", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pSurface-parameter", "pSurface must be a valid pointer to a VkSurfaceKHR handle", "1.3-extensions"}, {"VUID-vkCreateSwapchainKHR-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkCreateSwapchainKHR-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateSwapchainKHR-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure", "1.3-extensions"}, diff --git a/scripts/gn/layers-ohos.gni b/scripts/gn/layers-ohos.gni new file mode 100644 index 0000000000000000000000000000000000000000..983a057973259b1f4c1b7565742a3a92327ef495 --- /dev/null +++ b/scripts/gn/layers-ohos.gni @@ -0,0 +1,25 @@ +import("//build/ohos.gni") + +# import("//build_overrides/vulkan_validation_layers.gni") +# Paths to validation layer dependencies +vulkan_headers_dir = "//third_party/vulkan-headers" +vulkan_utility_libraries_dir = "//third_party/vulkan-utility-libraries" +vvl_spirv_tools_dir = "//third_party//spirv-tools" +vvl_spirv_headers_dir = "//third_party/spirv-headers" +vvl_glslang_dir = "//third_party/glslang" +# robin_hood_headers_dir = "external/robin-hood-hashing/src/include" + +# Subdirectories for generated files +vulkan_data_subdir = "" +vulkan_gen_subdir = "" + +# Build options +ozone_platform_x11 = false + +is_ohos = current_os == "ohos" +is_android = current_os == "android" +is_ios = current_os == "ios" +is_mac = current_os == "tvos" || current_os == "mac" +is_win = current_os == "win" || current_os == "mingw" +is_linux = current_os == "linux" +is_fuchsia = current_os == "fuchsia" diff --git a/scripts/gn/secondary/build_overrides/spirv_tools.gni b/scripts/gn/secondary/build_overrides/spirv_tools.gni index 6df1a96f3e89c8822296adcc89ac9537994aa5fe..f2019dde388375cb6ef7bc9b2dfc44fbe202f56d 100644 --- a/scripts/gn/secondary/build_overrides/spirv_tools.gni +++ b/scripts/gn/secondary/build_overrides/spirv_tools.gni @@ -16,5 +16,5 @@ spirv_tools_standalone = false # Paths to SPIRV-Tools dependencies -spirv_tools_googletest_dir = "//external/googletest" -spirv_tools_spirv_headers_dir = "//external/SPIRV-Headers" +spirv_tools_googletest_dir = "//third_party/vulkan-validationlayers/external/googletest" +spirv_tools_spirv_headers_dir = "//third_party/vulkan-validationlayers/external/SPIRV-Headers" diff --git a/scripts/gn/secondary/build_overrides/vulkan_headers.gni b/scripts/gn/secondary/build_overrides/vulkan_headers.gni index 5f24b39eed64cb385dde3e259bfba8d20a496fc9..72b0859c8fbdfeb1e0b2eb904557bf99bd3d88bb 100644 --- a/scripts/gn/secondary/build_overrides/vulkan_headers.gni +++ b/scripts/gn/secondary/build_overrides/vulkan_headers.gni @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -vulkan_use_x11 = true +vulkan_use_x11 = false diff --git a/scripts/gn/secondary/build_overrides/vulkan_utility_libraries.gni b/scripts/gn/secondary/build_overrides/vulkan_utility_libraries.gni index 6cf79d067caf3b8a7eb0eef6351ee486a1fc378e..a4a78db59c844a84d1999b9b4d6278f2153d2589 100644 --- a/scripts/gn/secondary/build_overrides/vulkan_utility_libraries.gni +++ b/scripts/gn/secondary/build_overrides/vulkan_utility_libraries.gni @@ -2,4 +2,4 @@ # # SPDX-License-Identifier: Apache-2.0 -vulkan_headers_dir = "//external/Vulkan-Headers" +vulkan_headers_dir = "//third_party/vulkan-headers" diff --git a/scripts/gn/secondary/build_overrides/vulkan_validation_layers.gni b/scripts/gn/secondary/build_overrides/vulkan_validation_layers.gni index 3f144fc5290a4d444cd1bd1788454f754e8d02ce..812ba11b1b1429d31f4e73beb9e058229c3a9948 100644 --- a/scripts/gn/secondary/build_overrides/vulkan_validation_layers.gni +++ b/scripts/gn/secondary/build_overrides/vulkan_validation_layers.gni @@ -13,12 +13,12 @@ # limitations under the License. # Paths to validation layer dependencies -vulkan_headers_dir = "//external/Vulkan-Headers" -vulkan_utility_libraries_dir = "//external/Vulkan-Utility-Libraries" -vvl_spirv_tools_dir = "//external/SPIRV-Tools" -vvl_spirv_headers_dir = "//external/SPIRV-Headers" -vvl_glslang_dir = "//external/glslang/" -robin_hood_headers_dir = "//external/robin-hood-hashing/src/include" +vulkan_headers_dir = "//third_party/vulkan-headers" +vulkan_utility_libraries_dir = "//third_party/vulkan-utility-libraries" +vvl_spirv_tools_dir = "//third_party/spirv-tools" +vvl_spirv_headers_dir = "//third_party/spirv-headers" +vvl_glslang_dir = "//third_party/glslang/" +# robin_hood_headers_dir = "//external/robin-hood-hashing/src/include" # Subdirectories for generated files vulkan_data_subdir = "" diff --git a/tests/openharmony/systemtest/BUILD.gn b/tests/openharmony/systemtest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..6b19cc70caa515a74431590f8c11feab89ac88cc --- /dev/null +++ b/tests/openharmony/systemtest/BUILD.gn @@ -0,0 +1,54 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# 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. + +import("//build/test.gni") + +module_out_path = "third_party/vulkan-validationlayers" + +group("systemtest") { + testonly = true + + deps = [ ":vulkan_validation_layers_system_test" ] +} + +ohos_systemtest("vulkan_validation_layers_system_test") { + defines = [ "VK_USE_PLATFORM_OHOS" ] + module_out_path = module_out_path + sources = [ "vulkan_validation_layers_system_test.cpp" ] + deps = [ ":vulkan_validation_layers_test_common" ] +} + +ohos_static_library("vulkan_validation_layers_test_common") { + visibility = [ ":*" ] + testonly = true + + public_deps = [ + "//third_party/googletest:gtest_main", + "//third_party/vulkan-headers:vulkan_headers", + "//third_party/zlib:libz", + ] + external_deps = [ + "c_utils:utils", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + "-Dprotected=public", + ] + + subsystem_name = "graphic" + part_name = "graphic_2d" +} diff --git a/tests/openharmony/systemtest/vulkan_validation_layers_system_test.cpp b/tests/openharmony/systemtest/vulkan_validation_layers_system_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..042c5e3897b316d1e3d84867c388dc91a4f807f9 --- /dev/null +++ b/tests/openharmony/systemtest/vulkan_validation_layers_system_test.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * 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. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "refbase.h" + +using namespace testing; +using namespace testing::ext; +using namespace OHOS::Rosen; + +namespace vulkan::loader { +class VulkanValidationLayersSystemTest : public testing::Test { +public: + static void SetUpTestCase() {} + static void TearDownTestCase() + { + if (isSupportedVulkan_) { + fpDestroyInstance(instance_, nullptr); + } + if (libVulkan_ != nullptr) { + dlclose(libVulkan_); + libVulkan_ = nullptr; + } + } + static inline void DLOpenLibVulkan(); + + static inline PFN_vkCreateInstance vkCreateInstance; + static inline PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; + + static inline PFN_vkDestroyInstance fpDestroyInstance; + + static inline void *libVulkan_ = nullptr; + static inline VkInstance instance_ = nullptr; + static inline bool isSupportedVulkan_ = false; +}; + +void VulkanValidationLayersSystemTest::DLOpenLibVulkan() +{ +#if (defined(__aarch64__) || defined(__x86_64__)) + const char *path = "/system/lib64/platformsdk/libvulkan.so"; +#else + const char *path = "/system/lib/platformsdk/libvulkan.so"; +#endif + libVulkan_ = dlopen(path, RTLD_NOW | RTLD_LOCAL); + if (libVulkan_ == nullptr) { + std::cout << "dlerror: " << dlerror() << std::endl; + isSupportedVulkan_ = false; + return; + } + isSupportedVulkan_ = true; +} + +/** + * @tc.name: Enable Vulkan Validation Layers + * @tc.desc: Enable Vulkan Validation Layers + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(VulkanValidationLayersSystemTest, EnableVVL, TestSize.Level1) +{ + DLOpenLibVulkan(); + if (isSupportedVulkan_) { + EXPECT_NE(libVulkan_, nullptr); + + // Load base functions + vkEnumerateInstanceLayerProperties = reinterpret_cast( + dlsym(libVulkan_, "vkEnumerateInstanceLayerProperties")); + EXPECT_NE(vkEnumerateInstanceLayerProperties, nullptr); + vkCreateInstance = reinterpret_cast(dlsym(libVulkan_, "vkCreateInstance")); + EXPECT_NE(vkCreateInstance, nullptr); + VkApplicationInfo appInfo = {}; + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pApplicationName = "pApplicationName"; + appInfo.pEngineName = "pEngineName"; + appInfo.apiVersion = VK_API_VERSION_1_0; + + std::vector instanceExtensions = { + VK_KHR_SURFACE_EXTENSION_NAME, + VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + }; + + VkInstanceCreateInfo instanceCreateInfo = {}; + instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + instanceCreateInfo.pNext = NULL; + instanceCreateInfo.pApplicationInfo = &appInfo; + + instanceCreateInfo.enabledExtensionCount = static_cast(instanceExtensions.size()); + instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.data(); + + const char* validationLayerName = "VK_LAYER_KHRONOS_validation"; + // Check if this layer is available at instance level + uint32_t instanceLayerCount; + vkEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr); + std::vector instanceLayerProperties(instanceLayerCount); + vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayerProperties.data()); + bool validationLayerPresent = false; + for (VkLayerProperties layer : instanceLayerProperties) { + if (strcmp(layer.layerName, validationLayerName) == 0) { + validationLayerPresent = true; + break; + } + } + if (validationLayerPresent) { + instanceCreateInfo.ppEnabledLayerNames = &validationLayerName; + instanceCreateInfo.enabledLayerCount = 1; + } else { + std::cerr << "Validation layer VK_LAYER_KHRONOS_validation not present, validation is disabled"; + } + + EXPECT_NE(validationLayerPresent, false); + + VkResult result = vkCreateInstance(&instanceCreateInfo, nullptr, &instance_); + if (result == VK_ERROR_INCOMPATIBLE_DRIVER) { + isSupportedVulkan_ = false; + } else { + isSupportedVulkan_ = true; + } + EXPECT_NE(result, VK_SUCCESS); + std::cout << "TrytoCreateVkInstance result: " << result << std::endl; + } +}