diff --git a/0001-fix-vk.xml.patch b/0001-fix-vk.xml.patch new file mode 100644 index 0000000000000000000000000000000000000000..5a52abb32e04f3fc88d06d4f9e3cb1d193b6870c --- /dev/null +++ b/0001-fix-vk.xml.patch @@ -0,0 +1,29 @@ +From 2db7ef659877ff34e400469d14eb53a5349b0bd9 Mon Sep 17 00:00:00 2001 +From: andrew0229 +Date: Wed, 15 Mar 2023 01:13:39 +0000 +Subject: [PATCH] fix vk.xml + +Signed-off-by: andrew0229 +Change-Id: Ib516cc68d2481ce3e2c72c342e9744f3d369cb57 +--- + registry/vk.xml | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/registry/vk.xml b/registry/vk.xml +index b9260fa..d0fc9ee 100644 +--- a/registry/vk.xml ++++ b/registry/vk.xml +@@ -20548,8 +20548,8 @@ typedef void* MTLSharedEvent_id; + + + +- +- ++ ++ + + + +-- +2.25.1 + diff --git a/2.patch.txt b/2.patch.txt new file mode 100644 index 0000000000000000000000000000000000000000..6da1be9767733596544bf5d2779ec435c17f0e54 --- /dev/null +++ b/2.patch.txt @@ -0,0 +1,2616 @@ +From 592972e531c1a1943cfa071e5365ac734cfe57c9 Mon Sep 17 00:00:00 2001 +From: andrew0229 +Date: Wed, 15 Mar 2023 02:02:40 +0000 +Subject: [PATCH 1/3] add OHOS ext [todo] + +Signed-off-by: andrew0229 +--- + .../vulkan_validation_layers.gni | 9 +- + build-openharmony/BUILD.gn | 334 ++++++++++++ + build-openharmony/build_overrides/build.gni | 16 + + .../build_overrides/spirv_tools.gni | 20 + + .../build_overrides/vulkan_headers.gni | 15 + + .../vulkan_validation_layers.gni | 25 + + layers/generated/best_practices.cpp | 52 ++ + layers/generated/best_practices.h | 34 ++ + layers/generated/chassis.cpp | 85 +++ + layers/generated/chassis.h | 37 ++ + layers/generated/chassis_dispatch_helper.h | 18 + + .../corechecks_optick_instrumentation.cpp | 54 ++ + .../corechecks_optick_instrumentation.h | 15 + + layers/generated/layer_chassis_dispatch.cpp | 58 ++ + layers/generated/layer_chassis_dispatch.h | 19 + + layers/generated/object_tracker.cpp | 54 ++ + layers/generated/object_tracker.h | 28 + + layers/generated/parameter_validation.cpp | 151 +++++- + layers/generated/parameter_validation.h | 19 + + layers/generated/thread_safety.cpp | 56 ++ + layers/generated/thread_safety.h | 41 ++ + layers/generated/vk_dispatch_table_helper.h | 23 + + layers/generated/vk_enum_string_helper.h | 18 + + layers/generated/vk_extension_helper.h | 19 + + layers/generated/vk_layer_dispatch_table.h | 13 + + layers/generated/vk_safe_struct.cpp | 502 ++++++++++++++++++ + layers/generated/vk_safe_struct.h | 128 +++++ + layers/generated/vk_typemap_helper.h | 77 +++ + .../generated/vk_validation_error_messages.h | 8 + + scripts/common_codegen.py | 1 + + 30 files changed, 1901 insertions(+), 28 deletions(-) + create mode 100644 build-openharmony/BUILD.gn + create mode 100644 build-openharmony/build_overrides/build.gni + create mode 100644 build-openharmony/build_overrides/spirv_tools.gni + create mode 100644 build-openharmony/build_overrides/vulkan_headers.gni + create mode 100644 build-openharmony/build_overrides/vulkan_validation_layers.gni + +diff --git a/build-gn/secondary/build_overrides/vulkan_validation_layers.gni b/build-gn/secondary/build_overrides/vulkan_validation_layers.gni +index 26e2ec5e0..4716578c4 100644 +--- a/build-gn/secondary/build_overrides/vulkan_validation_layers.gni ++++ b/build-gn/secondary/build_overrides/vulkan_validation_layers.gni +@@ -13,11 +13,10 @@ + # limitations under the License. + + # Paths to validation layer dependencies +-vulkan_headers_dir = "//external/Vulkan-Headers" +-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" ++vvl_spirv_tools_dir = "external/SPIRV-Tools" ++vvl_glslang_dir = "external/glslang/" ++robin_hood_headers_dir = "external/robin-hood-hashing/src/include" + + # Subdirectories for generated files + vulkan_data_subdir = "" +diff --git a/build-openharmony/BUILD.gn b/build-openharmony/BUILD.gn +new file mode 100644 +index 000000000..3598b92d5 +--- /dev/null ++++ b/build-openharmony/BUILD.gn +@@ -0,0 +1,334 @@ ++# Copyright (C) 2018-2021 The ANGLE Project Authors. ++# Copyright (C) 2019-2021 LunarG, Inc. ++# ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# https://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_overrides/build.gni") ++import("./build_overrides/vulkan_validation_layers.gni") ++ ++# Fuchsia has non-upstream changes to the vulkan layers, so we don't want ++# to build it from upstream sources. ++assert(!is_fuchsia) ++ ++# target_gen_dir:: //out/rk3568/gen/third_party/Vulkan-ValidationLayers/build-openharmony ++# vulkan_gen_dir = "$target_gen_dir/$vulkan_gen_subdir" ++# vulkan_gen_dir:: //out/rk3568/gen/third_party/Vulkan-ValidationLayers/build-openharmony/ ++# raw_vulkan_gen_dir = rebase_path(vulkan_gen_dir, root_build_dir) ++# raw_vulkan_gen_dir:: gen/third_party/Vulkan-ValidationLayers/build-openharmony/ ++ ++# root_out_dir:: //out/rk3568 ++vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir" ++# vulkan_data_dir:: //out/rk3568/ ++ ++# raw_vulkan_data_dir = rebase_path(vulkan_data_dir, root_build_dir) ++# raw_vulkan_data_dir:: ./ ++ ++# raw_root_out_dir = rebase_path(root_out_dir, root_build_dir) ++# raw_root_out_dir:: . ++ ++config("generated_layers_config") { ++ cflags = [ ++ "-Wno-conversion", ++ "-Wno-deprecated-copy", ++ "-Wno-extra-semi", ++ "-Wno-implicit-fallthrough", ++ "-Wno-missing-field-initializers", ++ "-Wno-newline-eof", ++ "-Wno-sign-compare", ++ "-Wno-unused-const-variable", ++ ] ++} ++ ++config("vulkan_internal_config") { ++ defines = [ ++ "VULKAN_NON_CMAKE_BUILD", ++ "VK_ENABLE_BETA_EXTENSIONS", ++ ] ++ ++ cflags = [] ++ if (is_clang || !is_win) { ++ cflags += [ "-Wno-unused-function" ] ++ } ++ if (is_ohos) { ++ cflags += [ "-Wno-extra-semi", ++ "-Wno-unused-but-set-variable" ] ++ } ++} ++ ++# The validation layers ++# --------------------- ++ ++config("vulkan_layer_config") { ++ include_dirs = [ ++ "../layers", ++ "../layers/generated", ++ ] ++} ++ ++core_validation_sources = [ ++ "../layers/android_ndk_types.h", ++ "../layers/base_node.cpp", ++ "../layers/base_node.h", ++ "../layers/buffer_state.cpp", ++ "../layers/buffer_state.h", ++ "../layers/buffer_validation.cpp", ++ "../layers/buffer_validation.h", ++ "../layers/convert_to_renderpass2.cpp", ++ "../layers/convert_to_renderpass2.h", ++ "../layers/core_validation.cpp", ++ "../layers/core_validation.h", ++ "../layers/core_validation_error_enums.h", ++ "../layers/cmd_buffer_state.h", ++ "../layers/cmd_buffer_state.cpp", ++ "../layers/device_memory_state.h", ++ "../layers/device_memory_state.cpp", ++ "../layers/device_state.h", ++ "../layers/image_state.h", ++ "../layers/image_state.cpp", ++ "../layers/pipeline_state.h", ++ "../layers/pipeline_state.cpp", ++ "../layers/pipeline_layout_state.h", ++ "../layers/pipeline_layout_state.cpp", ++ "../layers/pipeline_sub_state.h", ++ "../layers/pipeline_sub_state.cpp", ++ "../layers/qfo_transfer.h", ++ "../layers/query_state.h", ++ "../layers/queue_state.cpp", ++ "../layers/queue_state.h", ++ "../layers/ray_tracing_state.h", ++ "../layers/render_pass_state.h", ++ "../layers/render_pass_state.cpp", ++ "../layers/sampler_state.h", ++ "../layers/core_error_location.cpp", ++ "../layers/core_error_location.h", ++ "../layers/descriptor_sets.cpp", ++ "../layers/descriptor_sets.h", ++ "../layers/descriptor_validation.cpp", ++ "../layers/drawdispatch.cpp", ++ "../layers/generated/corechecks_optick_instrumentation.cpp", ++ "../layers/generated/corechecks_optick_instrumentation.h", ++ "../layers/generated/spirv_validation_helper.cpp", ++ "../layers/generated/spirv_grammar_helper.cpp", ++ "../layers/generated/spirv_grammar_helper.h", ++ "../layers/generated/command_validation.cpp", ++ "../layers/generated/command_validation.h", ++ "../layers/generated/gpu_pre_dispatch_comp.h", ++ "../layers/generated/gpu_pre_draw_vert.h", ++ "../layers/generated/gpu_as_inspection_comp.h", ++ "../layers/generated/synchronization_validation_types.cpp", ++ "../layers/generated/synchronization_validation_types.h", ++ "../layers/sync_utils.cpp", ++ "../layers/sync_utils.h", ++ "../layers/sync_vuid_maps.cpp", ++ "../layers/sync_vuid_maps.h", ++ "../layers/gpu_shaders/gpu_shaders_constants.h", ++ "../layers/gpu_utils.cpp", ++ "../layers/gpu_utils.h", ++ "../layers/gpu_validation.cpp", ++ "../layers/gpu_validation.h", ++ "../layers/gpu_vuids.h", ++ "../layers/image_layout_map.cpp", ++ "../layers/image_layout_map.h", ++ "../layers/range_vector.h", ++ "../layers/shader_module.cpp", ++ "../layers/shader_module.h", ++ "../layers/shader_validation.cpp", ++ "../layers/shader_validation.h", ++ "../layers/state_tracker.cpp", ++ "../layers/state_tracker.h", ++ "../layers/subresource_adapter.cpp", ++ "../layers/subresource_adapter.h", ++ "../layers/synchronization_validation.cpp", ++ "../layers/synchronization_validation.h", ++] ++ ++object_lifetimes_sources = [ ++ "../layers/generated/object_tracker.cpp", ++ "../layers/generated/object_tracker.h", ++ "../layers/object_lifetime_validation.h", ++ "../layers/object_tracker_utils.cpp", ++] ++ ++stateless_validation_sources = [ ++ "../layers/generated/parameter_validation.cpp", ++ "../layers/generated/parameter_validation.h", ++ "../layers/parameter_name.h", ++ "../layers/parameter_validation_utils.cpp", ++ "../layers/stateless_validation.h", ++] ++ ++thread_safety_sources = [ ++ "../layers/generated/thread_safety.cpp", ++ "../layers/generated/thread_safety.h", ++] ++ ++unique_objects_sources = [] ++ ++best_practices_sources = [ ++ "../layers/best_practices_error_enums.h", ++ "../layers/best_practices_utils.cpp", ++ "../layers/best_practices_validation.h", ++ "../layers/generated/best_practices.cpp", ++ "../layers/generated/best_practices.h", ++] ++ ++debug_printf_sources = [ ++ "../layers/debug_printf.cpp", ++ "../layers/debug_printf.h", ++] ++ ++chassis_sources = [ ++ "$vulkan_headers_dir/include/vulkan/vk_layer.h", ++ "$vulkan_headers_dir/include/vulkan/vulkan.h", ++ "../layers/generated/chassis.cpp", ++ "../layers/generated/chassis.h", ++ "../layers/generated/chassis_dispatch_helper.h", ++ "../layers/generated/layer_chassis_dispatch.cpp", ++ "../layers/generated/layer_chassis_dispatch.h", ++ "../layers/generated/vk_dispatch_table_helper.h", ++ "../layers/generated/vk_extension_helper.h", ++ "../layers/generated/vk_safe_struct.cpp", ++ "../layers/layer_options.cpp", ++ "../layers/layer_options.h", ++ "../layers/vk_layer_settings_ext.h", ++] ++ ++ ++ ++action("vulkan_gen_json_files") { ++ script = "../build-gn/generate_vulkan_layers_json.py" ++ ++ # Make sure that the cleanup of old layer JSON files happens before the new ones are generated. ++ deps = [ ++ "$vulkan_headers_dir:vulkan_headers", ++ ] ++ json_names = [ "VkLayer_khronos_validation.json" ] ++ sources = [ "$vulkan_headers_dir/include/vulkan/vulkan_core.h" ] ++ outputs = [] ++ foreach(json_name, json_names) { ++ sources += [ "../layers/json/$json_name.in" ] ++ outputs += [ "$vulkan_data_dir/$json_name" ] ++ } ++ _platform = "OpenHarmony" ++ ++ args = [ ++ "--platform", ++ _platform, ++ rebase_path("../layers/json", root_build_dir), ++ rebase_path(vulkan_data_dir, root_build_dir), ++ ] + rebase_path(sources, root_build_dir) ++ # The layer JSON files are part of the necessary data deps. ++ data = outputs ++} ++ ++config("vulkan_memory_allocator_config") { ++ if (is_clang) { ++ cflags_cc = [ "-Wno-nullability-completeness" ] ++ } ++} ++ ++source_set("vulkan_layer_utils") { ++ include_dirs = [ ++ "../layers", ++ "../layers/generated", ++ ] ++ sources = [ ++ "$vulkan_headers_dir/include/vulkan/vk_layer.h", ++ "$vulkan_headers_dir/include/vulkan/vk_sdk_platform.h", ++ "$vulkan_headers_dir/include/vulkan/vulkan.h", ++ "../layers/android_ndk_types.h", ++ "../layers/cast_utils.h", ++ "../layers/generated/vk_enum_string_helper.h", ++ "../layers/generated/vk_layer_dispatch_table.h", ++ "../layers/generated/vk_object_types.h", ++ "../layers/generated/vk_safe_struct.h", ++ "../layers/generated/vk_typemap_helper.h", ++ "../layers/generated/vk_validation_error_messages.h", ++ "../layers/generated/vk_format_utils.cpp", ++ "../layers/generated/vk_format_utils.h", ++ "../layers/hash_util.h", ++ "../layers/hash_vk_types.h", ++ "../layers/sparse_containers.h", ++ "../layers/vk_layer_config.cpp", ++ "../layers/vk_layer_config.h", ++ "../layers/vk_layer_data.h", ++ "../layers/vk_layer_extension_utils.cpp", ++ "../layers/vk_layer_extension_utils.h", ++ "../layers/vk_layer_logging.h", ++ "../layers/vk_layer_utils.cpp", ++ "../layers/vk_layer_utils.h", ++ "../layers/vk_mem_alloc.h", ++ "../layers/xxhash.c", ++ "../layers/xxhash.h", ++ ] ++ defines = [ "XXH_NO_LONG_LONG" ] ++ public_configs = [ ++ ":vulkan_internal_config", ++ ":vulkan_memory_allocator_config" ++ ] ++ public_deps = [ "$vulkan_headers_dir:vulkan_headers" ] ++ if (!is_ohos) { ++ configs -= [ "//build/config/compiler:chromium_code" ] ++ configs += [ "//build/config/compiler:no_chromium_code" ] ++ } ++} ++ ++config("vulkan_core_validation_config") { ++ include_dirs = [ ++ "$vvl_glslang_dir", ++ ] ++} ++ ++source_set("vulkan_core_validation_glslang") { ++ public_deps = [ ++ "${vvl_spirv_tools_dir}:spvtools", ++ "${vvl_spirv_tools_dir}:spvtools_opt", ++ "${vvl_spirv_tools_dir}:spvtools_val", ++ ] ++ public_configs = [ ++ "$vulkan_headers_dir:vulkan_headers_config", ++ ":vulkan_core_validation_config", ++ ] ++} ++ ++config("vulkan_stateless_validation_config") { ++ if (is_clang) { ++ cflags_cc = [ "-Wno-unused-const-variable" ] ++ } ++} ++ ++ohos_shared_library("VkLayer_khronos_validation") { ++ configs = [ ++ "//build/config/compiler:rtti", ++ ":generated_layers_config" ] ++ public_configs = [ ":vulkan_layer_config" ] ++ deps = [ ++ ":vulkan_layer_utils", ++ ":vulkan_core_validation_glslang", ++ ":vulkan_gen_json_files" ++ ] ++ sources = core_validation_sources + ++ object_lifetimes_sources + ++ stateless_validation_sources + ++ thread_safety_sources + ++ unique_objects_sources + ++ best_practices_sources + ++ debug_printf_sources + ++ chassis_sources ++ defines = [] ++ output_name = "VkLayer_khronos_validation" ++ output_extension = "so" ++ part_name = "graphic_standard" ++ subsystem_name = "graphic" ++} +diff --git a/build-openharmony/build_overrides/build.gni b/build-openharmony/build_overrides/build.gni +new file mode 100644 +index 000000000..b5b05ac15 +--- /dev/null ++++ b/build-openharmony/build_overrides/build.gni +@@ -0,0 +1,16 @@ ++ ++import("//build/ohos.gni") ++ ++ ++build_with_chromium = false ++ignore_elf32_limitations = true ++linux_use_bundled_binutils_override = false ++use_system_xcode = true ++ ++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" +\ No newline at end of file +diff --git a/build-openharmony/build_overrides/spirv_tools.gni b/build-openharmony/build_overrides/spirv_tools.gni +new file mode 100644 +index 000000000..a6457ce8f +--- /dev/null ++++ b/build-openharmony/build_overrides/spirv_tools.gni +@@ -0,0 +1,20 @@ ++# Copyright (c) 2019,2021 LunarG, Inc. ++# ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# https://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. ++ ++# We are building inside Vulkan-ValidationLayers ++spirv_tools_standalone = false ++ ++# Paths to SPIRV-Tools dependencies ++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/build-openharmony/build_overrides/vulkan_headers.gni b/build-openharmony/build_overrides/vulkan_headers.gni +new file mode 100644 +index 000000000..4e0f74bd2 +--- /dev/null ++++ b/build-openharmony/build_overrides/vulkan_headers.gni +@@ -0,0 +1,15 @@ ++# Copyright (c) 2020 LunarG, Inc. ++# ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# https://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. ++ ++vulkan_use_x11 = false +diff --git a/build-openharmony/build_overrides/vulkan_validation_layers.gni b/build-openharmony/build_overrides/vulkan_validation_layers.gni +new file mode 100644 +index 000000000..9a1be6c80 +--- /dev/null ++++ b/build-openharmony/build_overrides/vulkan_validation_layers.gni +@@ -0,0 +1,25 @@ ++# Copyright (c) 2019,2021 LunarG, Inc. ++# ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# https://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. ++ ++# Paths to validation layer dependencies ++vulkan_headers_dir = "//third_party//vulkan-headers" ++vvl_spirv_tools_dir = "../external/SPIRV-Tools" ++vvl_glslang_dir = "../external/glslang/" ++ ++# Subdirectories for generated files ++vulkan_data_subdir = "" ++vulkan_gen_subdir = "" ++ ++# Build options ++ozone_platform_x11 = false +diff --git a/layers/generated/best_practices.cpp b/layers/generated/best_practices.cpp +index cdb6f3515..bb58012ba 100644 +--- a/layers/generated/best_practices.cpp ++++ b/layers/generated/best_practices.cpp +@@ -3279,6 +3279,58 @@ void BestPractices::PostCallRecordGetFramebufferTilePropertiesQCOM( + } + } + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void BestPractices::PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) { ++ ValidationStateTracker::PostCallRecordCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface, result); ++ if (result != VK_SUCCESS) { ++ static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR}; ++ static const std::vector success_codes = {}; ++ ValidateReturnCodes("vkCreateOHOSSurfaceOpenHarmony", result, error_codes, success_codes); ++ } ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void BestPractices::PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, ++ VkResult result) { ++ ValidationStateTracker::PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties, result); ++ if (result != VK_SUCCESS) { ++ static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR}; ++ static const std::vector success_codes = {}; ++ ValidateReturnCodes("vkGetOHOSNativeBufferPropertiesOpenHarmony", result, error_codes, success_codes); ++ } ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void BestPractices::PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer, ++ VkResult result) { ++ ValidationStateTracker::PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer, result); ++ if (result != VK_SUCCESS) { ++ static const std::vector error_codes = {VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY}; ++ static const std::vector success_codes = {}; ++ ValidateReturnCodes("vkGetMemoryOHOSNativeBufferOpenHarmony", result, error_codes, success_codes); ++ } ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + void BestPractices::PostCallRecordCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/best_practices.h b/layers/generated/best_practices.h +index f934dd914..47b963f34 100644 +--- a/layers/generated/best_practices.h ++++ b/layers/generated/best_practices.h +@@ -1902,6 +1902,40 @@ void PostCallRecordGetFramebufferTilePropertiesQCOM( + VkResult result) override; + + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) override; ++ ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, ++ VkResult result) override; ++ ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer, ++ VkResult result) override; ++ ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + void PostCallRecordCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/chassis.cpp b/layers/generated/chassis.cpp +index 739e8cf62..094826193 100644 +--- a/layers/generated/chassis.cpp ++++ b/layers/generated/chassis.cpp +@@ -14085,6 +14085,82 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + + + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VKAPI_ATTR VkResult VKAPI_CALL CreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) { ++ auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); ++ bool skip = false; ++ for (auto intercept : layer_data->object_dispatch) { ++ auto lock = intercept->ReadLock(); ++ skip |= (const_cast(intercept))->PreCallValidateCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; ++ } ++ for (auto intercept : layer_data->object_dispatch) { ++ auto lock = intercept->WriteLock(); ++ intercept->PreCallRecordCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ } ++ VkResult result = DispatchCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ for (auto intercept : layer_data->object_dispatch) { ++ auto lock = intercept->WriteLock(); ++ intercept->PostCallRecordCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface, result); ++ } ++ return result; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VKAPI_ATTR VkResult VKAPI_CALL GetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) { ++ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); ++ bool skip = false; ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony]) { ++ auto lock = intercept->ReadLock(); ++ skip |= (const_cast(intercept))->PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; ++ } ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony]) { ++ auto lock = intercept->WriteLock(); ++ intercept->PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++ } ++ VkResult result = DispatchGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony]) { ++ auto lock = intercept->WriteLock(); ++ intercept->PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties, result); ++ } ++ return result; ++} ++ ++VKAPI_ATTR VkResult VKAPI_CALL GetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) { ++ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); ++ bool skip = false; ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetMemoryOHOSNativeBufferOpenHarmony]) { ++ auto lock = intercept->ReadLock(); ++ skip |= (const_cast(intercept))->PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; ++ } ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetMemoryOHOSNativeBufferOpenHarmony]) { ++ auto lock = intercept->WriteLock(); ++ intercept->PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++ } ++ VkResult result = DispatchGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++ for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetMemoryOHOSNativeBufferOpenHarmony]) { ++ auto lock = intercept->WriteLock(); ++ intercept->PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer, result); ++ } ++ return result; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, +@@ -15363,6 +15439,15 @@ const layer_data::unordered_map name_to_funcptr_map + {"vkCmdOpticalFlowExecuteNV", {kFuncTypeDev, (void*)CmdOpticalFlowExecuteNV}}, + {"vkGetFramebufferTilePropertiesQCOM", {kFuncTypeDev, (void*)GetFramebufferTilePropertiesQCOM}}, + {"vkGetDynamicRenderingTilePropertiesQCOM", {kFuncTypeDev, (void*)GetDynamicRenderingTilePropertiesQCOM}}, ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ {"vkCreateOHOSSurfaceOpenHarmony", {kFuncTypeInst, (void*)CreateOHOSSurfaceOpenHarmony}}, ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ {"vkGetOHOSNativeBufferPropertiesOpenHarmony", {kFuncTypeDev, (void*)GetOHOSNativeBufferPropertiesOpenHarmony}}, ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ {"vkGetMemoryOHOSNativeBufferOpenHarmony", {kFuncTypeDev, (void*)GetMemoryOHOSNativeBufferOpenHarmony}}, ++#endif + {"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}}, + {"vkDestroyAccelerationStructureKHR", {kFuncTypeDev, (void*)DestroyAccelerationStructureKHR}}, + {"vkCmdBuildAccelerationStructuresKHR", {kFuncTypeDev, (void*)CmdBuildAccelerationStructuresKHR}}, +diff --git a/layers/generated/chassis.h b/layers/generated/chassis.h +index 665b066ff..2283ed12f 100644 +--- a/layers/generated/chassis.h ++++ b/layers/generated/chassis.h +@@ -3584,6 +3584,28 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + + + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VKAPI_ATTR VkResult VKAPI_CALL CreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface); ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VKAPI_ATTR VkResult VKAPI_CALL GetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties); ++ ++VKAPI_ATTR VkResult VKAPI_CALL GetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer); ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, +@@ -5984,6 +6006,21 @@ class ValidationObject { + virtual bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const { return false; }; + virtual void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {}; + virtual void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) {}; ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ virtual bool PreCallValidateCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { return false; }; ++ virtual void PreCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {}; ++ virtual void PostCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {}; ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ virtual bool PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const { return false; }; ++ virtual void PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) {}; ++ virtual void PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, VkResult result) {}; ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ virtual bool PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) const { return false; }; ++ virtual void PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) {}; ++ virtual void PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) {}; ++#endif + virtual bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { return false; }; + virtual void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {}; + virtual void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) {}; +diff --git a/layers/generated/chassis_dispatch_helper.h b/layers/generated/chassis_dispatch_helper.h +index 9d01d8e9f..52b224106 100644 +--- a/layers/generated/chassis_dispatch_helper.h ++++ b/layers/generated/chassis_dispatch_helper.h +@@ -1421,6 +1421,12 @@ typedef enum InterceptId{ + InterceptIdPreCallValidateGetDynamicRenderingTilePropertiesQCOM, + InterceptIdPreCallRecordGetDynamicRenderingTilePropertiesQCOM, + InterceptIdPostCallRecordGetDynamicRenderingTilePropertiesQCOM, ++ InterceptIdPreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony, ++ InterceptIdPreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony, ++ InterceptIdPostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony, ++ InterceptIdPreCallValidateGetMemoryOHOSNativeBufferOpenHarmony, ++ InterceptIdPreCallRecordGetMemoryOHOSNativeBufferOpenHarmony, ++ InterceptIdPostCallRecordGetMemoryOHOSNativeBufferOpenHarmony, + InterceptIdPreCallValidateCreateAccelerationStructureKHR, + InterceptIdPreCallRecordCreateAccelerationStructureKHR, + InterceptIdPostCallRecordCreateAccelerationStructureKHR, +@@ -3068,6 +3074,18 @@ void ValidationObject::InitObjectDispatchVectors() { + BUILD_DISPATCH_VECTOR(PreCallValidateGetDynamicRenderingTilePropertiesQCOM); + BUILD_DISPATCH_VECTOR(PreCallRecordGetDynamicRenderingTilePropertiesQCOM); + BUILD_DISPATCH_VECTOR(PostCallRecordGetDynamicRenderingTilePropertiesQCOM); ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ BUILD_DISPATCH_VECTOR(PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony); ++ BUILD_DISPATCH_VECTOR(PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony); ++ BUILD_DISPATCH_VECTOR(PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony); ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony); ++ BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony); ++ BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony); ++#endif + BUILD_DISPATCH_VECTOR(PreCallValidateCreateAccelerationStructureKHR); + BUILD_DISPATCH_VECTOR(PreCallRecordCreateAccelerationStructureKHR); + BUILD_DISPATCH_VECTOR(PostCallRecordCreateAccelerationStructureKHR); +diff --git a/layers/generated/corechecks_optick_instrumentation.cpp b/layers/generated/corechecks_optick_instrumentation.cpp +index 47c63e91e..4f1f02cc7 100644 +--- a/layers/generated/corechecks_optick_instrumentation.cpp ++++ b/layers/generated/corechecks_optick_instrumentation.cpp +@@ -9360,6 +9360,60 @@ void CoreChecksOptickInstrumented::PostCallRecordGetDynamicRenderingTileProperti + CoreChecks::PostCallRecordGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties, result); + } + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool CoreChecksOptickInstrumented::PreCallValidateCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { ++ OPTICK_EVENT(); ++ auto result = CoreChecks::PreCallValidateCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ return result; ++} ++ ++void CoreChecksOptickInstrumented::PreCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { ++ OPTICK_EVENT(); ++ CoreChecks::PreCallRecordCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++} ++ ++void CoreChecksOptickInstrumented::PostCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) { ++ OPTICK_EVENT(); ++ CoreChecks::PostCallRecordCreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface, result); ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool CoreChecksOptickInstrumented::PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const { ++ OPTICK_EVENT(); ++ auto result = CoreChecks::PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++ return result; ++} ++ ++void CoreChecksOptickInstrumented::PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) { ++ OPTICK_EVENT(); ++ CoreChecks::PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++} ++ ++void CoreChecksOptickInstrumented::PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, VkResult result) { ++ OPTICK_EVENT(); ++ CoreChecks::PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties, result); ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool CoreChecksOptickInstrumented::PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) const { ++ OPTICK_EVENT(); ++ auto result = CoreChecks::PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++ return result; ++} ++ ++void CoreChecksOptickInstrumented::PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) { ++ OPTICK_EVENT(); ++ CoreChecks::PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++} ++ ++void CoreChecksOptickInstrumented::PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) { ++ OPTICK_EVENT(); ++ CoreChecks::PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer, result); ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + bool CoreChecksOptickInstrumented::PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); +diff --git a/layers/generated/corechecks_optick_instrumentation.h b/layers/generated/corechecks_optick_instrumentation.h +index 335f5d9aa..e1b7acc35 100644 +--- a/layers/generated/corechecks_optick_instrumentation.h ++++ b/layers/generated/corechecks_optick_instrumentation.h +@@ -1884,6 +1884,21 @@ class CoreChecksOptickInstrumented : public CoreChecks { + bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; + void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) override; + void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) override; ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ bool PreCallValidateCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const override; ++ void PreCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) override; ++ void PostCallRecordCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ bool PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const override; ++ void PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) override; ++ void PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ bool PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) const override; ++ void PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) override; ++ void PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const override; + void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) override; + void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) override; +diff --git a/layers/generated/layer_chassis_dispatch.cpp b/layers/generated/layer_chassis_dispatch.cpp +index d996b50df..82adc8c1c 100644 +--- a/layers/generated/layer_chassis_dispatch.cpp ++++ b/layers/generated/layer_chassis_dispatch.cpp +@@ -10904,6 +10904,64 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( + return result; + } + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VkResult DispatchCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* 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.CreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ VkResult result = layer_data->instance_dispatch_table.CreateOHOSSurfaceOpenHarmony(instance, pCreateInfo, pAllocator, pSurface); ++ if (VK_SUCCESS == result) { ++ *pSurface = layer_data->WrapNew(*pSurface); ++ } ++ return result; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VkResult DispatchGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) ++{ ++ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); ++ VkResult result = layer_data->device_dispatch_table.GetOHOSNativeBufferPropertiesOpenHarmony(device, buffer, pProperties); ++ ++ return result; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++VkResult DispatchGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* 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.GetMemoryOHOSNativeBufferOpenHarmony(device, pInfo, pBuffer); ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony var_local_pInfo; ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony *local_pInfo = NULL; ++ { ++ 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.GetMemoryOHOSNativeBufferOpenHarmony(device, (const VkMemoryGetOHOSNativeBufferInfoOpenHarmony*)local_pInfo, pBuffer); ++ ++ return result; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + VkResult DispatchCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/layer_chassis_dispatch.h b/layers/generated/layer_chassis_dispatch.h +index 9f49fa730..7828f9c99 100644 +--- a/layers/generated/layer_chassis_dispatch.h ++++ b/layers/generated/layer_chassis_dispatch.h +@@ -2702,6 +2702,25 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++VkResult DispatchCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface); ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++VkResult DispatchGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties); ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++VkResult DispatchGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer); ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + VkResult DispatchCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/object_tracker.cpp b/layers/generated/object_tracker.cpp +index 8583cd9ab..a11a6d5ba 100644 +--- a/layers/generated/object_tracker.cpp ++++ b/layers/generated/object_tracker.cpp +@@ -8057,6 +8057,60 @@ bool ObjectLifetimes::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( + return skip; + } + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++bool ObjectLifetimes::PreCallValidateCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) const { ++ bool skip = false; ++ skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateOHOSSurfaceOpenHarmony-instance-parameter", kVUIDUndefined); ++ ++ return skip; ++} ++ ++void ObjectLifetimes::PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) { ++ if (result != VK_SUCCESS) return; ++ CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); ++ ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++bool ObjectLifetimes::PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const { ++ bool skip = false; ++ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); ++ ++ return skip; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++bool ObjectLifetimes::PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) const { ++ bool skip = false; ++ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); ++ if (pInfo) { ++ skip |= ValidateObject(pInfo->memory, kVulkanObjectTypeDeviceMemory, false, kVUIDUndefined, kVUIDUndefined); ++ } ++ ++ return skip; ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/object_tracker.h b/layers/generated/object_tracker.h +index 285e07332..f9fb1a960 100644 +--- a/layers/generated/object_tracker.h ++++ b/layers/generated/object_tracker.h +@@ -3378,6 +3378,34 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) const override; ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) const override; ++void PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) const override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + bool PreCallValidateCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/parameter_validation.cpp b/layers/generated/parameter_validation.cpp +index e5d4586a7..5e651c7d7 100644 +--- a/layers/generated/parameter_validation.cpp ++++ b/layers/generated/parameter_validation.cpp +@@ -70,7 +70,7 @@ const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_B + const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FACE_FRONT_AND_BACK|VK_STENCIL_FRONT_AND_BACK; + const VkSubpassDescriptionFlags AllVkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX|VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX|VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM|VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT; + 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|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR; +-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_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR|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; ++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_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR|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_OHOS_NATIVE_BUFFER_BIT_OPENHARMONY; + 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_D3D11_FENCE_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA; + const VkFenceImportFlags AllVkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT|VK_FENCE_IMPORT_TEMPORARY_BIT_KHR; + const VkMemoryAllocateFlags AllVkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT|VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; +@@ -5372,6 +5372,22 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons + + // No Validation code for VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM structure members -- Covers VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType + ++ // No Validation code for VkOHOSNativeBufferUsageOpenHarmony structure members -- Covers VUID-VkOHOSNativeBufferUsageOpenHarmony-sType-sType ++ ++ // No Validation code for VkOHOSNativeBufferFormatPropertiesOpenHarmony structure members -- Covers VUID-VkOHOSNativeBufferFormatPropertiesOpenHarmony-sType-sType ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ // Validation code for VkImportOHOSNativeBufferInfoOpenHarmony structure members ++ case VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY: { // Covers VUID-VkImportOHOSNativeBufferInfoOpenHarmony-sType-sType ++ if (is_const_param) { ++ VkImportOHOSNativeBufferInfoOpenHarmony *structure = (VkImportOHOSNativeBufferInfoOpenHarmony *) header; ++ skip |= validate_required_pointer("VkImportOHOSNativeBufferInfoOpenHarmony", "buffer", structure->buffer, kVUIDUndefined); ++ } ++ } break; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ // No Validation code for VkExternalFormatOpenHarmony structure members -- Covers VUID-VkExternalFormatOpenHarmony-sType-sType ++ + // Validation code for VkWriteDescriptorSetAccelerationStructureKHR structure members + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { // Covers VUID-VkWriteDescriptorSetAccelerationStructureKHR-sType-sType + if (is_const_param) { +@@ -5886,9 +5902,9 @@ bool StatelessValidation::PreCallValidateAllocateMemory( + skip |= validate_struct_type("vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true, "VUID-vkAllocateMemory-pAllocateInfo-parameter", "VUID-VkMemoryAllocateInfo-sType-sType"); + if (pAllocateInfo != NULL) + { +- const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, 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_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; ++ const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, 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_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; + +- skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkImportOHOSNativeBufferInfoOpenHarmony, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); + } + if (pAllocator != NULL) + { +@@ -6689,9 +6705,9 @@ bool StatelessValidation::PreCallValidateCreateImage( + skip |= validate_struct_type("vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true, "VUID-vkCreateImage-pCreateInfo-parameter", "VUID-VkImageCreateInfo-sType-sType"); + if (pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -8933,9 +8949,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 + skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); + if (pImageFormatProperties != NULL) + { +- const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; ++ const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + +- skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); ++ skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkOHOSNativeBufferUsageOpenHarmony, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + } + if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + return skip; +@@ -9043,9 +9059,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversion( + skip |= validate_struct_type("vkCreateSamplerYcbcrConversion", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); + if (pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; ++ const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY }; + +- skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOpenHarmony", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + + skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversion", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); + +@@ -10618,9 +10634,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirements( + + if (pInfo->pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -10668,9 +10684,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirements( + + if (pInfo->pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -12133,9 +12149,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 + skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); + if (pImageFormatProperties != NULL) + { +- const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; ++ const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + +- skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); ++ skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkOHOSNativeBufferUsageOpenHarmony, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + } + if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + return skip; +@@ -13343,9 +13359,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversionKHR( + skip |= validate_struct_type("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); + if (pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; ++ const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY }; + +- skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOpenHarmony", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + + skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); + +@@ -14670,9 +14686,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirementsKHR( + + if (pInfo->pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -14722,9 +14738,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirementsK + + if (pInfo->pCreateInfo != NULL) + { +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -18333,9 +18349,9 @@ bool StatelessValidation::PreCallValidateSetBufferCollectionImageConstraintsFUCH + + skip |= validate_struct_type("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo", ParameterName::IndexVector{ formatConstraintsIndex }), "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", &(pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo), VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, false, kVUIDUndefined, "VUID-VkImageCreateInfo-sType-sType"); + +- const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; ++ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_OPENHARMONY, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + +- skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); ++ skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOpenHarmony, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + + skip |= validate_flags("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.flags", ParameterName::IndexVector{ formatConstraintsIndex }), "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); + +@@ -19819,6 +19835,95 @@ bool StatelessValidation::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( + + + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++bool StatelessValidation::PreCallValidateCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) const { ++ bool skip = false; ++ if (!instance_extensions.vk_khr_surface) skip |= OutputExtensionError("vkCreateOHOSSurfaceOpenHarmony", VK_KHR_SURFACE_EXTENSION_NAME); ++ if (!instance_extensions.vk_openharmony_ohos_surface) skip |= OutputExtensionError("vkCreateOHOSSurfaceOpenHarmony", VK_OPENHARMONY_OHOS_SURFACE_EXTENSION_NAME); ++ skip |= validate_struct_type("vkCreateOHOSSurfaceOpenHarmony", "pCreateInfo", "VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY", pCreateInfo, VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY, true, "VUID-vkCreateOHOSSurfaceOpenHarmony-pCreateInfo-parameter", "VUID-VkOHOSSurfaceCreateInfoOpenHarmony-sType-sType"); ++ if (pCreateInfo != NULL) ++ { ++ skip |= validate_struct_pnext("vkCreateOHOSSurfaceOpenHarmony", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkOHOSSurfaceCreateInfoOpenHarmony-pNext-pNext", kVUIDUndefined, false, true); ++ ++ skip |= validate_reserved_flags("vkCreateOHOSSurfaceOpenHarmony", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkOHOSSurfaceCreateInfoOpenHarmony-flags-zerobitmask"); ++ } ++ if (pAllocator != NULL) ++ { ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pAllocator->pfnAllocation", reinterpret_cast(pAllocator->pfnAllocation), "VUID-VkAllocationCallbacks-pfnAllocation-00632"); ++ ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pAllocator->pfnReallocation", reinterpret_cast(pAllocator->pfnReallocation), "VUID-VkAllocationCallbacks-pfnReallocation-00633"); ++ ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pAllocator->pfnFree", reinterpret_cast(pAllocator->pfnFree), "VUID-VkAllocationCallbacks-pfnFree-00634"); ++ ++ if (pAllocator->pfnInternalAllocation != NULL) ++ { ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pAllocator->pfnInternalFree", reinterpret_cast(pAllocator->pfnInternalFree), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); ++ ++ } ++ ++ if (pAllocator->pfnInternalFree != NULL) ++ { ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pAllocator->pfnInternalAllocation", reinterpret_cast(pAllocator->pfnInternalAllocation), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); ++ ++ } ++ } ++ skip |= validate_required_pointer("vkCreateOHOSSurfaceOpenHarmony", "pSurface", pSurface, "VUID-vkCreateOHOSSurfaceOpenHarmony-pSurface-parameter"); ++ return skip; ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++bool StatelessValidation::PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const { ++ bool skip = false; ++ if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetOHOSNativeBufferPropertiesOpenHarmony", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetOHOSNativeBufferPropertiesOpenHarmony", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetOHOSNativeBufferPropertiesOpenHarmony", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetOHOSNativeBufferPropertiesOpenHarmony", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_openharmony_external_memory_ohos_native_buffer)) skip |= OutputExtensionError("vkGetOHOSNativeBufferPropertiesOpenHarmony", VK_OPENHARMONY_EXTERNAL_MEMORY_OHOS_NATIVE_BUFFER_EXTENSION_NAME); ++ skip |= validate_required_pointer("vkGetOHOSNativeBufferPropertiesOpenHarmony", "buffer", buffer, kVUIDUndefined); ++ skip |= validate_struct_type("vkGetOHOSNativeBufferPropertiesOpenHarmony", "pProperties", "VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY", pProperties, VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY, true, kVUIDUndefined, kVUIDUndefined); ++ if (pProperties != NULL) ++ { ++ const VkStructureType allowed_structs_VkOHOSNativeBufferPropertiesOpenHarmony[] = { VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY }; ++ ++ skip |= validate_struct_pnext("vkGetOHOSNativeBufferPropertiesOpenHarmony", "pProperties->pNext", "VkOHOSNativeBufferFormatPropertiesOpenHarmony", pProperties->pNext, ARRAY_SIZE(allowed_structs_VkOHOSNativeBufferPropertiesOpenHarmony), allowed_structs_VkOHOSNativeBufferPropertiesOpenHarmony, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, false); ++ } ++ return skip; ++} ++ ++bool StatelessValidation::PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) const { ++ bool skip = false; ++ if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetMemoryOHOSNativeBufferOpenHarmony", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetMemoryOHOSNativeBufferOpenHarmony", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetMemoryOHOSNativeBufferOpenHarmony", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetMemoryOHOSNativeBufferOpenHarmony", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); ++ if (!IsExtEnabled(device_extensions.vk_openharmony_external_memory_ohos_native_buffer)) skip |= OutputExtensionError("vkGetMemoryOHOSNativeBufferOpenHarmony", VK_OPENHARMONY_EXTERNAL_MEMORY_OHOS_NATIVE_BUFFER_EXTENSION_NAME); ++ skip |= validate_struct_type("vkGetMemoryOHOSNativeBufferOpenHarmony", "pInfo", "VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY", pInfo, VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY, true, kVUIDUndefined, kVUIDUndefined); ++ if (pInfo != NULL) ++ { ++ skip |= validate_struct_pnext("vkGetMemoryOHOSNativeBufferOpenHarmony", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, true); ++ ++ skip |= validate_required_handle("vkGetMemoryOHOSNativeBufferOpenHarmony", "pInfo->memory", pInfo->memory); ++ } ++ skip |= validate_required_pointer("vkGetMemoryOHOSNativeBufferOpenHarmony", "pBuffer", pBuffer, kVUIDUndefined); ++ return skip; ++} ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + bool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/parameter_validation.h b/layers/generated/parameter_validation.h +index 5635e4545..a3f2c333a 100644 +--- a/layers/generated/parameter_validation.h ++++ b/layers/generated/parameter_validation.h +@@ -2666,6 +2666,25 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) const override; ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) const override; ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) const override; ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++bool PreCallValidateGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) const override; ++#endif + bool PreCallValidateCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/thread_safety.cpp b/layers/generated/thread_safety.cpp +index 1fa91da82..95a9e4655 100644 +--- a/layers/generated/thread_safety.cpp ++++ b/layers/generated/thread_safety.cpp +@@ -9808,6 +9808,62 @@ void ThreadSafety::PostCallRecordGetDynamicRenderingTilePropertiesQCOM( + FinishReadObjectParentInstance(device, "vkGetDynamicRenderingTilePropertiesQCOM"); + } + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void ThreadSafety::PreCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) { ++ StartReadObjectParentInstance(instance, "vkCreateOHOSSurfaceOpenHarmony"); ++} ++ ++void ThreadSafety::PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) { ++ FinishReadObjectParentInstance(instance, "vkCreateOHOSSurfaceOpenHarmony"); ++ if (result == VK_SUCCESS) { ++ CreateObjectParentInstance(*pSurface); ++ } ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void ThreadSafety::PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) { ++ StartReadObjectParentInstance(device, "vkGetOHOSNativeBufferPropertiesOpenHarmony"); ++} ++ ++void ThreadSafety::PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, ++ VkResult result) { ++ FinishReadObjectParentInstance(device, "vkGetOHOSNativeBufferPropertiesOpenHarmony"); ++} ++ ++void ThreadSafety::PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) { ++ StartReadObjectParentInstance(device, "vkGetMemoryOHOSNativeBufferOpenHarmony"); ++} ++ ++void ThreadSafety::PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer, ++ VkResult result) { ++ FinishReadObjectParentInstance(device, "vkGetMemoryOHOSNativeBufferOpenHarmony"); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + void ThreadSafety::PreCallRecordCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/thread_safety.h b/layers/generated/thread_safety.h +index 95516a29f..aeb47b373 100644 +--- a/layers/generated/thread_safety.h ++++ b/layers/generated/thread_safety.h +@@ -6518,6 +6518,47 @@ void PostCallRecordGetDynamicRenderingTilePropertiesQCOM( + VkTilePropertiesQCOM* pProperties, + VkResult result) override; + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void PreCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface) override; ++ ++void PostCallRecordCreateOHOSSurfaceOpenHarmony( ++ VkInstance instance, ++ const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, ++ const VkAllocationCallbacks* pAllocator, ++ VkSurfaceKHR* pSurface, ++ VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++void PreCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) override; ++ ++void PostCallRecordGetOHOSNativeBufferPropertiesOpenHarmony( ++ VkDevice device, ++ const struct OH_NativeBuffer* buffer, ++ VkOHOSNativeBufferPropertiesOpenHarmony* pProperties, ++ VkResult result) override; ++ ++void PreCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer) override; ++ ++void PostCallRecordGetMemoryOHOSNativeBufferOpenHarmony( ++ VkDevice device, ++ const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, ++ struct OH_NativeBuffer** pBuffer, ++ VkResult result) override; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + void PreCallRecordCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, +diff --git a/layers/generated/vk_dispatch_table_helper.h b/layers/generated/vk_dispatch_table_helper.h +index 1346f4ec2..6b4e2d3a3 100644 +--- a/layers/generated/vk_dispatch_table_helper.h ++++ b/layers/generated/vk_dispatch_table_helper.h +@@ -595,6 +595,15 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubBindOpticalFlowSessionImageNV(VkDevice + static VKAPI_ATTR void VKAPI_CALL StubCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { }; + static VKAPI_ATTR VkResult VKAPI_CALL StubGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; + static VKAPI_ATTR VkResult VKAPI_CALL StubGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++static VKAPI_ATTR VkResult VKAPI_CALL StubCreateOHOSSurfaceOpenHarmony(VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return VK_SUCCESS; }; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++static VKAPI_ATTR VkResult VKAPI_CALL StubGetOHOSNativeBufferPropertiesOpenHarmony(VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties) { return VK_SUCCESS; }; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryOHOSNativeBufferOpenHarmony(VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer) { return VK_SUCCESS; }; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; }; + static VKAPI_ATTR void VKAPI_CALL StubDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { }; + static VKAPI_ATTR void VKAPI_CALL StubCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { }; +@@ -926,6 +935,7 @@ const layer_data::unordered_map api_extension_map { + {"vkGetMemoryFdKHR", "VK_KHR_external_memory_fd"}, + {"vkGetMemoryFdPropertiesKHR", "VK_KHR_external_memory_fd"}, + {"vkGetMemoryHostPointerPropertiesEXT", "VK_EXT_external_memory_host"}, ++ {"vkGetMemoryOHOSNativeBufferOpenHarmony", "VK_OpenHarmony_external_memory_OHOS_native_buffer"}, + {"vkGetMemoryRemoteAddressNV", "VK_NV_external_memory_rdma"}, + {"vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32"}, + {"vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32"}, +@@ -933,6 +943,7 @@ const layer_data::unordered_map api_extension_map { + {"vkGetMemoryZirconHandleFUCHSIA", "VK_FUCHSIA_external_memory"}, + {"vkGetMemoryZirconHandlePropertiesFUCHSIA", "VK_FUCHSIA_external_memory"}, + {"vkGetMicromapBuildSizesEXT", "VK_EXT_opacity_micromap"}, ++ {"vkGetOHOSNativeBufferPropertiesOpenHarmony", "VK_OpenHarmony_external_memory_OHOS_native_buffer"}, + {"vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing"}, + {"vkGetPerformanceParameterINTEL", "VK_INTEL_performance_query"}, + {"vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties"}, +@@ -1927,6 +1938,14 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp + if (table->GetFramebufferTilePropertiesQCOM == nullptr) { table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)StubGetFramebufferTilePropertiesQCOM; } + table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM) gpa(device, "vkGetDynamicRenderingTilePropertiesQCOM"); + if (table->GetDynamicRenderingTilePropertiesQCOM == nullptr) { table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)StubGetDynamicRenderingTilePropertiesQCOM; } ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ table->GetOHOSNativeBufferPropertiesOpenHarmony = (PFN_vkGetOHOSNativeBufferPropertiesOpenHarmony) gpa(device, "vkGetOHOSNativeBufferPropertiesOpenHarmony"); ++ if (table->GetOHOSNativeBufferPropertiesOpenHarmony == nullptr) { table->GetOHOSNativeBufferPropertiesOpenHarmony = (PFN_vkGetOHOSNativeBufferPropertiesOpenHarmony)StubGetOHOSNativeBufferPropertiesOpenHarmony; } ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ table->GetMemoryOHOSNativeBufferOpenHarmony = (PFN_vkGetMemoryOHOSNativeBufferOpenHarmony) gpa(device, "vkGetMemoryOHOSNativeBufferOpenHarmony"); ++ if (table->GetMemoryOHOSNativeBufferOpenHarmony == nullptr) { table->GetMemoryOHOSNativeBufferOpenHarmony = (PFN_vkGetMemoryOHOSNativeBufferOpenHarmony)StubGetMemoryOHOSNativeBufferOpenHarmony; } ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR) gpa(device, "vkCreateAccelerationStructureKHR"); + if (table->CreateAccelerationStructureKHR == nullptr) { table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)StubCreateAccelerationStructureKHR; } + table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR) gpa(device, "vkDestroyAccelerationStructureKHR"); +@@ -2226,4 +2245,8 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay + #endif // VK_USE_PLATFORM_SCREEN_QNX + table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV) gpa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); + if (table->GetPhysicalDeviceOpticalFlowImageFormatsNV == nullptr) { table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)StubGetPhysicalDeviceOpticalFlowImageFormatsNV; } ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ table->CreateOHOSSurfaceOpenHarmony = (PFN_vkCreateOHOSSurfaceOpenHarmony) gpa(instance, "vkCreateOHOSSurfaceOpenHarmony"); ++ if (table->CreateOHOSSurfaceOpenHarmony == nullptr) { table->CreateOHOSSurfaceOpenHarmony = (PFN_vkCreateOHOSSurfaceOpenHarmony)StubCreateOHOSSurfaceOpenHarmony; } ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + } +diff --git a/layers/generated/vk_enum_string_helper.h b/layers/generated/vk_enum_string_helper.h +index 005cc21ea..68f1c2669 100644 +--- a/layers/generated/vk_enum_string_helper.h ++++ b/layers/generated/vk_enum_string_helper.h +@@ -493,6 +493,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) + return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; ++ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY"; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: +@@ -631,6 +633,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) + return "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT"; + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + return "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT"; ++ case VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY"; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: + return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: +@@ -673,6 +677,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) + return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: + return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"; ++ case VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY"; + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: + return "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"; + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: +@@ -709,6 +715,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) + return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT"; ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY"; ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY"; ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY"; ++ case VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY: ++ return "VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY"; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: + return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV"; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: +@@ -5274,6 +5288,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMe + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; ++ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OPENHARMONY: ++ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OPENHARMONY"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: +@@ -6853,6 +6869,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExterna + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; ++ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OPENHARMONY: ++ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OPENHARMONY"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: +diff --git a/layers/generated/vk_extension_helper.h b/layers/generated/vk_extension_helper.h +index c34c7e9ca..ad7797700 100644 +--- a/layers/generated/vk_extension_helper.h ++++ b/layers/generated/vk_extension_helper.h +@@ -105,6 +105,7 @@ struct InstanceExtensions { + ExtEnabled vk_mvk_macos_surface{kNotEnabled}; + ExtEnabled vk_nn_vi_surface{kNotEnabled}; + ExtEnabled vk_nv_external_memory_capabilities{kNotEnabled}; ++ ExtEnabled vk_openharmony_ohos_surface{kNotEnabled}; + ExtEnabled vk_qnx_screen_surface{kNotEnabled}; + + struct InstanceReq { +@@ -212,6 +213,10 @@ struct InstanceExtensions { + {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, + #endif + {VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_nv_external_memory_capabilities, {})}, ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ {VK_OPENHARMONY_OHOS_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_openharmony_ohos_surface, {{ ++ {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, ++#endif + #ifdef VK_USE_PLATFORM_SCREEN_QNX + {VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_qnx_screen_surface, {{ + {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, +@@ -359,6 +364,9 @@ static const std::set kInstanceExtensionNames = { + VK_NN_VI_SURFACE_EXTENSION_NAME, + #endif + VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ VK_OPENHARMONY_OHOS_SURFACE_EXTENSION_NAME, ++#endif + #ifdef VK_USE_PLATFORM_SCREEN_QNX + VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, + #endif +@@ -628,6 +636,7 @@ struct DeviceExtensions : public InstanceExtensions { + ExtEnabled vk_nv_viewport_array2{kNotEnabled}; + ExtEnabled vk_nv_viewport_swizzle{kNotEnabled}; + ExtEnabled vk_nv_win32_keyed_mutex{kNotEnabled}; ++ ExtEnabled vk_openharmony_external_memory_ohos_native_buffer{kNotEnabled}; + ExtEnabled vk_qcom_fragment_density_map_offset{kNotEnabled}; + ExtEnabled vk_qcom_image_processing{kNotEnabled}; + ExtEnabled vk_qcom_render_pass_shader_resolve{kNotEnabled}; +@@ -1200,6 +1209,13 @@ struct DeviceExtensions : public InstanceExtensions { + #ifdef VK_USE_PLATFORM_WIN32_KHR + {VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_nv_win32_keyed_mutex, {{ + {&DeviceExtensions::vk_nv_external_memory_win32, VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME}}})}, ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ {VK_OPENHARMONY_EXTERNAL_MEMORY_OHOS_NATIVE_BUFFER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_openharmony_external_memory_ohos_native_buffer, {{ ++ {&DeviceExtensions::vk_khr_sampler_ycbcr_conversion, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME}, ++ {&DeviceExtensions::vk_khr_external_memory, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME}, ++ {&DeviceExtensions::vk_ext_queue_family_foreign, VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME}, ++ {&DeviceExtensions::vk_khr_dedicated_allocation, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME}}})}, + #endif + {VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_qcom_fragment_density_map_offset, {{ + {&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}, +@@ -1661,6 +1677,9 @@ static const std::set kDeviceExtensionNames = { + VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, + #ifdef VK_USE_PLATFORM_WIN32_KHR + VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, ++#endif ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ VK_OPENHARMONY_EXTERNAL_MEMORY_OHOS_NATIVE_BUFFER_EXTENSION_NAME, + #endif + VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, + VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME, +diff --git a/layers/generated/vk_layer_dispatch_table.h b/layers/generated/vk_layer_dispatch_table.h +index 1a08f28f3..187e86d80 100644 +--- a/layers/generated/vk_layer_dispatch_table.h ++++ b/layers/generated/vk_layer_dispatch_table.h +@@ -278,6 +278,11 @@ typedef struct VkLayerInstanceDispatchTable_ { + + // ---- VK_NV_optical_flow extension commands + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; ++ ++ // ---- VK_OpenHarmony_OHOS_surface extension commands ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ PFN_vkCreateOHOSSurfaceOpenHarmony CreateOHOSSurfaceOpenHarmony; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + } VkLayerInstanceDispatchTable; + + // Device function pointer dispatch table +@@ -1017,6 +1022,14 @@ typedef struct VkLayerDispatchTable_ { + PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM; + PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM; + ++ // ---- VK_OpenHarmony_external_memory_OHOS_native_buffer extension commands ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ PFN_vkGetOHOSNativeBufferPropertiesOpenHarmony GetOHOSNativeBufferPropertiesOpenHarmony; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ PFN_vkGetMemoryOHOSNativeBufferOpenHarmony GetMemoryOHOSNativeBufferOpenHarmony; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + // ---- VK_KHR_acceleration_structure extension commands + PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; + PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; +diff --git a/layers/generated/vk_safe_struct.cpp b/layers/generated/vk_safe_struct.cpp +index f9c45bde7..d89304886 100644 +--- a/layers/generated/vk_safe_struct.cpp ++++ b/layers/generated/vk_safe_struct.cpp +@@ -57412,6 +57412,480 @@ void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(const safe + shaderWarpsPerCore = copy_src->shaderWarpsPerCore; + pNext = SafePnextCopy(copy_src->pNext); + } ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkOHOSSurfaceCreateInfoOpenHarmony::safe_VkOHOSSurfaceCreateInfoOpenHarmony(const VkOHOSSurfaceCreateInfoOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ flags(in_struct->flags), ++ window(in_struct->window) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkOHOSSurfaceCreateInfoOpenHarmony::safe_VkOHOSSurfaceCreateInfoOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY), ++ pNext(nullptr), ++ flags(), ++ window(nullptr) ++{} ++ ++safe_VkOHOSSurfaceCreateInfoOpenHarmony::safe_VkOHOSSurfaceCreateInfoOpenHarmony(const safe_VkOHOSSurfaceCreateInfoOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ flags = copy_src.flags; ++ window = copy_src.window; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkOHOSSurfaceCreateInfoOpenHarmony& safe_VkOHOSSurfaceCreateInfoOpenHarmony::operator=(const safe_VkOHOSSurfaceCreateInfoOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ flags = copy_src.flags; ++ window = copy_src.window; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkOHOSSurfaceCreateInfoOpenHarmony::~safe_VkOHOSSurfaceCreateInfoOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkOHOSSurfaceCreateInfoOpenHarmony::initialize(const VkOHOSSurfaceCreateInfoOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ flags = in_struct->flags; ++ window = in_struct->window; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkOHOSSurfaceCreateInfoOpenHarmony::initialize(const safe_VkOHOSSurfaceCreateInfoOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ flags = copy_src->flags; ++ window = copy_src->window; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkOHOSNativeBufferUsageOpenHarmony::safe_VkOHOSNativeBufferUsageOpenHarmony(const VkOHOSNativeBufferUsageOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ OHOSNativeBufferUsage(in_struct->OHOSNativeBufferUsage) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkOHOSNativeBufferUsageOpenHarmony::safe_VkOHOSNativeBufferUsageOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY), ++ pNext(nullptr), ++ OHOSNativeBufferUsage() ++{} ++ ++safe_VkOHOSNativeBufferUsageOpenHarmony::safe_VkOHOSNativeBufferUsageOpenHarmony(const safe_VkOHOSNativeBufferUsageOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkOHOSNativeBufferUsageOpenHarmony& safe_VkOHOSNativeBufferUsageOpenHarmony::operator=(const safe_VkOHOSNativeBufferUsageOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkOHOSNativeBufferUsageOpenHarmony::~safe_VkOHOSNativeBufferUsageOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkOHOSNativeBufferUsageOpenHarmony::initialize(const VkOHOSNativeBufferUsageOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ OHOSNativeBufferUsage = in_struct->OHOSNativeBufferUsage; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkOHOSNativeBufferUsageOpenHarmony::initialize(const safe_VkOHOSNativeBufferUsageOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ OHOSNativeBufferUsage = copy_src->OHOSNativeBufferUsage; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkOHOSNativeBufferPropertiesOpenHarmony::safe_VkOHOSNativeBufferPropertiesOpenHarmony(const VkOHOSNativeBufferPropertiesOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ allocationSize(in_struct->allocationSize), ++ memoryTypeBits(in_struct->memoryTypeBits) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkOHOSNativeBufferPropertiesOpenHarmony::safe_VkOHOSNativeBufferPropertiesOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY), ++ pNext(nullptr), ++ allocationSize(), ++ memoryTypeBits() ++{} ++ ++safe_VkOHOSNativeBufferPropertiesOpenHarmony::safe_VkOHOSNativeBufferPropertiesOpenHarmony(const safe_VkOHOSNativeBufferPropertiesOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ allocationSize = copy_src.allocationSize; ++ memoryTypeBits = copy_src.memoryTypeBits; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkOHOSNativeBufferPropertiesOpenHarmony& safe_VkOHOSNativeBufferPropertiesOpenHarmony::operator=(const safe_VkOHOSNativeBufferPropertiesOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ allocationSize = copy_src.allocationSize; ++ memoryTypeBits = copy_src.memoryTypeBits; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkOHOSNativeBufferPropertiesOpenHarmony::~safe_VkOHOSNativeBufferPropertiesOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkOHOSNativeBufferPropertiesOpenHarmony::initialize(const VkOHOSNativeBufferPropertiesOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ allocationSize = in_struct->allocationSize; ++ memoryTypeBits = in_struct->memoryTypeBits; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkOHOSNativeBufferPropertiesOpenHarmony::initialize(const safe_VkOHOSNativeBufferPropertiesOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ allocationSize = copy_src->allocationSize; ++ memoryTypeBits = copy_src->memoryTypeBits; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(const VkOHOSNativeBufferFormatPropertiesOpenHarmony* in_struct) : ++ 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); ++} ++ ++safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY), ++ pNext(nullptr), ++ format(), ++ externalFormat(), ++ formatFeatures(), ++ samplerYcbcrConversionComponents(), ++ suggestedYcbcrModel(), ++ suggestedYcbcrRange(), ++ suggestedXChromaOffset(), ++ suggestedYChromaOffset() ++{} ++ ++safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony& 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_VkOHOSNativeBufferFormatPropertiesOpenHarmony& safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::operator=(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ 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_VkOHOSNativeBufferFormatPropertiesOpenHarmony::~safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::initialize(const VkOHOSNativeBufferFormatPropertiesOpenHarmony* in_struct) ++{ ++ if (pNext) ++ 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); ++} ++ ++void safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony::initialize(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony* 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); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkImportOHOSNativeBufferInfoOpenHarmony::safe_VkImportOHOSNativeBufferInfoOpenHarmony(const VkImportOHOSNativeBufferInfoOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ buffer(in_struct->buffer) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkImportOHOSNativeBufferInfoOpenHarmony::safe_VkImportOHOSNativeBufferInfoOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY), ++ pNext(nullptr), ++ buffer(nullptr) ++{} ++ ++safe_VkImportOHOSNativeBufferInfoOpenHarmony::safe_VkImportOHOSNativeBufferInfoOpenHarmony(const safe_VkImportOHOSNativeBufferInfoOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ buffer = copy_src.buffer; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkImportOHOSNativeBufferInfoOpenHarmony& safe_VkImportOHOSNativeBufferInfoOpenHarmony::operator=(const safe_VkImportOHOSNativeBufferInfoOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ buffer = copy_src.buffer; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkImportOHOSNativeBufferInfoOpenHarmony::~safe_VkImportOHOSNativeBufferInfoOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkImportOHOSNativeBufferInfoOpenHarmony::initialize(const VkImportOHOSNativeBufferInfoOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ buffer = in_struct->buffer; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkImportOHOSNativeBufferInfoOpenHarmony::initialize(const safe_VkImportOHOSNativeBufferInfoOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ buffer = copy_src->buffer; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ memory(in_struct->memory) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY), ++ pNext(nullptr), ++ memory() ++{} ++ ++safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ memory = copy_src.memory; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::operator=(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ memory = copy_src.memory; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::~safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::initialize(const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ memory = in_struct->memory; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony::initialize(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ memory = copy_src->memory; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++ ++safe_VkExternalFormatOpenHarmony::safe_VkExternalFormatOpenHarmony(const VkExternalFormatOpenHarmony* in_struct) : ++ sType(in_struct->sType), ++ externalFormat(in_struct->externalFormat) ++{ ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++safe_VkExternalFormatOpenHarmony::safe_VkExternalFormatOpenHarmony() : ++ sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY), ++ pNext(nullptr), ++ externalFormat() ++{} ++ ++safe_VkExternalFormatOpenHarmony::safe_VkExternalFormatOpenHarmony(const safe_VkExternalFormatOpenHarmony& copy_src) ++{ ++ sType = copy_src.sType; ++ externalFormat = copy_src.externalFormat; ++ pNext = SafePnextCopy(copy_src.pNext); ++} ++ ++safe_VkExternalFormatOpenHarmony& safe_VkExternalFormatOpenHarmony::operator=(const safe_VkExternalFormatOpenHarmony& copy_src) ++{ ++ if (©_src == this) return *this; ++ ++ if (pNext) ++ FreePnextChain(pNext); ++ ++ sType = copy_src.sType; ++ externalFormat = copy_src.externalFormat; ++ pNext = SafePnextCopy(copy_src.pNext); ++ ++ return *this; ++} ++ ++safe_VkExternalFormatOpenHarmony::~safe_VkExternalFormatOpenHarmony() ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++} ++ ++void safe_VkExternalFormatOpenHarmony::initialize(const VkExternalFormatOpenHarmony* in_struct) ++{ ++ if (pNext) ++ FreePnextChain(pNext); ++ sType = in_struct->sType; ++ externalFormat = in_struct->externalFormat; ++ pNext = SafePnextCopy(in_struct->pNext); ++} ++ ++void safe_VkExternalFormatOpenHarmony::initialize(const safe_VkExternalFormatOpenHarmony* copy_src) ++{ ++ sType = copy_src->sType; ++ externalFormat = copy_src->externalFormat; ++ pNext = SafePnextCopy(copy_src->pNext); ++} ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + + safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct) : + sType(in_struct->sType), +@@ -61064,6 +61538,20 @@ void *SafePnextCopy(const void *pNext) { + safe_pNext = new safe_VkImportMetalSharedEventInfoEXT(reinterpret_cast(pNext)); + break; + #endif // VK_USE_PLATFORM_METAL_EXT ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY: ++ safe_pNext = new safe_VkOHOSNativeBufferUsageOpenHarmony(reinterpret_cast(pNext)); ++ break; ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY: ++ safe_pNext = new safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(reinterpret_cast(pNext)); ++ break; ++ case VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY: ++ safe_pNext = new safe_VkImportOHOSNativeBufferInfoOpenHarmony(reinterpret_cast(pNext)); ++ break; ++ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY: ++ safe_pNext = new safe_VkExternalFormatOpenHarmony(reinterpret_cast(pNext)); ++ break; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + #ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast(pNext)); +@@ -62434,6 +62922,20 @@ void FreePnextChain(const void *pNext) { + delete reinterpret_cast(header); + break; + #endif // VK_USE_PLATFORM_METAL_EXT ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY: ++ delete reinterpret_cast(header); ++ break; ++ case VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY: ++ delete reinterpret_cast(header); ++ break; ++ case VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY: ++ delete reinterpret_cast(header); ++ break; ++ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY: ++ delete reinterpret_cast(header); ++ break; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + #ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + delete reinterpret_cast(header); +diff --git a/layers/generated/vk_safe_struct.h b/layers/generated/vk_safe_struct.h +index 5410b4bb1..0780b8a0c 100644 +--- a/layers/generated/vk_safe_struct.h ++++ b/layers/generated/vk_safe_struct.h +@@ -12564,6 +12564,134 @@ struct safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const *ptr() const { return reinterpret_cast(this); } + }; + ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkOHOSSurfaceCreateInfoOpenHarmony { ++ VkStructureType sType; ++ const void* pNext{}; ++ VkOHOSSurfaceCreateFlagsOpenHarmony flags; ++ OHNativeWindow* window{}; ++ safe_VkOHOSSurfaceCreateInfoOpenHarmony(const VkOHOSSurfaceCreateInfoOpenHarmony* in_struct); ++ safe_VkOHOSSurfaceCreateInfoOpenHarmony(const safe_VkOHOSSurfaceCreateInfoOpenHarmony& copy_src); ++ safe_VkOHOSSurfaceCreateInfoOpenHarmony& operator=(const safe_VkOHOSSurfaceCreateInfoOpenHarmony& copy_src); ++ safe_VkOHOSSurfaceCreateInfoOpenHarmony(); ++ ~safe_VkOHOSSurfaceCreateInfoOpenHarmony(); ++ void initialize(const VkOHOSSurfaceCreateInfoOpenHarmony* in_struct); ++ void initialize(const safe_VkOHOSSurfaceCreateInfoOpenHarmony* copy_src); ++ VkOHOSSurfaceCreateInfoOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkOHOSSurfaceCreateInfoOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkOHOSNativeBufferUsageOpenHarmony { ++ VkStructureType sType; ++ void* pNext{}; ++ uint64_t OHOSNativeBufferUsage; ++ safe_VkOHOSNativeBufferUsageOpenHarmony(const VkOHOSNativeBufferUsageOpenHarmony* in_struct); ++ safe_VkOHOSNativeBufferUsageOpenHarmony(const safe_VkOHOSNativeBufferUsageOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferUsageOpenHarmony& operator=(const safe_VkOHOSNativeBufferUsageOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferUsageOpenHarmony(); ++ ~safe_VkOHOSNativeBufferUsageOpenHarmony(); ++ void initialize(const VkOHOSNativeBufferUsageOpenHarmony* in_struct); ++ void initialize(const safe_VkOHOSNativeBufferUsageOpenHarmony* copy_src); ++ VkOHOSNativeBufferUsageOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkOHOSNativeBufferUsageOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkOHOSNativeBufferPropertiesOpenHarmony { ++ VkStructureType sType; ++ void* pNext{}; ++ VkDeviceSize allocationSize; ++ uint32_t memoryTypeBits; ++ safe_VkOHOSNativeBufferPropertiesOpenHarmony(const VkOHOSNativeBufferPropertiesOpenHarmony* in_struct); ++ safe_VkOHOSNativeBufferPropertiesOpenHarmony(const safe_VkOHOSNativeBufferPropertiesOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferPropertiesOpenHarmony& operator=(const safe_VkOHOSNativeBufferPropertiesOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferPropertiesOpenHarmony(); ++ ~safe_VkOHOSNativeBufferPropertiesOpenHarmony(); ++ void initialize(const VkOHOSNativeBufferPropertiesOpenHarmony* in_struct); ++ void initialize(const safe_VkOHOSNativeBufferPropertiesOpenHarmony* copy_src); ++ VkOHOSNativeBufferPropertiesOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkOHOSNativeBufferPropertiesOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony { ++ VkStructureType sType; ++ void* pNext{}; ++ VkFormat format; ++ uint64_t externalFormat; ++ VkFormatFeatureFlags formatFeatures; ++ VkComponentMapping samplerYcbcrConversionComponents; ++ VkSamplerYcbcrModelConversion suggestedYcbcrModel; ++ VkSamplerYcbcrRange suggestedYcbcrRange; ++ VkChromaLocation suggestedXChromaOffset; ++ VkChromaLocation suggestedYChromaOffset; ++ safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(const VkOHOSNativeBufferFormatPropertiesOpenHarmony* in_struct); ++ safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony& operator=(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony& copy_src); ++ safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(); ++ ~safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony(); ++ void initialize(const VkOHOSNativeBufferFormatPropertiesOpenHarmony* in_struct); ++ void initialize(const safe_VkOHOSNativeBufferFormatPropertiesOpenHarmony* copy_src); ++ VkOHOSNativeBufferFormatPropertiesOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkOHOSNativeBufferFormatPropertiesOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkImportOHOSNativeBufferInfoOpenHarmony { ++ VkStructureType sType; ++ const void* pNext{}; ++ struct OH_NativeBuffer* buffer{}; ++ safe_VkImportOHOSNativeBufferInfoOpenHarmony(const VkImportOHOSNativeBufferInfoOpenHarmony* in_struct); ++ safe_VkImportOHOSNativeBufferInfoOpenHarmony(const safe_VkImportOHOSNativeBufferInfoOpenHarmony& copy_src); ++ safe_VkImportOHOSNativeBufferInfoOpenHarmony& operator=(const safe_VkImportOHOSNativeBufferInfoOpenHarmony& copy_src); ++ safe_VkImportOHOSNativeBufferInfoOpenHarmony(); ++ ~safe_VkImportOHOSNativeBufferInfoOpenHarmony(); ++ void initialize(const VkImportOHOSNativeBufferInfoOpenHarmony* in_struct); ++ void initialize(const safe_VkImportOHOSNativeBufferInfoOpenHarmony* copy_src); ++ VkImportOHOSNativeBufferInfoOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkImportOHOSNativeBufferInfoOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony { ++ VkStructureType sType; ++ const void* pNext{}; ++ VkDeviceMemory memory; ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* in_struct); ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& copy_src); ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& operator=(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony& copy_src); ++ safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(); ++ ~safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony(); ++ void initialize(const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* in_struct); ++ void initialize(const safe_VkMemoryGetOHOSNativeBufferInfoOpenHarmony* copy_src); ++ VkMemoryGetOHOSNativeBufferInfoOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkMemoryGetOHOSNativeBufferInfoOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++struct safe_VkExternalFormatOpenHarmony { ++ VkStructureType sType; ++ void* pNext{}; ++ uint64_t externalFormat; ++ safe_VkExternalFormatOpenHarmony(const VkExternalFormatOpenHarmony* in_struct); ++ safe_VkExternalFormatOpenHarmony(const safe_VkExternalFormatOpenHarmony& copy_src); ++ safe_VkExternalFormatOpenHarmony& operator=(const safe_VkExternalFormatOpenHarmony& copy_src); ++ safe_VkExternalFormatOpenHarmony(); ++ ~safe_VkExternalFormatOpenHarmony(); ++ void initialize(const VkExternalFormatOpenHarmony* in_struct); ++ void initialize(const safe_VkExternalFormatOpenHarmony* copy_src); ++ VkExternalFormatOpenHarmony *ptr() { return reinterpret_cast(this); } ++ VkExternalFormatOpenHarmony const *ptr() const { return reinterpret_cast(this); } ++}; ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++ + struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { + VkStructureType sType; + const void* pNext{}; +diff --git a/layers/generated/vk_typemap_helper.h b/layers/generated/vk_typemap_helper.h +index 482097bc2..754b3f1cb 100644 +--- a/layers/generated/vk_typemap_helper.h ++++ b/layers/generated/vk_typemap_helper.h +@@ -6513,6 +6513,83 @@ template <> struct LvlSTypeMap struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkOHOSSurfaceCreateInfoOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkOHOSNativeBufferUsageOpenHarmony to id VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_USAGE_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkOHOSNativeBufferUsageOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkOHOSNativeBufferPropertiesOpenHarmony to id VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_PROPERTIES_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkOHOSNativeBufferPropertiesOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkOHOSNativeBufferFormatPropertiesOpenHarmony to id VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_OHOS_NATIVE_BUFFER_FORMAT_PROPERTIES_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkOHOSNativeBufferFormatPropertiesOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkImportOHOSNativeBufferInfoOpenHarmony to id VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkImportOHOSNativeBufferInfoOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkMemoryGetOHOSNativeBufferInfoOpenHarmony to id VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_OHOS_NATIVE_BUFFER_INFO_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkMemoryGetOHOSNativeBufferInfoOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY ++#ifdef VK_USE_PLATFORM_OHOS_OPENHARMONY ++// Map type VkExternalFormatOpenHarmony to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY ++template <> struct LvlTypeMap { ++ static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OPENHARMONY; ++}; ++ ++template <> struct LvlSTypeMap { ++ typedef VkExternalFormatOpenHarmony Type; ++}; ++ ++#endif // VK_USE_PLATFORM_OHOS_OPENHARMONY + // Map type VkAccelerationStructureGeometryTrianglesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR + template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; +diff --git a/layers/generated/vk_validation_error_messages.h b/layers/generated/vk_validation_error_messages.h +index 5f2f17afa..ea04f7935 100644 +--- a/layers/generated/vk_validation_error_messages.h ++++ b/layers/generated/vk_validation_error_messages.h +@@ -3776,6 +3776,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { + {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04602", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", "1.3-extensions"}, + {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04603", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK", "1.3-extensions"}, + {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-parameter", "If descriptorTypeCount is not 0, pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid VkDescriptorType values", "1.3-extensions"}, ++ {"VUID-VkOHOSSurfaceCreateInfoOpenHarmony-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, ++ {"VUID-VkOHOSSurfaceCreateInfoOpenHarmony-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, ++ {"VUID-VkOHOSSurfaceCreateInfoOpenHarmony-sType-sType", "sType must be VK_STRUCTURE_TYPE_OHOS_SURFACE_CREATE_INFO_OPENHARMONY", "1.3-extensions"}, ++ {"VUID-VkOHOSSurfaceCreateInfoOpenHarmony-window-01248", "window must point to a valid OHOS ANativeWindow", "1.3-extensions"}, + {"VUID-VkOpticalFlowExecuteInfoNV-flags-parameter", "flags must be a valid combination of VkOpticalFlowExecuteFlagBitsNV values", "1.3-extensions"}, + {"VUID-VkOpticalFlowExecuteInfoNV-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkOpticalFlowExecuteInfoNV-pRegions-parameter", "If regionCount is not 0, pRegions must be a valid pointer to an array of regionCount VkRect2D structures", "1.3-extensions"}, +@@ -11830,6 +11834,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { + {"VUID-vkCreateMicromapEXT-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, + {"VUID-vkCreateMicromapEXT-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkMicromapCreateInfoEXT structure", "1.3-extensions"}, + {"VUID-vkCreateMicromapEXT-pMicromap-parameter", "pMicromap must be a valid pointer to a VkMicromapEXT handle", "1.3-extensions"}, ++ {"VUID-vkCreateOHOSSurfaceOpenHarmony-instance-parameter", "instance must be a valid VkInstance handle", "1.3-extensions"}, ++ {"VUID-vkCreateOHOSSurfaceOpenHarmony-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, ++ {"VUID-vkCreateOHOSSurfaceOpenHarmony-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkOHOSSurfaceCreateInfoOpenHarmony structure", "1.3-extensions"}, ++ {"VUID-vkCreateOHOSSurfaceOpenHarmony-pSurface-parameter", "pSurface must be a valid pointer to a VkSurfaceKHR handle", "1.3-extensions"}, + {"VUID-vkCreateOpticalFlowSessionNV-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, + {"VUID-vkCreateOpticalFlowSessionNV-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, + {"VUID-vkCreateOpticalFlowSessionNV-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkOpticalFlowSessionCreateInfoNV structure", "1.3-extensions"}, +diff --git a/scripts/common_codegen.py b/scripts/common_codegen.py +index 9e4d60ac7..8406167b3 100644 +--- a/scripts/common_codegen.py ++++ b/scripts/common_codegen.py +@@ -62,6 +62,7 @@ platform_dict = { + 'provisional' : 'VK_ENABLE_BETA_EXTENSIONS', + 'directfb' : 'VK_USE_PLATFORM_DIRECTFB_EXT', + 'screen' : 'VK_USE_PLATFORM_SCREEN_QNX', ++ 'OHOS' : 'VK_USE_PLATFORM_OHOS_OPENHARMONY', + } + + # +-- +Gitee + + +From e1eeac5d02afcb41f17eeb42e9cafb455debace5 Mon Sep 17 00:00:00 2001 +From: andrew0229 +Date: Wed, 15 Mar 2023 02:06:58 +0000 +Subject: [PATCH 2/3] add spirv-tools build fix + +Signed-off-by: andrew0229 +--- + spirv-tools.patch | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + create mode 100644 spirv-tools.patch + +diff --git a/spirv-tools.patch b/spirv-tools.patch +new file mode 100644 +index 000000000..576666f5f +--- /dev/null ++++ b/spirv-tools.patch +@@ -0,0 +1,16 @@ ++diff --git a/BUILD.gn b/BUILD.gn ++index b7e20b34..7b83378e 100644 ++--- a/BUILD.gn +++++ b/BUILD.gn ++@@ -12,8 +12,9 @@ ++ # See the License for the specific language governing permissions and ++ # limitations under the License. ++ ++-import("//build_overrides/build.gni") ++-import("//build_overrides/spirv_tools.gni") +++build_overrides_dir = "//third_party/Vulkan-ValidationLayers/build-openharmony/build_overrides" +++import("${build_overrides_dir}/build.gni") +++import("${build_overrides_dir}/spirv_tools.gni") ++ if (build_with_chromium) { ++ import("//testing/test.gni") ++ import("//third_party/protobuf/proto_library.gni") +-- +Gitee + + +From ab643697c6f2407f457294cf7d6445b9ea9282c0 Mon Sep 17 00:00:00 2001 +From: andrew0229 +Date: Wed, 15 Mar 2023 02:08:15 +0000 +Subject: [PATCH 3/3] add vulkan-headers fix + +Signed-off-by: andrew0229 +--- + 0001-fix-vk.xml.patch | 29 +++++++++++++++++++++++++++++ + 1 file changed, 29 insertions(+) + create mode 100644 0001-fix-vk.xml.patch + +diff --git a/0001-fix-vk.xml.patch b/0001-fix-vk.xml.patch +new file mode 100644 +index 000000000..5a52abb32 +--- /dev/null ++++ b/0001-fix-vk.xml.patch +@@ -0,0 +1,29 @@ ++From 2db7ef659877ff34e400469d14eb53a5349b0bd9 Mon Sep 17 00:00:00 2001 ++From: andrew0229 ++Date: Wed, 15 Mar 2023 01:13:39 +0000 ++Subject: [PATCH] fix vk.xml ++ ++Signed-off-by: andrew0229 ++Change-Id: Ib516cc68d2481ce3e2c72c342e9744f3d369cb57 ++--- ++ registry/vk.xml | 4 ++-- ++ 1 file changed, 2 insertions(+), 2 deletions(-) ++ ++diff --git a/registry/vk.xml b/registry/vk.xml ++index b9260fa..d0fc9ee 100644 ++--- a/registry/vk.xml +++++ b/registry/vk.xml ++@@ -20548,8 +20548,8 @@ typedef void* MTLSharedEvent_id; ++ ++ ++ ++- ++- +++ +++ ++ ++ ++ ++-- ++2.25.1 ++ +-- +Gitee + diff --git a/build-gn/secondary/build_overrides/vulkan_validation_layers.gni b/build-gn/secondary/build_overrides/vulkan_validation_layers.gni index 26e2ec5e06753797f2ace79b7ac1ab60e43773b9..4716578c47805070d9e3afb9d9c694c0e3fd95e5 100644 --- a/build-gn/secondary/build_overrides/vulkan_validation_layers.gni +++ b/build-gn/secondary/build_overrides/vulkan_validation_layers.gni @@ -13,11 +13,10 @@ # limitations under the License. # Paths to validation layer dependencies -vulkan_headers_dir = "//external/Vulkan-Headers" -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" +vvl_spirv_tools_dir = "external/SPIRV-Tools" +vvl_glslang_dir = "external/glslang/" +robin_hood_headers_dir = "external/robin-hood-hashing/src/include" # Subdirectories for generated files vulkan_data_subdir = "" diff --git a/build-openharmony/BUILD.gn b/build-openharmony/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ebb1f3a35cb56f2da369e5c33926858474c7116e --- /dev/null +++ b/build-openharmony/BUILD.gn @@ -0,0 +1,295 @@ +# Copyright (C) 2018-2021 The ANGLE Project Authors. +# Copyright (C) 2019-2021 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://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_overrides/build.gni") +import("./build_overrides/vulkan_validation_layers.gni") + +# Fuchsia has non-upstream changes to the vulkan layers, so we don't want +# to build it from upstream sources. +assert(!is_fuchsia) + +# target_gen_dir:: //out/rk3568/gen/third_party/Vulkan-ValidationLayers/build-openharmony +# vulkan_gen_dir = "$target_gen_dir/$vulkan_gen_subdir" +# vulkan_gen_dir:: //out/rk3568/gen/third_party/Vulkan-ValidationLayers/build-openharmony/ +# raw_vulkan_gen_dir = rebase_path(vulkan_gen_dir, root_build_dir) +# raw_vulkan_gen_dir:: gen/third_party/Vulkan-ValidationLayers/build-openharmony/ + +# root_out_dir:: //out/rk3568 +vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir" +# vulkan_data_dir:: //out/rk3568/ + +# raw_vulkan_data_dir = rebase_path(vulkan_data_dir, root_build_dir) +# raw_vulkan_data_dir:: ./ + +# raw_root_out_dir = rebase_path(root_out_dir, root_build_dir) +# raw_root_out_dir:: . + +config("generated_layers_config") { + cflags = [ + "-Wno-conversion", + "-Wno-deprecated-copy", + "-Wno-extra-semi", + "-Wno-implicit-fallthrough", + "-Wno-missing-field-initializers", + "-Wno-newline-eof", + "-Wno-sign-compare", + "-Wno-unused-const-variable", + ] +} + +config("vulkan_internal_config") { + defines = [ + "VULKAN_NON_CMAKE_BUILD", + "VK_ENABLE_BETA_EXTENSIONS", + ] + + cflags = [] + if (is_clang || !is_win) { + cflags += [ "-Wno-unused-function" ] + } + if (is_ohos) { + cflags += [ "-Wno-extra-semi", + "-Wno-unused-but-set-variable" ] + } +} + +# The validation layers +# --------------------- + +config("vulkan_layer_config") { + include_dirs = [ + "../layers", + "../layers/generated", + ] +} + +core_validation_sources = [ + "../layers/android_ndk_types.h", + "../layers/base_node.cpp", + "../layers/base_node.h", + "../layers/buffer_state.cpp", + "../layers/buffer_state.h", + "../layers/buffer_validation.cpp", + "../layers/buffer_validation.h", + "../layers/convert_to_renderpass2.cpp", + "../layers/convert_to_renderpass2.h", + "../layers/core_validation.cpp", + "../layers/core_validation.h", + "../layers/core_validation_error_enums.h", + "../layers/cmd_buffer_state.h", + "../layers/cmd_buffer_state.cpp", + "../layers/device_memory_state.h", + "../layers/device_memory_state.cpp", + "../layers/device_state.h", + "../layers/image_state.h", + "../layers/image_state.cpp", + "../layers/pipeline_state.h", + "../layers/pipeline_state.cpp", + "../layers/pipeline_layout_state.h", + "../layers/pipeline_layout_state.cpp", + "../layers/pipeline_sub_state.h", + "../layers/pipeline_sub_state.cpp", + "../layers/qfo_transfer.h", + "../layers/query_state.h", + "../layers/queue_state.cpp", + "../layers/queue_state.h", + "../layers/ray_tracing_state.h", + "../layers/render_pass_state.h", + "../layers/render_pass_state.cpp", + "../layers/sampler_state.h", + "../layers/core_error_location.cpp", + "../layers/core_error_location.h", + "../layers/descriptor_sets.cpp", + "../layers/descriptor_sets.h", + "../layers/descriptor_validation.cpp", + "../layers/drawdispatch.cpp", + "../layers/generated/corechecks_optick_instrumentation.cpp", + "../layers/generated/corechecks_optick_instrumentation.h", + "../layers/generated/spirv_validation_helper.cpp", + "../layers/generated/spirv_grammar_helper.cpp", + "../layers/generated/spirv_grammar_helper.h", + "../layers/generated/command_validation.cpp", + "../layers/generated/command_validation.h", + "../layers/generated/gpu_pre_dispatch_comp.h", + "../layers/generated/gpu_pre_draw_vert.h", + "../layers/generated/gpu_as_inspection_comp.h", + "../layers/generated/synchronization_validation_types.cpp", + "../layers/generated/synchronization_validation_types.h", + "../layers/sync_utils.cpp", + "../layers/sync_utils.h", + "../layers/sync_vuid_maps.cpp", + "../layers/sync_vuid_maps.h", + "../layers/gpu_shaders/gpu_shaders_constants.h", + "../layers/gpu_utils.cpp", + "../layers/gpu_utils.h", + "../layers/gpu_validation.cpp", + "../layers/gpu_validation.h", + "../layers/gpu_vuids.h", + "../layers/image_layout_map.cpp", + "../layers/image_layout_map.h", + "../layers/range_vector.h", + "../layers/shader_module.cpp", + "../layers/shader_module.h", + "../layers/shader_validation.cpp", + "../layers/shader_validation.h", + "../layers/state_tracker.cpp", + "../layers/state_tracker.h", + "../layers/subresource_adapter.cpp", + "../layers/subresource_adapter.h", + "../layers/synchronization_validation.cpp", + "../layers/synchronization_validation.h", +] + +object_lifetimes_sources = [ + "../layers/generated/object_tracker.cpp", + "../layers/generated/object_tracker.h", + "../layers/object_lifetime_validation.h", + "../layers/object_tracker_utils.cpp", +] + +stateless_validation_sources = [ + "../layers/generated/parameter_validation.cpp", + "../layers/generated/parameter_validation.h", + "../layers/parameter_name.h", + "../layers/parameter_validation_utils.cpp", + "../layers/stateless_validation.h", +] + +thread_safety_sources = [ + "../layers/generated/thread_safety.cpp", + "../layers/generated/thread_safety.h", +] + +unique_objects_sources = [] + +best_practices_sources = [ + "../layers/best_practices_error_enums.h", + "../layers/best_practices_utils.cpp", + "../layers/best_practices_validation.h", + "../layers/generated/best_practices.cpp", + "../layers/generated/best_practices.h", +] + +debug_printf_sources = [ + "../layers/debug_printf.cpp", + "../layers/debug_printf.h", +] + +chassis_sources = [ + "$vulkan_headers_dir/include/vulkan/vk_layer.h", + "$vulkan_headers_dir/include/vulkan/vulkan.h", + "../layers/generated/chassis.cpp", + "../layers/generated/chassis.h", + "../layers/generated/chassis_dispatch_helper.h", + "../layers/generated/layer_chassis_dispatch.cpp", + "../layers/generated/layer_chassis_dispatch.h", + "../layers/generated/vk_dispatch_table_helper.h", + "../layers/generated/vk_extension_helper.h", + "../layers/generated/vk_safe_struct.cpp", + "../layers/layer_options.cpp", + "../layers/layer_options.h", + "../layers/vk_layer_settings_ext.h", +] + +config("vulkan_memory_allocator_config") { + if (is_clang) { + cflags_cc = [ "-Wno-nullability-completeness" ] + } +} + +config("vulkan_core_validation_config") { + include_dirs = [ + "$vvl_glslang_dir", + ] +} + +config("vulkan_stateless_validation_config") { + if (is_clang) { + cflags_cc = [ "-Wno-unused-const-variable" ] + } +} + +ohos_shared_library("VkLayer_khronos_validation") { + include_dirs = [ + "../layers", + "../layers/generated", + ] + defines = [ "XXH_NO_LONG_LONG" ] + public_configs = [ + ":vulkan_internal_config", + ":vulkan_memory_allocator_config" + ] + public_deps = [ "$vulkan_headers_dir:vulkan_headers" ] + if (!is_ohos) { + configs -= [ "//build/config/compiler:chromium_code" ] + configs += [ "//build/config/compiler:no_chromium_code" ] + } + configs = [ + "//build/config/compiler:rtti", + ":generated_layers_config" ] + public_configs += [ ":vulkan_layer_config" ] + sources = core_validation_sources + + object_lifetimes_sources + + stateless_validation_sources + + thread_safety_sources + + unique_objects_sources + + best_practices_sources + + debug_printf_sources + + chassis_sources + + sources += [ + "$vulkan_headers_dir/include/vulkan/vk_layer.h", + "$vulkan_headers_dir/include/vulkan/vk_sdk_platform.h", + "$vulkan_headers_dir/include/vulkan/vulkan.h", + "../layers/android_ndk_types.h", + "../layers/cast_utils.h", + "../layers/generated/vk_enum_string_helper.h", + "../layers/generated/vk_layer_dispatch_table.h", + "../layers/generated/vk_object_types.h", + "../layers/generated/vk_safe_struct.h", + "../layers/generated/vk_typemap_helper.h", + "../layers/generated/vk_validation_error_messages.h", + "../layers/generated/vk_format_utils.cpp", + "../layers/generated/vk_format_utils.h", + "../layers/hash_util.h", + "../layers/hash_vk_types.h", + "../layers/sparse_containers.h", + "../layers/vk_layer_config.cpp", + "../layers/vk_layer_config.h", + "../layers/vk_layer_data.h", + "../layers/vk_layer_extension_utils.cpp", + "../layers/vk_layer_extension_utils.h", + "../layers/vk_layer_logging.h", + "../layers/vk_layer_utils.cpp", + "../layers/vk_layer_utils.h", + "../layers/vk_mem_alloc.h", + "../layers/xxhash.c", + "../layers/xxhash.h", + ] + output_name = "VkLayer_khronos_validation" + output_extension = "so" + part_name = "graphic_2d" + subsystem_name = "graphic" +} + +## Build VkLayer_khronos_validation.json {{{ +ohos_prebuilt_etc("VkLayer_khronos_validation_json") { + source = "../layers/json/VkLayer_khronos_validation.json" + part_name = "graphic_2d" + subsystem_name = "graphic" + module_install_dir = "etc/vulkan/explicit_layer.d" +} +## Build VkLayer_khronos_validation.json }}} \ No newline at end of file diff --git a/build-openharmony/build_overrides/build.gni b/build-openharmony/build_overrides/build.gni new file mode 100644 index 0000000000000000000000000000000000000000..b5b05ac1538303770565b06ad395bd152d985f04 --- /dev/null +++ b/build-openharmony/build_overrides/build.gni @@ -0,0 +1,16 @@ + +import("//build/ohos.gni") + + +build_with_chromium = false +ignore_elf32_limitations = true +linux_use_bundled_binutils_override = false +use_system_xcode = true + +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" \ No newline at end of file diff --git a/build-openharmony/build_overrides/spirv_tools.gni b/build-openharmony/build_overrides/spirv_tools.gni new file mode 100644 index 0000000000000000000000000000000000000000..c981c2f7b7eeb4f606764c4a30c08a5d0420d163 --- /dev/null +++ b/build-openharmony/build_overrides/spirv_tools.gni @@ -0,0 +1,20 @@ +# Copyright (c) 2019,2021 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://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. + +# We are building inside Vulkan-ValidationLayers +spirv_tools_standalone = false + +# Paths to SPIRV-Tools dependencies +spirv_tools_googletest_dir = "//third_party/Vulkan-ValidationLayers/external/googletest" +spirv_tools_spirv_headers_dir = "//third_party/spirv-headers" diff --git a/build-openharmony/build_overrides/vulkan_headers.gni b/build-openharmony/build_overrides/vulkan_headers.gni new file mode 100644 index 0000000000000000000000000000000000000000..4e0f74bd2325350fcbf3c52c0044b4a5ee3e75db --- /dev/null +++ b/build-openharmony/build_overrides/vulkan_headers.gni @@ -0,0 +1,15 @@ +# Copyright (c) 2020 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://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. + +vulkan_use_x11 = false diff --git a/build-openharmony/build_overrides/vulkan_validation_layers.gni b/build-openharmony/build_overrides/vulkan_validation_layers.gni new file mode 100644 index 0000000000000000000000000000000000000000..b1d5c3dcf2540fd7664b7a728bca9f0f5e6dd7e1 --- /dev/null +++ b/build-openharmony/build_overrides/vulkan_validation_layers.gni @@ -0,0 +1,25 @@ +# Copyright (c) 2019,2021 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://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. + +# Paths to validation layer dependencies +vulkan_headers_dir = "//third_party//vulkan-headers" +vvl_spirv_tools_dir = "//third_party/spirv-tools" +vvl_glslang_dir = "../external/glslang/" + +# Subdirectories for generated files +vulkan_data_subdir = "" +vulkan_gen_subdir = "" + +# Build options +ozone_platform_x11 = false diff --git a/bundle.json b/bundle.json new file mode 100644 index 0000000000000000000000000000000000000000..1fdeb1e8f79f47abfa2b5e64fb617b9da5411b77 --- /dev/null +++ b/bundle.json @@ -0,0 +1,34 @@ +{ + "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": "graphic", + "syscap": [], + "features": [], + "adapted_system_type": ["standard"], + "rom": "1", + "ram": "1", + "deps": { + "components": [], + "third_party": [] + }, + "build": { + "sub_component": [], + "inner_kits": [], + "test": [] + } + } +} \ No newline at end of file diff --git a/layers/generated/best_practices.cpp b/layers/generated/best_practices.cpp index cdb6f3515fe1a7271c51da17c661a2cf2743d415..8b14eedaa54533ec76324c4dcde20975e088d335 100644 --- a/layers/generated/best_practices.cpp +++ b/layers/generated/best_practices.cpp @@ -3279,6 +3279,58 @@ void BestPractices::PostCallRecordGetFramebufferTilePropertiesQCOM( } } +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + ValidationStateTracker::PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkCreateSurfaceOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) { + ValidationStateTracker::PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkGetNativeBufferPropertiesOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) { + ValidationStateTracker::PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkGetMemoryNativeBufferOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + void BestPractices::PostCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/best_practices.h b/layers/generated/best_practices.h index f934dd9141d4f9c4f96d0df3147ce0610ef0c855..f5df642199d9aab27b5e31ba7a25d664fbb8958d 100644 --- a/layers/generated/best_practices.h +++ b/layers/generated/best_practices.h @@ -1902,6 +1902,40 @@ void PostCallRecordGetFramebufferTilePropertiesQCOM( VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + void PostCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/chassis.cpp b/layers/generated/chassis.cpp index 739e8cf6211cb2bb459b6e665e20af804cf21472..74e2d1ff343f450ced56238b63b3f28601971095 100644 --- a/layers/generated/chassis.cpp +++ b/layers/generated/chassis.cpp @@ -14085,6 +14085,82 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( +#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; + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + } + VkResult result = DispatchCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); + } + return result; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +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; + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + } + VkResult result = DispatchGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); + } + 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; + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetMemoryNativeBufferOHOS]) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + } + VkResult result = DispatchGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); + } + return result; +} +#endif // VK_USE_PLATFORM_OHOS + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( VkDevice device, @@ -15363,6 +15439,15 @@ const layer_data::unordered_map name_to_funcptr_map {"vkCmdOpticalFlowExecuteNV", {kFuncTypeDev, (void*)CmdOpticalFlowExecuteNV}}, {"vkGetFramebufferTilePropertiesQCOM", {kFuncTypeDev, (void*)GetFramebufferTilePropertiesQCOM}}, {"vkGetDynamicRenderingTilePropertiesQCOM", {kFuncTypeDev, (void*)GetDynamicRenderingTilePropertiesQCOM}}, +#ifdef VK_USE_PLATFORM_OHOS + {"vkCreateSurfaceOHOS", {kFuncTypeInst, (void*)CreateSurfaceOHOS}}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetNativeBufferPropertiesOHOS", {kFuncTypeDev, (void*)GetNativeBufferPropertiesOHOS}}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetMemoryNativeBufferOHOS", {kFuncTypeDev, (void*)GetMemoryNativeBufferOHOS}}, +#endif {"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}}, {"vkDestroyAccelerationStructureKHR", {kFuncTypeDev, (void*)DestroyAccelerationStructureKHR}}, {"vkCmdBuildAccelerationStructuresKHR", {kFuncTypeDev, (void*)CmdBuildAccelerationStructuresKHR}}, diff --git a/layers/generated/chassis.h b/layers/generated/chassis.h index 665b066ff2c210123a25084461ad8935133bbf6e..21d97571af951b920f460d9582ccce06225b9a80 100644 --- a/layers/generated/chassis.h +++ b/layers/generated/chassis.h @@ -3584,6 +3584,28 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( +#ifdef VK_USE_PLATFORM_OHOS + +VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +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, @@ -5984,6 +6006,21 @@ class ValidationObject { virtual bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const { return false; }; virtual void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {}; virtual void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) {}; +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { return false; }; + virtual void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {}; + virtual void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {}; +#endif +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const { return false; }; + virtual void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) {}; + virtual void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) {}; +#endif +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const { return false; }; + virtual void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) {}; + virtual void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) {}; +#endif virtual bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { return false; }; virtual void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {}; virtual void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) {}; diff --git a/layers/generated/chassis_dispatch_helper.h b/layers/generated/chassis_dispatch_helper.h index 9d01d8e9f3c89f285b5c300b458f12c7f3ae7c64..15955caf59cee6795ef286c5b0a6c7366fc155ca 100644 --- a/layers/generated/chassis_dispatch_helper.h +++ b/layers/generated/chassis_dispatch_helper.h @@ -1421,6 +1421,12 @@ typedef enum InterceptId{ InterceptIdPreCallValidateGetDynamicRenderingTilePropertiesQCOM, InterceptIdPreCallRecordGetDynamicRenderingTilePropertiesQCOM, InterceptIdPostCallRecordGetDynamicRenderingTilePropertiesQCOM, + InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS, + InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPreCallValidateGetMemoryNativeBufferOHOS, + InterceptIdPreCallRecordGetMemoryNativeBufferOHOS, + InterceptIdPostCallRecordGetMemoryNativeBufferOHOS, InterceptIdPreCallValidateCreateAccelerationStructureKHR, InterceptIdPreCallRecordCreateAccelerationStructureKHR, InterceptIdPostCallRecordCreateAccelerationStructureKHR, @@ -3068,6 +3074,18 @@ void ValidationObject::InitObjectDispatchVectors() { BUILD_DISPATCH_VECTOR(PreCallValidateGetDynamicRenderingTilePropertiesQCOM); BUILD_DISPATCH_VECTOR(PreCallRecordGetDynamicRenderingTilePropertiesQCOM); BUILD_DISPATCH_VECTOR(PostCallRecordGetDynamicRenderingTilePropertiesQCOM); +#ifdef VK_USE_PLATFORM_OHOS +#endif +#ifdef VK_USE_PLATFORM_OHOS + BUILD_DISPATCH_VECTOR(PreCallValidateGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetNativeBufferPropertiesOHOS); +#endif +#ifdef VK_USE_PLATFORM_OHOS + BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryNativeBufferOHOS); +#endif BUILD_DISPATCH_VECTOR(PreCallValidateCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PreCallRecordCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PostCallRecordCreateAccelerationStructureKHR); diff --git a/layers/generated/corechecks_optick_instrumentation.cpp b/layers/generated/corechecks_optick_instrumentation.cpp index 47c63e91e74ddc6418d594d4aa13c2025fdf0b9d..4d585b2cc601859675655dbf3d75e82dbb61376d 100644 --- a/layers/generated/corechecks_optick_instrumentation.cpp +++ b/layers/generated/corechecks_optick_instrumentation.cpp @@ -9360,6 +9360,60 @@ void CoreChecksOptickInstrumented::PostCallRecordGetDynamicRenderingTileProperti CoreChecks::PostCallRecordGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties, result); } +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); +} + +void CoreChecksOptickInstrumented::PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); +} + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties); +} + +void CoreChecksOptickInstrumented::PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); +} + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); +} + +void CoreChecksOptickInstrumented::PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); +} + +#endif // VK_USE_PLATFORM_OHOS bool CoreChecksOptickInstrumented::PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { OPTICK_EVENT(); auto result = CoreChecks::PreCallValidateCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); diff --git a/layers/generated/corechecks_optick_instrumentation.h b/layers/generated/corechecks_optick_instrumentation.h index 335f5d9aa592e76da69725a320c7c0d3ba72608d..8be6f1414767d79c27508abd9903955ed41fa28c 100644 --- a/layers/generated/corechecks_optick_instrumentation.h +++ b/layers/generated/corechecks_optick_instrumentation.h @@ -1884,6 +1884,21 @@ class CoreChecksOptickInstrumented : public CoreChecks { bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) override; void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const override; + void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) override; + void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const override; + void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) override; + void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const override; + void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) override; + void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const override; void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) override; void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) override; diff --git a/layers/generated/layer_chassis_dispatch.cpp b/layers/generated/layer_chassis_dispatch.cpp index d996b50dfd6fa26e03e8c29efd4b10e141fbefc6..f807e8d4be7edb83f77c649e98170ef28af5af72 100644 --- a/layers/generated/layer_chassis_dispatch.cpp +++ b/layers/generated/layer_chassis_dispatch.cpp @@ -10904,6 +10904,64 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( return result; } +#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; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +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; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +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 = NULL; + { + 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, diff --git a/layers/generated/layer_chassis_dispatch.h b/layers/generated/layer_chassis_dispatch.h index 9f49fa7308d9ce5d63b1a10ed5746d33139ecb04..662e21cace9c522e9bd7883727e817b3ed9b345a 100644 --- a/layers/generated/layer_chassis_dispatch.h +++ b/layers/generated/layer_chassis_dispatch.h @@ -2702,6 +2702,25 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif // VK_USE_PLATFORM_OHOS VkResult DispatchCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/object_tracker.cpp b/layers/generated/object_tracker.cpp index 8583cd9ab1fefb4765e34d09789d3b6818158e21..ff25f7090673e1cfaeb9ba445c441737f308a3e9 100644 --- a/layers/generated/object_tracker.cpp +++ b/layers/generated/object_tracker.cpp @@ -8057,6 +8057,60 @@ bool ObjectLifetimes::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( return skip; } +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const { + bool skip = false; + skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateSurfaceOHOS-instance-parameter", kVUIDUndefined); + + return skip; +} + +void ObjectLifetimes::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + if (result != VK_SUCCESS) return; + CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); + +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const { + bool skip = false; + skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); + + return skip; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const { + bool skip = false; + skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); + if (pInfo) { + skip |= ValidateObject(pInfo->memory, kVulkanObjectTypeDeviceMemory, false, kVUIDUndefined, kVUIDUndefined); + } + + return skip; +} +#endif // VK_USE_PLATFORM_OHOS + bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/object_tracker.h b/layers/generated/object_tracker.h index 285e073322c9e1aed6b01b8f762cb0e04004ee37..3d6a40fb2fd600ed863b63809a3bc454cd98f456 100644 --- a/layers/generated/object_tracker.h +++ b/layers/generated/object_tracker.h @@ -3378,6 +3378,34 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const override; +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/parameter_validation.cpp b/layers/generated/parameter_validation.cpp index e5d4586a79752fee195d58bdcacc7c005a01cfff..3f3455a74fb16d2184c09fee7ba052008d9ee724 100644 --- a/layers/generated/parameter_validation.cpp +++ b/layers/generated/parameter_validation.cpp @@ -70,7 +70,7 @@ const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_B const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FACE_FRONT_AND_BACK|VK_STENCIL_FRONT_AND_BACK; const VkSubpassDescriptionFlags AllVkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX|VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX|VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM|VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT; 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|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR; -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_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR|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; +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_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR|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_NATIVE_BUFFER_BIT_OHOS; 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_D3D11_FENCE_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA; const VkFenceImportFlags AllVkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT|VK_FENCE_IMPORT_TEMPORARY_BIT_KHR; const VkMemoryAllocateFlags AllVkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT|VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; @@ -5372,6 +5372,22 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons // No Validation code for VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM structure members -- Covers VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType + // No Validation code for VkNativeBufferUsageOHOS structure members -- Covers VUID-VkNativeBufferUsageOHOS-sType-sType + + // No Validation code for VkNativeBufferFormatPropertiesOHOS structure members -- Covers VUID-VkNativeBufferFormatPropertiesOHOS-sType-sType + +#ifdef VK_USE_PLATFORM_OHOS + // Validation code for VkImportNativeBufferInfoOHOS structure members + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: { // Covers VUID-VkImportNativeBufferInfoOHOS-sType-sType + if (is_const_param) { + VkImportNativeBufferInfoOHOS *structure = (VkImportNativeBufferInfoOHOS *) header; + skip |= validate_required_pointer("VkImportNativeBufferInfoOHOS", "buffer", structure->buffer, kVUIDUndefined); + } + } break; +#endif // VK_USE_PLATFORM_OHOS + + // No Validation code for VkExternalFormatOHOS structure members -- Covers VUID-VkExternalFormatOHOS-sType-sType + // Validation code for VkWriteDescriptorSetAccelerationStructureKHR structure members case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { // Covers VUID-VkWriteDescriptorSetAccelerationStructureKHR-sType-sType if (is_const_param) { @@ -5886,9 +5902,9 @@ bool StatelessValidation::PreCallValidateAllocateMemory( skip |= validate_struct_type("vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true, "VUID-vkAllocateMemory-pAllocateInfo-parameter", "VUID-VkMemoryAllocateInfo-sType-sType"); if (pAllocateInfo != NULL) { - const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, 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_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; + const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, 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_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; - skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkImportNativeBufferInfoOHOS, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); } if (pAllocator != NULL) { @@ -6689,9 +6705,9 @@ bool StatelessValidation::PreCallValidateCreateImage( skip |= validate_struct_type("vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true, "VUID-vkCreateImage-pCreateInfo-parameter", "VUID-VkImageCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -8933,9 +8949,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); if (pImageFormatProperties != NULL) { - const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_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 }; - skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkNativeBufferUsageOHOS, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); } if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); return skip; @@ -9043,9 +9059,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversion( skip |= validate_struct_type("vkCreateSamplerYcbcrConversion", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; + const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS }; - skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOHOS", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversion", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); @@ -10618,9 +10634,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirements( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -10668,9 +10684,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirements( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -12133,9 +12149,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); if (pImageFormatProperties != NULL) { - const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_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 }; - skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkNativeBufferUsageOHOS, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); } if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); return skip; @@ -13343,9 +13359,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversionKHR( skip |= validate_struct_type("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; + const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS }; - skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOHOS", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); @@ -14670,9 +14686,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirementsKHR( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -14722,9 +14738,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirementsK if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -18333,9 +18349,9 @@ bool StatelessValidation::PreCallValidateSetBufferCollectionImageConstraintsFUCH skip |= validate_struct_type("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo", ParameterName::IndexVector{ formatConstraintsIndex }), "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", &(pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo), VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, false, kVUIDUndefined, "VUID-VkImageCreateInfo-sType-sType"); - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, 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_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.flags", ParameterName::IndexVector{ formatConstraintsIndex }), "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -19819,6 +19835,95 @@ bool StatelessValidation::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( +#ifdef VK_USE_PLATFORM_OHOS + +bool StatelessValidation::PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const { + bool skip = false; + if (!instance_extensions.vk_khr_surface) skip |= OutputExtensionError("vkCreateSurfaceOHOS", VK_KHR_SURFACE_EXTENSION_NAME); + if (!instance_extensions.vk_ohos_surface) skip |= OutputExtensionError("vkCreateSurfaceOHOS", VK_OHOS_SURFACE_EXTENSION_NAME); + skip |= validate_struct_type("vkCreateSurfaceOHOS", "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 != NULL) + { + skip |= validate_struct_pnext("vkCreateSurfaceOHOS", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkSurfaceCreateInfoOHOS-pNext-pNext", kVUIDUndefined, false, true); + + skip |= validate_reserved_flags("vkCreateSurfaceOHOS", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkSurfaceCreateInfoOHOS-flags-zerobitmask"); + } + if (pAllocator != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnAllocation", reinterpret_cast(pAllocator->pfnAllocation), "VUID-VkAllocationCallbacks-pfnAllocation-00632"); + + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnReallocation", reinterpret_cast(pAllocator->pfnReallocation), "VUID-VkAllocationCallbacks-pfnReallocation-00633"); + + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnFree", reinterpret_cast(pAllocator->pfnFree), "VUID-VkAllocationCallbacks-pfnFree-00634"); + + if (pAllocator->pfnInternalAllocation != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnInternalFree", reinterpret_cast(pAllocator->pfnInternalFree), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + + } + + if (pAllocator->pfnInternalFree != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnInternalAllocation", reinterpret_cast(pAllocator->pfnInternalAllocation), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + + } + } + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pSurface", pSurface, "VUID-vkCreateSurfaceOHOS-pSurface-parameter"); + return skip; +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool StatelessValidation::PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const { + bool skip = false; + if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME); + skip |= validate_required_pointer("vkGetNativeBufferPropertiesOHOS", "buffer", buffer, kVUIDUndefined); + skip |= validate_struct_type("vkGetNativeBufferPropertiesOHOS", "pProperties", "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS", pProperties, VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, true, kVUIDUndefined, kVUIDUndefined); + if (pProperties != NULL) + { + const VkStructureType allowed_structs_VkNativeBufferPropertiesOHOS[] = { VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS }; + + skip |= validate_struct_pnext("vkGetNativeBufferPropertiesOHOS", "pProperties->pNext", "VkNativeBufferFormatPropertiesOHOS", pProperties->pNext, ARRAY_SIZE(allowed_structs_VkNativeBufferPropertiesOHOS), allowed_structs_VkNativeBufferPropertiesOHOS, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, false); + } + return skip; +} + +bool StatelessValidation::PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const { + bool skip = false; + if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME); + skip |= validate_struct_type("vkGetMemoryNativeBufferOHOS", "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 != NULL) + { + skip |= validate_struct_pnext("vkGetMemoryNativeBufferOHOS", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, true); + + skip |= validate_required_handle("vkGetMemoryNativeBufferOHOS", "pInfo->memory", pInfo->memory); + } + skip |= validate_required_pointer("vkGetMemoryNativeBufferOHOS", "pBuffer", pBuffer, kVUIDUndefined); + return skip; +} + +#endif // VK_USE_PLATFORM_OHOS + bool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/parameter_validation.h b/layers/generated/parameter_validation.h index 5635e454523fc04e037685cb4a65151fe7bd4519..1c2b73a77133de276f81ab5092eeedf48c53e682 100644 --- a/layers/generated/parameter_validation.h +++ b/layers/generated/parameter_validation.h @@ -2666,6 +2666,25 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const override; +#endif +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const override; +#endif +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const override; +#endif bool PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/thread_safety.cpp b/layers/generated/thread_safety.cpp index 1fa91da829c5f9baf11d49cf7757da5752700eea..935bc39c8023c4e2177b3c34bcab9e8acdc2b1a2 100644 --- a/layers/generated/thread_safety.cpp +++ b/layers/generated/thread_safety.cpp @@ -9808,6 +9808,62 @@ void ThreadSafety::PostCallRecordGetDynamicRenderingTilePropertiesQCOM( FinishReadObjectParentInstance(device, "vkGetDynamicRenderingTilePropertiesQCOM"); } +#ifdef VK_USE_PLATFORM_OHOS + +void ThreadSafety::PreCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { + StartReadObjectParentInstance(instance, "vkCreateSurfaceOHOS"); +} + +void ThreadSafety::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + FinishReadObjectParentInstance(instance, "vkCreateSurfaceOHOS"); + if (result == VK_SUCCESS) { + CreateObjectParentInstance(*pSurface); + } +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void ThreadSafety::PreCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + StartReadObjectParentInstance(device, "vkGetNativeBufferPropertiesOHOS"); +} + +void ThreadSafety::PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) { + FinishReadObjectParentInstance(device, "vkGetNativeBufferPropertiesOHOS"); +} + +void ThreadSafety::PreCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + StartReadObjectParentInstance(device, "vkGetMemoryNativeBufferOHOS"); +} + +void ThreadSafety::PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) { + FinishReadObjectParentInstance(device, "vkGetMemoryNativeBufferOHOS"); +} +#endif // VK_USE_PLATFORM_OHOS + void ThreadSafety::PreCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/thread_safety.h b/layers/generated/thread_safety.h index 95516a29fb581e80636ab5684f8270fdfee88c01..a89ef8c8823b9e0f88fc1bf175c7f8c8931be61b 100644 --- a/layers/generated/thread_safety.h +++ b/layers/generated/thread_safety.h @@ -6518,6 +6518,47 @@ void PostCallRecordGetDynamicRenderingTilePropertiesQCOM( VkTilePropertiesQCOM* pProperties, VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + +void PreCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) override; + +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PreCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) override; + +void PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) override; + +void PreCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) override; + +void PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + void PreCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/vk_dispatch_table_helper.h b/layers/generated/vk_dispatch_table_helper.h index 1346f4ec2e83c973f005e895c961d84335622c0d..5dd6fd153fd5cc2204c32662d427ececb5b78fc0 100644 --- a/layers/generated/vk_dispatch_table_helper.h +++ b/layers/generated/vk_dispatch_table_helper.h @@ -595,6 +595,15 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubBindOpticalFlowSessionImageNV(VkDevice static VKAPI_ATTR void VKAPI_CALL StubCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; +#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; }; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL StubGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { return VK_SUCCESS; }; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +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, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; }; static VKAPI_ATTR void VKAPI_CALL StubDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { }; static VKAPI_ATTR void VKAPI_CALL StubCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { }; @@ -926,6 +935,7 @@ const layer_data::unordered_map api_extension_map { {"vkGetMemoryFdKHR", "VK_KHR_external_memory_fd"}, {"vkGetMemoryFdPropertiesKHR", "VK_KHR_external_memory_fd"}, {"vkGetMemoryHostPointerPropertiesEXT", "VK_EXT_external_memory_host"}, + {"vkGetMemoryNativeBufferOHOS", "VK_OHOS_external_memory"}, {"vkGetMemoryRemoteAddressNV", "VK_NV_external_memory_rdma"}, {"vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32"}, {"vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32"}, @@ -933,6 +943,7 @@ const layer_data::unordered_map api_extension_map { {"vkGetMemoryZirconHandleFUCHSIA", "VK_FUCHSIA_external_memory"}, {"vkGetMemoryZirconHandlePropertiesFUCHSIA", "VK_FUCHSIA_external_memory"}, {"vkGetMicromapBuildSizesEXT", "VK_EXT_opacity_micromap"}, + {"vkGetNativeBufferPropertiesOHOS", "VK_OHOS_external_memory"}, {"vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing"}, {"vkGetPerformanceParameterINTEL", "VK_INTEL_performance_query"}, {"vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties"}, @@ -1927,6 +1938,14 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->GetFramebufferTilePropertiesQCOM == nullptr) { table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)StubGetFramebufferTilePropertiesQCOM; } table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM) gpa(device, "vkGetDynamicRenderingTilePropertiesQCOM"); if (table->GetDynamicRenderingTilePropertiesQCOM == nullptr) { table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)StubGetDynamicRenderingTilePropertiesQCOM; } +#ifdef VK_USE_PLATFORM_OHOS + table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS) gpa(device, "vkGetNativeBufferPropertiesOHOS"); + if (table->GetNativeBufferPropertiesOHOS == nullptr) { table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS)StubGetNativeBufferPropertiesOHOS; } +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + 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; } table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR) gpa(device, "vkDestroyAccelerationStructureKHR"); @@ -2226,4 +2245,8 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay #endif // VK_USE_PLATFORM_SCREEN_QNX table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV) gpa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); if (table->GetPhysicalDeviceOpticalFlowImageFormatsNV == nullptr) { 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 } diff --git a/layers/generated/vk_enum_string_helper.h b/layers/generated/vk_enum_string_helper.h index 005cc21ea816437fcc617b3fd74439845ebbebda..bf2215c184c6d2ca44954360e035a6409b438614 100644 --- a/layers/generated/vk_enum_string_helper.h +++ b/layers/generated/vk_enum_string_helper.h @@ -493,6 +493,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"; case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS"; case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"; case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: @@ -631,6 +633,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT"; case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: return "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT"; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + return "VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS"; case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"; case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: @@ -673,6 +677,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"; + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: + return "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS"; case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: return "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"; case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: @@ -709,6 +715,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"; case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS"; + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + return "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS"; case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV"; case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: @@ -5274,6 +5288,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMe return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_NATIVE_BUFFER_BIT_OHOS: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_NATIVE_BUFFER_BIT_OHOS"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: @@ -6853,6 +6869,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExterna return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_NATIVE_BUFFER_BIT_OHOS: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_NATIVE_BUFFER_BIT_OHOS"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: diff --git a/layers/generated/vk_extension_helper.h b/layers/generated/vk_extension_helper.h index c34c7e9cade1fa54dfa5469e624699a48627a40b..f0c1f2e3b6a04839c3775dd9a092b0f51fb2c802 100644 --- a/layers/generated/vk_extension_helper.h +++ b/layers/generated/vk_extension_helper.h @@ -105,6 +105,7 @@ struct InstanceExtensions { ExtEnabled vk_mvk_macos_surface{kNotEnabled}; ExtEnabled vk_nn_vi_surface{kNotEnabled}; ExtEnabled vk_nv_external_memory_capabilities{kNotEnabled}; + ExtEnabled vk_ohos_surface{kNotEnabled}; ExtEnabled vk_qnx_screen_surface{kNotEnabled}; struct InstanceReq { @@ -212,6 +213,10 @@ struct InstanceExtensions { {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, #endif {VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_nv_external_memory_capabilities, {})}, +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_ohos_surface, {{ + {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, +#endif #ifdef VK_USE_PLATFORM_SCREEN_QNX {VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_qnx_screen_surface, {{ {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, @@ -359,6 +364,9 @@ static const std::set kInstanceExtensionNames = { VK_NN_VI_SURFACE_EXTENSION_NAME, #endif VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_SURFACE_EXTENSION_NAME, +#endif #ifdef VK_USE_PLATFORM_SCREEN_QNX VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, #endif @@ -628,6 +636,7 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_nv_viewport_array2{kNotEnabled}; ExtEnabled vk_nv_viewport_swizzle{kNotEnabled}; ExtEnabled vk_nv_win32_keyed_mutex{kNotEnabled}; + ExtEnabled vk_ohos_external_memory{kNotEnabled}; ExtEnabled vk_qcom_fragment_density_map_offset{kNotEnabled}; ExtEnabled vk_qcom_image_processing{kNotEnabled}; ExtEnabled vk_qcom_render_pass_shader_resolve{kNotEnabled}; @@ -1200,6 +1209,13 @@ struct DeviceExtensions : public InstanceExtensions { #ifdef VK_USE_PLATFORM_WIN32_KHR {VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_nv_win32_keyed_mutex, {{ {&DeviceExtensions::vk_nv_external_memory_win32, VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME}}})}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ohos_external_memory, {{ + {&DeviceExtensions::vk_khr_sampler_ycbcr_conversion, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME}, + {&DeviceExtensions::vk_khr_external_memory, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME}, + {&DeviceExtensions::vk_ext_queue_family_foreign, VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME}, + {&DeviceExtensions::vk_khr_dedicated_allocation, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME}}})}, #endif {VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_qcom_fragment_density_map_offset, {{ {&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}, @@ -1661,6 +1677,9 @@ static const std::set kDeviceExtensionNames = { VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, #ifdef VK_USE_PLATFORM_WIN32_KHR VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, +#endif +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, #endif VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME, diff --git a/layers/generated/vk_layer_dispatch_table.h b/layers/generated/vk_layer_dispatch_table.h index 1a08f28f36d350479ab8eec4f0b3fd2e4e75de48..864ca554fbec686fac3338e318705708fcf2872f 100644 --- a/layers/generated/vk_layer_dispatch_table.h +++ b/layers/generated/vk_layer_dispatch_table.h @@ -278,6 +278,11 @@ typedef struct VkLayerInstanceDispatchTable_ { // ---- VK_NV_optical_flow extension commands PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; + + // ---- VK_OHOS_surface extension commands +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkCreateSurfaceOHOS CreateSurfaceOHOS; +#endif // VK_USE_PLATFORM_OHOS } VkLayerInstanceDispatchTable; // Device function pointer dispatch table @@ -1017,6 +1022,14 @@ typedef struct VkLayerDispatchTable_ { PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM; PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM; + // ---- VK_OHOS_external_memory extension commands +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkGetNativeBufferPropertiesOHOS GetNativeBufferPropertiesOHOS; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkGetMemoryNativeBufferOHOS GetMemoryNativeBufferOHOS; +#endif // VK_USE_PLATFORM_OHOS + // ---- VK_KHR_acceleration_structure extension commands PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; diff --git a/layers/generated/vk_safe_struct.cpp b/layers/generated/vk_safe_struct.cpp index f9c45bde7742defab65313101c1b256fe83e3c76..2cc6041ba9c3aed5dc8774db8975ec2cd22f9aae 100644 --- a/layers/generated/vk_safe_struct.cpp +++ b/layers/generated/vk_safe_struct.cpp @@ -57412,6 +57412,480 @@ void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(const safe shaderWarpsPerCore = copy_src->shaderWarpsPerCore; pNext = SafePnextCopy(copy_src->pNext); } +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct) : + sType(in_struct->sType), + flags(in_struct->flags), + window(in_struct->window) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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 = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCreateInfoOHOS& safe_VkSurfaceCreateInfoOHOS::operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + window = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCreateInfoOHOS::~safe_VkSurfaceCreateInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const VkSurfaceCreateInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + window = in_struct->window; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src) +{ + sType = copy_src->sType; + flags = copy_src->flags; + window = copy_src->window; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct) : + sType(in_struct->sType), + OHOSNativeBufferUsage(in_struct->OHOSNativeBufferUsage) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferUsageOHOS::~safe_VkNativeBufferUsageOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferUsageOHOS::initialize(const VkNativeBufferUsageOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + OHOSNativeBufferUsage = in_struct->OHOSNativeBufferUsage; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkNativeBufferUsageOHOS::initialize(const safe_VkNativeBufferUsageOHOS* copy_src) +{ + sType = copy_src->sType; + OHOSNativeBufferUsage = copy_src->OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct) : + sType(in_struct->sType), + allocationSize(in_struct->allocationSize), + memoryTypeBits(in_struct->memoryTypeBits) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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; + + if (pNext) + 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() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferPropertiesOHOS::initialize(const VkNativeBufferPropertiesOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkNativeBufferPropertiesOHOS::initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src) +{ + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS* in_struct) : + 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); +} + +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; + + if (pNext) + 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() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(const VkNativeBufferFormatPropertiesOHOS* in_struct) +{ + if (pNext) + 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); +} + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(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); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct) : + sType(in_struct->sType), + buffer(in_struct->buffer) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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 = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportNativeBufferInfoOHOS& safe_VkImportNativeBufferInfoOHOS::operator=(const safe_VkImportNativeBufferInfoOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportNativeBufferInfoOHOS::~safe_VkImportNativeBufferInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const VkImportNativeBufferInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src) +{ + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct) : + sType(in_struct->sType), + memory(in_struct->memory) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetNativeBufferInfoOHOS::~safe_VkMemoryGetNativeBufferInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const VkMemoryGetNativeBufferInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src) +{ + sType = copy_src->sType; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct) : + sType(in_struct->sType), + externalFormat(in_struct->externalFormat) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +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; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFormatOHOS::~safe_VkExternalFormatOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkExternalFormatOHOS::initialize(const VkExternalFormatOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormat = in_struct->externalFormat; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkExternalFormatOHOS::initialize(const safe_VkExternalFormatOHOS* copy_src) +{ + sType = copy_src->sType; + externalFormat = copy_src->externalFormat; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct) : sType(in_struct->sType), @@ -61064,6 +61538,20 @@ void *SafePnextCopy(const void *pNext) { safe_pNext = new safe_VkImportMetalSharedEventInfoEXT(reinterpret_cast(pNext)); break; #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + safe_pNext = new safe_VkNativeBufferUsageOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + safe_pNext = new safe_VkNativeBufferFormatPropertiesOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + safe_pNext = new safe_VkImportNativeBufferInfoOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + safe_pNext = new safe_VkExternalFormatOHOS(reinterpret_cast(pNext)); + break; +#endif // VK_USE_PLATFORM_OHOS #ifdef VK_USE_PLATFORM_WIN32_KHR case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast(pNext)); @@ -62434,6 +62922,20 @@ void FreePnextChain(const void *pNext) { delete reinterpret_cast(header); break; #endif // VK_USE_PLATFORM_METAL_EXT +#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 #ifdef VK_USE_PLATFORM_WIN32_KHR case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: delete reinterpret_cast(header); diff --git a/layers/generated/vk_safe_struct.h b/layers/generated/vk_safe_struct.h index 5410b4bb102a8975c4f038b7df7f23f3c248bc5c..05b2db5d6862727a7ff8b7e22add9adcdecf3253 100644 --- a/layers/generated/vk_safe_struct.h +++ b/layers/generated/vk_safe_struct.h @@ -12564,6 +12564,134 @@ struct safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const *ptr() const { 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); + 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); + void initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src); + VkSurfaceCreateInfoOHOS *ptr() { return reinterpret_cast(this); } + VkSurfaceCreateInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkNativeBufferUsageOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t OHOSNativeBufferUsage; + safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct); + 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); + void initialize(const safe_VkNativeBufferUsageOHOS* copy_src); + VkNativeBufferUsageOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferUsageOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkNativeBufferPropertiesOHOS { + VkStructureType sType; + void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; + safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct); + 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); + void initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src); + VkNativeBufferPropertiesOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferPropertiesOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +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); + 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); + void initialize(const safe_VkNativeBufferFormatPropertiesOHOS* copy_src); + VkNativeBufferFormatPropertiesOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferFormatPropertiesOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkImportNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + struct OH_NativeBuffer* buffer{}; + safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct); + 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); + void initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src); + VkImportNativeBufferInfoOHOS *ptr() { return reinterpret_cast(this); } + VkImportNativeBufferInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkMemoryGetNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct); + 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); + void initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src); + VkMemoryGetNativeBufferInfoOHOS *ptr() { return reinterpret_cast(this); } + VkMemoryGetNativeBufferInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkExternalFormatOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t externalFormat; + safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct); + 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); + void initialize(const safe_VkExternalFormatOHOS* copy_src); + 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/generated/vk_typemap_helper.h b/layers/generated/vk_typemap_helper.h index 482097bc2bde6f8b6ea33ca72b3bbbb909689b22..7d690227bc3c532914fbdac46c148fbdf136d448 100644 --- a/layers/generated/vk_typemap_helper.h +++ b/layers/generated/vk_typemap_helper.h @@ -6513,6 +6513,83 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCreateInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferUsageOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferUsageOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferFormatPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferFormatPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkImportNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkImportNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkMemoryGetNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkExternalFormatOHOS to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalFormatOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS // Map type VkAccelerationStructureGeometryTrianglesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; diff --git a/layers/generated/vk_validation_error_messages.h b/layers/generated/vk_validation_error_messages.h index 5f2f17afa129445d335a60f3526886a2d0958cc6..50e58c020547084c138479a4da665af14f6bd1c5 100644 --- a/layers/generated/vk_validation_error_messages.h +++ b/layers/generated/vk_validation_error_messages.h @@ -3776,6 +3776,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04602", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", "1.3-extensions"}, {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04603", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK", "1.3-extensions"}, {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-parameter", "If descriptorTypeCount is not 0, pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid VkDescriptorType values", "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 ANativeWindow", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-flags-parameter", "flags must be a valid combination of VkOpticalFlowExecuteFlagBitsNV values", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-pRegions-parameter", "If regionCount is not 0, pRegions must be a valid pointer to an array of regionCount VkRect2D structures", "1.3-extensions"}, @@ -11830,6 +11834,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCreateMicromapEXT-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateMicromapEXT-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkMicromapCreateInfoEXT structure", "1.3-extensions"}, {"VUID-vkCreateMicromapEXT-pMicromap-parameter", "pMicromap must be a valid pointer to a VkMicromapEXT 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-vkCreateOpticalFlowSessionNV-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkCreateOpticalFlowSessionNV-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateOpticalFlowSessionNV-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkOpticalFlowSessionCreateInfoNV structure", "1.3-extensions"}, diff --git a/scripts/common_codegen.py b/scripts/common_codegen.py index 9e4d60ac73dea74efa19e573f8b2fffa7f91b3db..8406167b360ead8624be199d3e51143d9d546aff 100644 --- a/scripts/common_codegen.py +++ b/scripts/common_codegen.py @@ -62,6 +62,7 @@ platform_dict = { 'provisional' : 'VK_ENABLE_BETA_EXTENSIONS', 'directfb' : 'VK_USE_PLATFORM_DIRECTFB_EXT', 'screen' : 'VK_USE_PLATFORM_SCREEN_QNX', + 'OHOS' : 'VK_USE_PLATFORM_OHOS_OPENHARMONY', } # diff --git a/spirv-tools.patch b/spirv-tools.patch new file mode 100644 index 0000000000000000000000000000000000000000..576666f5f761f3ec7ad2df67a7d16a701e6af715 --- /dev/null +++ b/spirv-tools.patch @@ -0,0 +1,16 @@ +diff --git a/BUILD.gn b/BUILD.gn +index b7e20b34..7b83378e 100644 +--- a/BUILD.gn ++++ b/BUILD.gn +@@ -12,8 +12,9 @@ + # See the License for the specific language governing permissions and + # limitations under the License. + +-import("//build_overrides/build.gni") +-import("//build_overrides/spirv_tools.gni") ++build_overrides_dir = "//third_party/Vulkan-ValidationLayers/build-openharmony/build_overrides" ++import("${build_overrides_dir}/build.gni") ++import("${build_overrides_dir}/spirv_tools.gni") + if (build_with_chromium) { + import("//testing/test.gni") + import("//third_party/protobuf/proto_library.gni")