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/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..3598b92d5eec8f38377551ae49cd0535fdb4943f --- /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 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..a6457ce8fba73477d2dd95cad7eeb2a3a4357cd2 --- /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 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..9a1be6c8011b5b59c8dd85b1b15cd4a76cc8e850 --- /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 cdb6f3515fe1a7271c51da17c661a2cf2743d415..bb58012ba35293705b015d852d2ed30cde8823f1 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 f934dd9141d4f9c4f96d0df3147ce0610ef0c855..47b963f349580afdfdb43085533bb62aee57caa8 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 739e8cf6211cb2bb459b6e665e20af804cf21472..094826193927f3fb01182bc8e8ab5f80107a937f 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 665b066ff2c210123a25084461ad8935133bbf6e..2283ed12f9ec0fdb633650f48c69450e0bcaf4d9 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 9d01d8e9f3c89f285b5c300b458f12c7f3ae7c64..52b224106ab519cc80615c3275c0d549f0d8d3a4 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 47c63e91e74ddc6418d594d4aa13c2025fdf0b9d..4f1f02cc73f228b495dd05b2a5722a492dcd7c8f 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 335f5d9aa592e76da69725a320c7c0d3ba72608d..e1b7acc352788d863287e619b8cc5147028d61ba 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 d996b50dfd6fa26e03e8c29efd4b10e141fbefc6..82adc8c1c0bad729136ef00bb3255f315a7ee8c9 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 9f49fa7308d9ce5d63b1a10ed5746d33139ecb04..7828f9c99c7e653d6c6c8de8f1f93a11ba0b2a6a 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 8583cd9ab1fefb4765e34d09789d3b6818158e21..a11a6d5bac8036d333593424dee3ba63b1d3a2e8 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 285e073322c9e1aed6b01b8f762cb0e04004ee37..f9fb1a960c989312ded5bf46b6b243086def6f3e 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 e5d4586a79752fee195d58bdcacc7c005a01cfff..5e651c7d7c79f9e0033706b790bf5d94c2c3a43d 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 5635e454523fc04e037685cb4a65151fe7bd4519..a3f2c333a075c3a483ed4d50c19559fe157c4511 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 1fa91da829c5f9baf11d49cf7757da5752700eea..95a9e46552e8548528cec0b5eb6526ec7becaf77 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 95516a29fb581e80636ab5684f8270fdfee88c01..aeb47b3733ae347dc75d3d8a8e48550a774ff16b 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 1346f4ec2e83c973f005e895c961d84335622c0d..6b4e2d3a3c50a97ac900a26f294cf5a6266f9c35 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 005cc21ea816437fcc617b3fd74439845ebbebda..68f1c2669d3fecbec4f227f41eee35a4ec5699f4 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 c34c7e9cade1fa54dfa5469e624699a48627a40b..ad779770096999df36b9be6986cb61a371cc4d77 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 1a08f28f36d350479ab8eec4f0b3fd2e4e75de48..187e86d805553e23802b91a5defe8db5458c16bd 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 f9c45bde7742defab65313101c1b256fe83e3c76..d89304886584ab0f4f797cfacf34407b064af790 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 5410b4bb102a8975c4f038b7df7f23f3c248bc5c..0780b8a0cba5b4a0e15acb5662aa77070ed1c39d 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 482097bc2bde6f8b6ea33ca72b3bbbb909689b22..754b3f1cbbe3e2a663b421f162925170a67ceb24 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 5f2f17afa129445d335a60f3526886a2d0958cc6..ea04f7935dc6f6bf40fcfe1cbd684f876bb1b669 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 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")