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..ee58315d44531d4aeb950ee46d7cf3b725bf5b19 --- /dev/null +++ b/build-openharmony/BUILD.gn @@ -0,0 +1,335 @@ +# 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/ohos.gni") +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_2d" + 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..a42bb7053659bc68f9fdadf92b1fc50fdbeadcc3 --- /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..7715ffe6f9ad596a71ea17c896033311f42030d1 --- /dev/null +++ b/build-openharmony/build_overrides/spirv_tools.gni @@ -0,0 +1,21 @@ +# Copyright (c) 2019,2021 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# We are building inside Vulkan-ValidationLayers +spirv_tools_standalone = false + +# Paths to SPIRV-Tools dependencies +spirv_tools_googletest_dir = "//third_party/Vulkan-ValidationLayers/external/googletest" +spirv_tools_spirv_headers_dir = "//third_party/spirv-headers" +# 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..b1d5c3dcf2540fd7664b7a728bca9f0f5e6dd7e1 --- /dev/null +++ b/build-openharmony/build_overrides/vulkan_validation_layers.gni @@ -0,0 +1,25 @@ +# Copyright (c) 2019,2021 LunarG, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Paths to validation layer dependencies +vulkan_headers_dir = "//third_party//vulkan-headers" +vvl_spirv_tools_dir = "//third_party/spirv-tools" +vvl_glslang_dir = "../external/glslang/" + +# Subdirectories for generated files +vulkan_data_subdir = "" +vulkan_gen_subdir = "" + +# Build options +ozone_platform_x11 = false diff --git a/bundle.json b/bundle.json new file mode 100644 index 0000000000000000000000000000000000000000..5f0e12cb8f5302a3dbde9acb389ad652af8ea2a9 --- /dev/null +++ b/bundle.json @@ -0,0 +1,34 @@ +{ + "name": "@ohos/vulkan-validationlayers", + "description": "validationlayers", + "version": "4.0", + "license": "Apache-2.0", + "publishAs": "code-segment", + "segment": { + "destPath": "third_party/Vulkan-Validationlayers" + }, + "dirs": {}, + "scripts": {}, + "licensePath": "CODE_OF_CONDUCT.md", + "readmePath": { + "en": "README.md" + }, + "component": { + "name": "vulkan-validationlayers", + "subsystem": "thirdparty", + "syscap": [], + "features": [], + "adapted_system_type": ["standard"], + "rom": "1", + "ram": "1", + "deps": { + "components": [], + "third_party": [] + }, + "build": { + "sub_component": [], + "inner_kits": [], + "test": [] + } + } +} \ No newline at end of file diff --git a/layers/generated/best_practices.cpp b/layers/generated/best_practices.cpp index cdb6f3515fe1a7271c51da17c661a2cf2743d415..8b14eedaa54533ec76324c4dcde20975e088d335 100644 --- a/layers/generated/best_practices.cpp +++ b/layers/generated/best_practices.cpp @@ -3279,6 +3279,58 @@ void BestPractices::PostCallRecordGetFramebufferTilePropertiesQCOM( } } +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + ValidationStateTracker::PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkCreateSurfaceOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) { + ValidationStateTracker::PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkGetNativeBufferPropertiesOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void BestPractices::PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) { + ValidationStateTracker::PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); + if (result != VK_SUCCESS) { + static const std::vector error_codes = {VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY}; + static const std::vector success_codes = {}; + ValidateReturnCodes("vkGetMemoryNativeBufferOHOS", result, error_codes, success_codes); + } +} + +#endif // VK_USE_PLATFORM_OHOS + void BestPractices::PostCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/best_practices.h b/layers/generated/best_practices.h index f934dd9141d4f9c4f96d0df3147ce0610ef0c855..f5df642199d9aab27b5e31ba7a25d664fbb8958d 100644 --- a/layers/generated/best_practices.h +++ b/layers/generated/best_practices.h @@ -1902,6 +1902,40 @@ void PostCallRecordGetFramebufferTilePropertiesQCOM( VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) override; + + +#endif // VK_USE_PLATFORM_OHOS + void PostCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/chassis.cpp b/layers/generated/chassis.cpp index 739e8cf6211cb2bb459b6e665e20af804cf21472..74e2d1ff343f450ced56238b63b3f28601971095 100644 --- a/layers/generated/chassis.cpp +++ b/layers/generated/chassis.cpp @@ -14085,6 +14085,82 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( +#ifdef VK_USE_PLATFORM_OHOS + +VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); + bool skip = false; + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + } + VkResult result = DispatchCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + for (auto intercept : layer_data->object_dispatch) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); + } + return result; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + } + VkResult result = DispatchGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + bool skip = false; + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetMemoryNativeBufferOHOS]) { + auto lock = intercept->ReadLock(); + skip |= (const_cast(intercept))->PreCallValidateGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; + } + for (auto intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + } + VkResult result = DispatchGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + for (auto intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetMemoryNativeBufferOHOS]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); + } + return result; +} +#endif // VK_USE_PLATFORM_OHOS + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( VkDevice device, @@ -15363,6 +15439,15 @@ const layer_data::unordered_map name_to_funcptr_map {"vkCmdOpticalFlowExecuteNV", {kFuncTypeDev, (void*)CmdOpticalFlowExecuteNV}}, {"vkGetFramebufferTilePropertiesQCOM", {kFuncTypeDev, (void*)GetFramebufferTilePropertiesQCOM}}, {"vkGetDynamicRenderingTilePropertiesQCOM", {kFuncTypeDev, (void*)GetDynamicRenderingTilePropertiesQCOM}}, +#ifdef VK_USE_PLATFORM_OHOS + {"vkCreateSurfaceOHOS", {kFuncTypeInst, (void*)CreateSurfaceOHOS}}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetNativeBufferPropertiesOHOS", {kFuncTypeDev, (void*)GetNativeBufferPropertiesOHOS}}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {"vkGetMemoryNativeBufferOHOS", {kFuncTypeDev, (void*)GetMemoryNativeBufferOHOS}}, +#endif {"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}}, {"vkDestroyAccelerationStructureKHR", {kFuncTypeDev, (void*)DestroyAccelerationStructureKHR}}, {"vkCmdBuildAccelerationStructuresKHR", {kFuncTypeDev, (void*)CmdBuildAccelerationStructuresKHR}}, diff --git a/layers/generated/chassis.h b/layers/generated/chassis.h index 665b066ff2c210123a25084461ad8935133bbf6e..21d97571af951b920f460d9582ccce06225b9a80 100644 --- a/layers/generated/chassis.h +++ b/layers/generated/chassis.h @@ -3584,6 +3584,28 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( +#ifdef VK_USE_PLATFORM_OHOS + +VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif // VK_USE_PLATFORM_OHOS + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( VkDevice device, @@ -5984,6 +6006,21 @@ class ValidationObject { virtual bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const { return false; }; virtual void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {}; virtual void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) {}; +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { return false; }; + virtual void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {}; + virtual void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {}; +#endif +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const { return false; }; + virtual void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) {}; + virtual void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) {}; +#endif +#ifdef VK_USE_PLATFORM_OHOS + virtual bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const { return false; }; + virtual void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) {}; + virtual void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) {}; +#endif virtual bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { return false; }; virtual void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {}; virtual void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) {}; diff --git a/layers/generated/chassis_dispatch_helper.h b/layers/generated/chassis_dispatch_helper.h index 9d01d8e9f3c89f285b5c300b458f12c7f3ae7c64..15955caf59cee6795ef286c5b0a6c7366fc155ca 100644 --- a/layers/generated/chassis_dispatch_helper.h +++ b/layers/generated/chassis_dispatch_helper.h @@ -1421,6 +1421,12 @@ typedef enum InterceptId{ InterceptIdPreCallValidateGetDynamicRenderingTilePropertiesQCOM, InterceptIdPreCallRecordGetDynamicRenderingTilePropertiesQCOM, InterceptIdPostCallRecordGetDynamicRenderingTilePropertiesQCOM, + InterceptIdPreCallValidateGetNativeBufferPropertiesOHOS, + InterceptIdPreCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPostCallRecordGetNativeBufferPropertiesOHOS, + InterceptIdPreCallValidateGetMemoryNativeBufferOHOS, + InterceptIdPreCallRecordGetMemoryNativeBufferOHOS, + InterceptIdPostCallRecordGetMemoryNativeBufferOHOS, InterceptIdPreCallValidateCreateAccelerationStructureKHR, InterceptIdPreCallRecordCreateAccelerationStructureKHR, InterceptIdPostCallRecordCreateAccelerationStructureKHR, @@ -3068,6 +3074,18 @@ void ValidationObject::InitObjectDispatchVectors() { BUILD_DISPATCH_VECTOR(PreCallValidateGetDynamicRenderingTilePropertiesQCOM); BUILD_DISPATCH_VECTOR(PreCallRecordGetDynamicRenderingTilePropertiesQCOM); BUILD_DISPATCH_VECTOR(PostCallRecordGetDynamicRenderingTilePropertiesQCOM); +#ifdef VK_USE_PLATFORM_OHOS +#endif +#ifdef VK_USE_PLATFORM_OHOS + BUILD_DISPATCH_VECTOR(PreCallValidateGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetNativeBufferPropertiesOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetNativeBufferPropertiesOHOS); +#endif +#ifdef VK_USE_PLATFORM_OHOS + BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryNativeBufferOHOS); + BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryNativeBufferOHOS); +#endif BUILD_DISPATCH_VECTOR(PreCallValidateCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PreCallRecordCreateAccelerationStructureKHR); BUILD_DISPATCH_VECTOR(PostCallRecordCreateAccelerationStructureKHR); diff --git a/layers/generated/corechecks_optick_instrumentation.cpp b/layers/generated/corechecks_optick_instrumentation.cpp index 47c63e91e74ddc6418d594d4aa13c2025fdf0b9d..4d585b2cc601859675655dbf3d75e82dbb61376d 100644 --- a/layers/generated/corechecks_optick_instrumentation.cpp +++ b/layers/generated/corechecks_optick_instrumentation.cpp @@ -9360,6 +9360,60 @@ void CoreChecksOptickInstrumented::PostCallRecordGetDynamicRenderingTileProperti CoreChecks::PostCallRecordGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties, result); } +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); +} + +void CoreChecksOptickInstrumented::PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface, result); +} + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateGetNativeBufferPropertiesOHOS(device, buffer, pProperties); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties); +} + +void CoreChecksOptickInstrumented::PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordGetNativeBufferPropertiesOHOS(device, buffer, pProperties, result); +} + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +bool CoreChecksOptickInstrumented::PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const { + OPTICK_EVENT(); + auto result = CoreChecks::PreCallValidateGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + return result; +} + +void CoreChecksOptickInstrumented::PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { + OPTICK_EVENT(); + CoreChecks::PreCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer); +} + +void CoreChecksOptickInstrumented::PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) { + OPTICK_EVENT(); + CoreChecks::PostCallRecordGetMemoryNativeBufferOHOS(device, pInfo, pBuffer, result); +} + +#endif // VK_USE_PLATFORM_OHOS bool CoreChecksOptickInstrumented::PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { OPTICK_EVENT(); auto result = CoreChecks::PreCallValidateCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); diff --git a/layers/generated/corechecks_optick_instrumentation.h b/layers/generated/corechecks_optick_instrumentation.h index 335f5d9aa592e76da69725a320c7c0d3ba72608d..8be6f1414767d79c27508abd9903955ed41fa28c 100644 --- a/layers/generated/corechecks_optick_instrumentation.h +++ b/layers/generated/corechecks_optick_instrumentation.h @@ -1884,6 +1884,21 @@ class CoreChecksOptickInstrumented : public CoreChecks { bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) override; void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const override; + void PreCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) override; + void PostCallRecordCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) const override; + void PreCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) override; + void PostCallRecordGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + bool PreCallValidateGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) const override; + void PreCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) override; + void PostCallRecordGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer, VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const override; void PreCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) override; void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult result) override; diff --git a/layers/generated/layer_chassis_dispatch.cpp b/layers/generated/layer_chassis_dispatch.cpp index d996b50dfd6fa26e03e8c29efd4b10e141fbefc6..f807e8d4be7edb83f77c649e98170ef28af5af72 100644 --- a/layers/generated/layer_chassis_dispatch.cpp +++ b/layers/generated/layer_chassis_dispatch.cpp @@ -10904,6 +10904,64 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( return result; } +#ifdef VK_USE_PLATFORM_OHOS + +VkResult DispatchCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); + if (!wrap_handles) return layer_data->instance_dispatch_table.CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + VkResult result = layer_data->instance_dispatch_table.CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + if (VK_SUCCESS == result) { + *pSurface = layer_data->WrapNew(*pSurface); + } + return result; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +VkResult DispatchGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) +{ + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + VkResult result = layer_data->device_dispatch_table.GetNativeBufferPropertiesOHOS(device, buffer, pProperties); + + return result; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +VkResult DispatchGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) +{ + auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + safe_VkMemoryGetNativeBufferInfoOHOS var_local_pInfo; + safe_VkMemoryGetNativeBufferInfoOHOS *local_pInfo = NULL; + { + if (pInfo) { + local_pInfo = &var_local_pInfo; + local_pInfo->initialize(pInfo); + if (pInfo->memory) { + local_pInfo->memory = layer_data->Unwrap(pInfo->memory); + } + } + } + VkResult result = layer_data->device_dispatch_table.GetMemoryNativeBufferOHOS(device, (const VkMemoryGetNativeBufferInfoOHOS*)local_pInfo, pBuffer); + + return result; +} +#endif // VK_USE_PLATFORM_OHOS + VkResult DispatchCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/layer_chassis_dispatch.h b/layers/generated/layer_chassis_dispatch.h index 9f49fa7308d9ce5d63b1a10ed5746d33139ecb04..662e21cace9c522e9bd7883727e817b3ed9b345a 100644 --- a/layers/generated/layer_chassis_dispatch.h +++ b/layers/generated/layer_chassis_dispatch.h @@ -2702,6 +2702,25 @@ VkResult DispatchGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +VkResult DispatchGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif // VK_USE_PLATFORM_OHOS VkResult DispatchCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/object_tracker.cpp b/layers/generated/object_tracker.cpp index 8583cd9ab1fefb4765e34d09789d3b6818158e21..ff25f7090673e1cfaeb9ba445c441737f308a3e9 100644 --- a/layers/generated/object_tracker.cpp +++ b/layers/generated/object_tracker.cpp @@ -8057,6 +8057,60 @@ bool ObjectLifetimes::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( return skip; } +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const { + bool skip = false; + skip |= ValidateObject(instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateSurfaceOHOS-instance-parameter", kVUIDUndefined); + + return skip; +} + +void ObjectLifetimes::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + if (result != VK_SUCCESS) return; + CreateObject(*pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); + +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const { + bool skip = false; + skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); + + return skip; +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool ObjectLifetimes::PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const { + bool skip = false; + skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined); + if (pInfo) { + skip |= ValidateObject(pInfo->memory, kVulkanObjectTypeDeviceMemory, false, kVUIDUndefined, kVUIDUndefined); + } + + return skip; +} +#endif // VK_USE_PLATFORM_OHOS + bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/object_tracker.h b/layers/generated/object_tracker.h index 285e073322c9e1aed6b01b8f762cb0e04004ee37..3d6a40fb2fd600ed863b63809a3bc454cd98f456 100644 --- a/layers/generated/object_tracker.h +++ b/layers/generated/object_tracker.h @@ -3378,6 +3378,34 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const override; +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const override; +#endif // VK_USE_PLATFORM_OHOS bool PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/parameter_validation.cpp b/layers/generated/parameter_validation.cpp index e5d4586a79752fee195d58bdcacc7c005a01cfff..726a651edcd8a612341c8a386df5e6e02f239105 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_OHOS; const VkExternalSemaphoreHandleTypeFlags AllVkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR|VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA; const VkFenceImportFlags AllVkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT|VK_FENCE_IMPORT_TEMPORARY_BIT_KHR; const VkMemoryAllocateFlags AllVkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT|VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR|VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR; @@ -5372,6 +5372,22 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons // No Validation code for VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM structure members -- Covers VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType + // No Validation code for VkNativeBufferUsageOHOS structure members -- Covers VUID-VkNativeBufferUsageOHOS-sType-sType + + // No Validation code for VkNativeBufferFormatPropertiesOHOS structure members -- Covers VUID-VkNativeBufferFormatPropertiesOHOS-sType-sType + +#ifdef VK_USE_PLATFORM_OHOS + // Validation code for VkImportNativeBufferInfoOHOS structure members + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: { // Covers VUID-VkImportNativeBufferInfoOHOS-sType-sType + if (is_const_param) { + VkImportNativeBufferInfoOHOS *structure = (VkImportNativeBufferInfoOHOS *) header; + skip |= validate_required_pointer("VkImportNativeBufferInfoOHOS", "buffer", structure->buffer, kVUIDUndefined); + } + } break; +#endif // VK_USE_PLATFORM_OHOS + + // No Validation code for VkExternalFormatOHOS structure members -- Covers VUID-VkExternalFormatOHOS-sType-sType + // Validation code for VkWriteDescriptorSetAccelerationStructureKHR structure members case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { // Covers VUID-VkWriteDescriptorSetAccelerationStructureKHR-sType-sType if (is_const_param) { @@ -5886,9 +5902,9 @@ bool StatelessValidation::PreCallValidateAllocateMemory( skip |= validate_struct_type("vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true, "VUID-vkAllocateMemory-pAllocateInfo-parameter", "VUID-VkMemoryAllocateInfo-sType-sType"); if (pAllocateInfo != NULL) { - const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; + const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT }; - skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkExportMetalObjectCreateInfoEXT, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkImportMetalBufferInfoEXT, VkImportNativeBufferInfoOHOS, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique", false, true); } if (pAllocator != NULL) { @@ -6689,9 +6705,9 @@ bool StatelessValidation::PreCallValidateCreateImage( skip |= validate_struct_type("vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true, "VUID-vkCreateImage-pCreateInfo-parameter", "VUID-VkImageCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -8933,9 +8949,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); if (pImageFormatProperties != NULL) { - const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; - skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkNativeBufferUsageOHOS, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); } if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); return skip; @@ -9043,9 +9059,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversion( skip |= validate_struct_type("vkCreateSamplerYcbcrConversion", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; + const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS }; - skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversion", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOHOS", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversion", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); @@ -10618,9 +10634,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirements( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -10668,9 +10684,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirements( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirements", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -12133,9 +12149,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2 skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType"); if (pImageFormatProperties != NULL) { - const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; + const VkStructureType allowed_structs_VkImageFormatProperties2[] = { VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD }; - skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); + skip |= validate_struct_pnext("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties->pNext", "VkAndroidHardwareBufferUsageANDROID, VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, VkImageCompressionPropertiesEXT, VkNativeBufferUsageOHOS, VkSamplerYcbcrConversionImageFormatProperties, VkTextureLODGatherFormatPropertiesAMD", pImageFormatProperties->pNext, ARRAY_SIZE(allowed_structs_VkImageFormatProperties2), allowed_structs_VkImageFormatProperties2, GeneratedVulkanHeaderVersion, "VUID-VkImageFormatProperties2-pNext-pNext", "VUID-VkImageFormatProperties2-sType-unique", true, false); } if (!skip) skip |= manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); return skip; @@ -13343,9 +13359,9 @@ bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversionKHR( skip |= validate_struct_type("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, true, "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType"); if (pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID }; + const VkStructureType allowed_structs_VkSamplerYcbcrConversionCreateInfo[] = { VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS }; - skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->pNext", "VkExternalFormatANDROID, VkExternalFormatOHOS", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerYcbcrConversionCreateInfo), allowed_structs_VkSamplerYcbcrConversionCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", "VUID-VkSamplerYcbcrConversionCreateInfo-sType-unique", false, true); skip |= validate_ranged_enum("vkCreateSamplerYcbcrConversionKHR", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter"); @@ -14670,9 +14686,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirementsKHR( if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -14722,9 +14738,9 @@ bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirementsK if (pInfo->pCreateInfo != NULL) { - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pInfo->pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkGetDeviceImageSparseMemoryRequirementsKHR", "pInfo->pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pInfo->pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -18333,9 +18349,9 @@ bool StatelessValidation::PreCallValidateSetBufferCollectionImageConstraintsFUCH skip |= validate_struct_type("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo", ParameterName::IndexVector{ formatConstraintsIndex }), "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", &(pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo), VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, false, kVUIDUndefined, "VUID-VkImageCreateInfo-sType-sType"); - const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; + const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR }; - skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); + skip |= validate_struct_pnext("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.pNext", ParameterName::IndexVector{ formatConstraintsIndex }), "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExportMetalObjectCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageCompressionControlEXT, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR, VkImportMetalIOSurfaceInfoEXT, VkImportMetalTextureInfoEXT, VkOpticalFlowImageFormatInfoNV, VkVideoProfileListInfoKHR", pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique", false, true); skip |= validate_flags("vkSetBufferCollectionImageConstraintsFUCHSIA", ParameterName("pImageConstraintsInfo->pFormatConstraints[%i].imageCreateInfo.flags", ParameterName::IndexVector{ formatConstraintsIndex }), "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageConstraintsInfo->pFormatConstraints[formatConstraintsIndex].imageCreateInfo.flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter"); @@ -19819,6 +19835,95 @@ bool StatelessValidation::PreCallValidateGetDynamicRenderingTilePropertiesQCOM( +#ifdef VK_USE_PLATFORM_OHOS + +bool StatelessValidation::PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const { + bool skip = false; + if (!instance_extensions.vk_khr_surface) skip |= OutputExtensionError("vkCreateSurfaceOHOS", VK_KHR_SURFACE_EXTENSION_NAME); + if (!instance_extensions.vk_ohos_surface) skip |= OutputExtensionError("vkCreateSurfaceOHOS", VK_OHOS_SURFACE_EXTENSION_NAME); + skip |= validate_struct_type("vkCreateSurfaceOHOS", "pCreateInfo", "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", pCreateInfo, VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS, true, "VUID-vkCreateSurfaceOHOS-pCreateInfo-parameter", "VUID-VkSurfaceCreateInfoOHOS-sType-sType"); + if (pCreateInfo != NULL) + { + skip |= validate_struct_pnext("vkCreateSurfaceOHOS", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkSurfaceCreateInfoOHOS-pNext-pNext", kVUIDUndefined, false, true); + + skip |= validate_reserved_flags("vkCreateSurfaceOHOS", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkSurfaceCreateInfoOHOS-flags-zerobitmask"); + } + if (pAllocator != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnAllocation", reinterpret_cast(pAllocator->pfnAllocation), "VUID-VkAllocationCallbacks-pfnAllocation-00632"); + + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnReallocation", reinterpret_cast(pAllocator->pfnReallocation), "VUID-VkAllocationCallbacks-pfnReallocation-00633"); + + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnFree", reinterpret_cast(pAllocator->pfnFree), "VUID-VkAllocationCallbacks-pfnFree-00634"); + + if (pAllocator->pfnInternalAllocation != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnInternalFree", reinterpret_cast(pAllocator->pfnInternalFree), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + + } + + if (pAllocator->pfnInternalFree != NULL) + { + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pAllocator->pfnInternalAllocation", reinterpret_cast(pAllocator->pfnInternalAllocation), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635"); + + } + } + skip |= validate_required_pointer("vkCreateSurfaceOHOS", "pSurface", pSurface, "VUID-vkCreateSurfaceOHOS-pSurface-parameter"); + return skip; +} + +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +bool StatelessValidation::PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const { + bool skip = false; + if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError("vkGetNativeBufferPropertiesOHOS", VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME); + skip |= validate_required_pointer("vkGetNativeBufferPropertiesOHOS", "buffer", buffer, kVUIDUndefined); + skip |= validate_struct_type("vkGetNativeBufferPropertiesOHOS", "pProperties", "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS", pProperties, VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, true, kVUIDUndefined, kVUIDUndefined); + if (pProperties != NULL) + { + const VkStructureType allowed_structs_VkNativeBufferPropertiesOHOS[] = { VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS }; + + skip |= validate_struct_pnext("vkGetNativeBufferPropertiesOHOS", "pProperties->pNext", "VkNativeBufferFormatPropertiesOHOS", pProperties->pNext, ARRAY_SIZE(allowed_structs_VkNativeBufferPropertiesOHOS), allowed_structs_VkNativeBufferPropertiesOHOS, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, false); + } + return skip; +} + +bool StatelessValidation::PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const { + bool skip = false; + if (!IsExtEnabled(device_extensions.vk_khr_dedicated_allocation)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ext_queue_family_foreign)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_external_memory)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); + if (!IsExtEnabled(device_extensions.vk_ohos_external_memory)) skip |= OutputExtensionError("vkGetMemoryNativeBufferOHOS", VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME); + skip |= validate_struct_type("vkGetMemoryNativeBufferOHOS", "pInfo", "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS", pInfo, VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS, true, kVUIDUndefined, kVUIDUndefined); + if (pInfo != NULL) + { + skip |= validate_struct_pnext("vkGetMemoryNativeBufferOHOS", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined, false, true); + + skip |= validate_required_handle("vkGetMemoryNativeBufferOHOS", "pInfo->memory", pInfo->memory); + } + skip |= validate_required_pointer("vkGetMemoryNativeBufferOHOS", "pBuffer", pBuffer, kVUIDUndefined); + return skip; +} + +#endif // VK_USE_PLATFORM_OHOS + bool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/parameter_validation.h b/layers/generated/parameter_validation.h index 5635e454523fc04e037685cb4a65151fe7bd4519..1c2b73a77133de276f81ab5092eeedf48c53e682 100644 --- a/layers/generated/parameter_validation.h +++ b/layers/generated/parameter_validation.h @@ -2666,6 +2666,25 @@ bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const override; +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const override; +#endif +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) const override; +#endif +#ifdef VK_USE_PLATFORM_OHOS +bool PreCallValidateGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) const override; +#endif bool PreCallValidateCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/thread_safety.cpp b/layers/generated/thread_safety.cpp index 1fa91da829c5f9baf11d49cf7757da5752700eea..935bc39c8023c4e2177b3c34bcab9e8acdc2b1a2 100644 --- a/layers/generated/thread_safety.cpp +++ b/layers/generated/thread_safety.cpp @@ -9808,6 +9808,62 @@ void ThreadSafety::PostCallRecordGetDynamicRenderingTilePropertiesQCOM( FinishReadObjectParentInstance(device, "vkGetDynamicRenderingTilePropertiesQCOM"); } +#ifdef VK_USE_PLATFORM_OHOS + +void ThreadSafety::PreCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { + StartReadObjectParentInstance(instance, "vkCreateSurfaceOHOS"); +} + +void ThreadSafety::PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) { + FinishReadObjectParentInstance(instance, "vkCreateSurfaceOHOS"); + if (result == VK_SUCCESS) { + CreateObjectParentInstance(*pSurface); + } +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void ThreadSafety::PreCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) { + StartReadObjectParentInstance(device, "vkGetNativeBufferPropertiesOHOS"); +} + +void ThreadSafety::PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) { + FinishReadObjectParentInstance(device, "vkGetNativeBufferPropertiesOHOS"); +} + +void ThreadSafety::PreCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) { + StartReadObjectParentInstance(device, "vkGetMemoryNativeBufferOHOS"); +} + +void ThreadSafety::PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) { + FinishReadObjectParentInstance(device, "vkGetMemoryNativeBufferOHOS"); +} +#endif // VK_USE_PLATFORM_OHOS + void ThreadSafety::PreCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/thread_safety.h b/layers/generated/thread_safety.h index 95516a29fb581e80636ab5684f8270fdfee88c01..a89ef8c8823b9e0f88fc1bf175c7f8c8931be61b 100644 --- a/layers/generated/thread_safety.h +++ b/layers/generated/thread_safety.h @@ -6518,6 +6518,47 @@ void PostCallRecordGetDynamicRenderingTilePropertiesQCOM( VkTilePropertiesQCOM* pProperties, VkResult result) override; +#ifdef VK_USE_PLATFORM_OHOS + +void PreCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) override; + +void PostCallRecordCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + +void PreCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties) override; + +void PostCallRecordGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties, + VkResult result) override; + +void PreCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer) override; + +void PostCallRecordGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer, + VkResult result) override; +#endif // VK_USE_PLATFORM_OHOS + void PreCallRecordCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/layers/generated/vk_dispatch_table_helper.h b/layers/generated/vk_dispatch_table_helper.h index 1346f4ec2e83c973f005e895c961d84335622c0d..5dd6fd153fd5cc2204c32662d427ececb5b78fc0 100644 --- a/layers/generated/vk_dispatch_table_helper.h +++ b/layers/generated/vk_dispatch_table_helper.h @@ -595,6 +595,15 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubBindOpticalFlowSessionImageNV(VkDevice static VKAPI_ATTR void VKAPI_CALL StubCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; static VKAPI_ATTR VkResult VKAPI_CALL StubGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; }; +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL StubCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { return VK_SUCCESS; }; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL StubGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { return VK_SUCCESS; }; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { return VK_SUCCESS; }; +#endif // VK_USE_PLATFORM_OHOS static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; }; static VKAPI_ATTR void VKAPI_CALL StubDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { }; static VKAPI_ATTR void VKAPI_CALL StubCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { }; @@ -926,6 +935,7 @@ const layer_data::unordered_map api_extension_map { {"vkGetMemoryFdKHR", "VK_KHR_external_memory_fd"}, {"vkGetMemoryFdPropertiesKHR", "VK_KHR_external_memory_fd"}, {"vkGetMemoryHostPointerPropertiesEXT", "VK_EXT_external_memory_host"}, + {"vkGetMemoryNativeBufferOHOS", "VK_OHOS_external_memory"}, {"vkGetMemoryRemoteAddressNV", "VK_NV_external_memory_rdma"}, {"vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32"}, {"vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32"}, @@ -933,6 +943,7 @@ const layer_data::unordered_map api_extension_map { {"vkGetMemoryZirconHandleFUCHSIA", "VK_FUCHSIA_external_memory"}, {"vkGetMemoryZirconHandlePropertiesFUCHSIA", "VK_FUCHSIA_external_memory"}, {"vkGetMicromapBuildSizesEXT", "VK_EXT_opacity_micromap"}, + {"vkGetNativeBufferPropertiesOHOS", "VK_OHOS_external_memory"}, {"vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing"}, {"vkGetPerformanceParameterINTEL", "VK_INTEL_performance_query"}, {"vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties"}, @@ -1927,6 +1938,14 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->GetFramebufferTilePropertiesQCOM == nullptr) { table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)StubGetFramebufferTilePropertiesQCOM; } table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM) gpa(device, "vkGetDynamicRenderingTilePropertiesQCOM"); if (table->GetDynamicRenderingTilePropertiesQCOM == nullptr) { table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)StubGetDynamicRenderingTilePropertiesQCOM; } +#ifdef VK_USE_PLATFORM_OHOS + table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS) gpa(device, "vkGetNativeBufferPropertiesOHOS"); + if (table->GetNativeBufferPropertiesOHOS == nullptr) { table->GetNativeBufferPropertiesOHOS = (PFN_vkGetNativeBufferPropertiesOHOS)StubGetNativeBufferPropertiesOHOS; } +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + table->GetMemoryNativeBufferOHOS = (PFN_vkGetMemoryNativeBufferOHOS) gpa(device, "vkGetMemoryNativeBufferOHOS"); + if (table->GetMemoryNativeBufferOHOS == nullptr) { table->GetMemoryNativeBufferOHOS = (PFN_vkGetMemoryNativeBufferOHOS)StubGetMemoryNativeBufferOHOS; } +#endif // VK_USE_PLATFORM_OHOS table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR) gpa(device, "vkCreateAccelerationStructureKHR"); if (table->CreateAccelerationStructureKHR == nullptr) { table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)StubCreateAccelerationStructureKHR; } table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR) gpa(device, "vkDestroyAccelerationStructureKHR"); @@ -2226,4 +2245,8 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay #endif // VK_USE_PLATFORM_SCREEN_QNX table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV) gpa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); if (table->GetPhysicalDeviceOpticalFlowImageFormatsNV == nullptr) { table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)StubGetPhysicalDeviceOpticalFlowImageFormatsNV; } +#ifdef VK_USE_PLATFORM_OHOS + table->CreateSurfaceOHOS = (PFN_vkCreateSurfaceOHOS) gpa(instance, "vkCreateSurfaceOHOS"); + if (table->CreateSurfaceOHOS == nullptr) { table->CreateSurfaceOHOS = (PFN_vkCreateSurfaceOHOS)StubCreateSurfaceOHOS; } +#endif // VK_USE_PLATFORM_OHOS } diff --git a/layers/generated/vk_enum_string_helper.h b/layers/generated/vk_enum_string_helper.h index 005cc21ea816437fcc617b3fd74439845ebbebda..40af766c7f27b5f1fa116bea580bdaa454a8bc17 100644 --- a/layers/generated/vk_enum_string_helper.h +++ b/layers/generated/vk_enum_string_helper.h @@ -493,6 +493,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"; case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS"; case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"; case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: @@ -631,6 +633,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT"; case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: return "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT"; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + return "VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS"; case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"; case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: @@ -673,6 +677,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"; + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: + return "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS"; case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: return "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"; case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: @@ -709,6 +715,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"; case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS"; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS"; + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + return "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS"; case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV"; case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: @@ -5274,6 +5288,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMe return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OHOS: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OHOS"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: @@ -6853,6 +6869,8 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExterna return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OHOS: + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OHOS_NATIVE_BUFFER_BIT_OHOS"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: diff --git a/layers/generated/vk_extension_helper.h b/layers/generated/vk_extension_helper.h index c34c7e9cade1fa54dfa5469e624699a48627a40b..f0c1f2e3b6a04839c3775dd9a092b0f51fb2c802 100644 --- a/layers/generated/vk_extension_helper.h +++ b/layers/generated/vk_extension_helper.h @@ -105,6 +105,7 @@ struct InstanceExtensions { ExtEnabled vk_mvk_macos_surface{kNotEnabled}; ExtEnabled vk_nn_vi_surface{kNotEnabled}; ExtEnabled vk_nv_external_memory_capabilities{kNotEnabled}; + ExtEnabled vk_ohos_surface{kNotEnabled}; ExtEnabled vk_qnx_screen_surface{kNotEnabled}; struct InstanceReq { @@ -212,6 +213,10 @@ struct InstanceExtensions { {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, #endif {VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_nv_external_memory_capabilities, {})}, +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_ohos_surface, {{ + {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, +#endif #ifdef VK_USE_PLATFORM_SCREEN_QNX {VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, InstanceInfo(&InstanceExtensions::vk_qnx_screen_surface, {{ {&InstanceExtensions::vk_khr_surface, VK_KHR_SURFACE_EXTENSION_NAME}}})}, @@ -359,6 +364,9 @@ static const std::set kInstanceExtensionNames = { VK_NN_VI_SURFACE_EXTENSION_NAME, #endif VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_SURFACE_EXTENSION_NAME, +#endif #ifdef VK_USE_PLATFORM_SCREEN_QNX VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, #endif @@ -628,6 +636,7 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_nv_viewport_array2{kNotEnabled}; ExtEnabled vk_nv_viewport_swizzle{kNotEnabled}; ExtEnabled vk_nv_win32_keyed_mutex{kNotEnabled}; + ExtEnabled vk_ohos_external_memory{kNotEnabled}; ExtEnabled vk_qcom_fragment_density_map_offset{kNotEnabled}; ExtEnabled vk_qcom_image_processing{kNotEnabled}; ExtEnabled vk_qcom_render_pass_shader_resolve{kNotEnabled}; @@ -1200,6 +1209,13 @@ struct DeviceExtensions : public InstanceExtensions { #ifdef VK_USE_PLATFORM_WIN32_KHR {VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_nv_win32_keyed_mutex, {{ {&DeviceExtensions::vk_nv_external_memory_win32, VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME}}})}, +#endif +#ifdef VK_USE_PLATFORM_OHOS + {VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ohos_external_memory, {{ + {&DeviceExtensions::vk_khr_sampler_ycbcr_conversion, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME}, + {&DeviceExtensions::vk_khr_external_memory, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME}, + {&DeviceExtensions::vk_ext_queue_family_foreign, VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME}, + {&DeviceExtensions::vk_khr_dedicated_allocation, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME}}})}, #endif {VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_qcom_fragment_density_map_offset, {{ {&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}, @@ -1661,6 +1677,9 @@ static const std::set kDeviceExtensionNames = { VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, #ifdef VK_USE_PLATFORM_WIN32_KHR VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, +#endif +#ifdef VK_USE_PLATFORM_OHOS + VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME, #endif VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME, VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME, diff --git a/layers/generated/vk_layer_dispatch_table.h b/layers/generated/vk_layer_dispatch_table.h index 1a08f28f36d350479ab8eec4f0b3fd2e4e75de48..864ca554fbec686fac3338e318705708fcf2872f 100644 --- a/layers/generated/vk_layer_dispatch_table.h +++ b/layers/generated/vk_layer_dispatch_table.h @@ -278,6 +278,11 @@ typedef struct VkLayerInstanceDispatchTable_ { // ---- VK_NV_optical_flow extension commands PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; + + // ---- VK_OHOS_surface extension commands +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkCreateSurfaceOHOS CreateSurfaceOHOS; +#endif // VK_USE_PLATFORM_OHOS } VkLayerInstanceDispatchTable; // Device function pointer dispatch table @@ -1017,6 +1022,14 @@ typedef struct VkLayerDispatchTable_ { PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM; PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM; + // ---- VK_OHOS_external_memory extension commands +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkGetNativeBufferPropertiesOHOS GetNativeBufferPropertiesOHOS; +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS + PFN_vkGetMemoryNativeBufferOHOS GetMemoryNativeBufferOHOS; +#endif // VK_USE_PLATFORM_OHOS + // ---- VK_KHR_acceleration_structure extension commands PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; diff --git a/layers/generated/vk_safe_struct.cpp b/layers/generated/vk_safe_struct.cpp index f9c45bde7742defab65313101c1b256fe83e3c76..2cc6041ba9c3aed5dc8774db8975ec2cd22f9aae 100644 --- a/layers/generated/vk_safe_struct.cpp +++ b/layers/generated/vk_safe_struct.cpp @@ -57412,6 +57412,480 @@ void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(const safe shaderWarpsPerCore = copy_src->shaderWarpsPerCore; pNext = SafePnextCopy(copy_src->pNext); } +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct) : + sType(in_struct->sType), + flags(in_struct->flags), + window(in_struct->window) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS() : + sType(VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS), + pNext(nullptr), + flags(), + window(nullptr) +{} + +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src) +{ + sType = copy_src.sType; + flags = copy_src.flags; + window = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCreateInfoOHOS& safe_VkSurfaceCreateInfoOHOS::operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + window = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCreateInfoOHOS::~safe_VkSurfaceCreateInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const VkSurfaceCreateInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + window = in_struct->window; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkSurfaceCreateInfoOHOS::initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src) +{ + sType = copy_src->sType; + flags = copy_src->flags; + window = copy_src->window; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct) : + sType(in_struct->sType), + OHOSNativeBufferUsage(in_struct->OHOSNativeBufferUsage) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS() : + sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS), + pNext(nullptr), + OHOSNativeBufferUsage() +{} + +safe_VkNativeBufferUsageOHOS::safe_VkNativeBufferUsageOHOS(const safe_VkNativeBufferUsageOHOS& copy_src) +{ + sType = copy_src.sType; + OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferUsageOHOS& safe_VkNativeBufferUsageOHOS::operator=(const safe_VkNativeBufferUsageOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + OHOSNativeBufferUsage = copy_src.OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferUsageOHOS::~safe_VkNativeBufferUsageOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferUsageOHOS::initialize(const VkNativeBufferUsageOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + OHOSNativeBufferUsage = in_struct->OHOSNativeBufferUsage; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkNativeBufferUsageOHOS::initialize(const safe_VkNativeBufferUsageOHOS* copy_src) +{ + sType = copy_src->sType; + OHOSNativeBufferUsage = copy_src->OHOSNativeBufferUsage; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct) : + sType(in_struct->sType), + allocationSize(in_struct->allocationSize), + memoryTypeBits(in_struct->memoryTypeBits) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS() : + sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS), + pNext(nullptr), + allocationSize(), + memoryTypeBits() +{} + +safe_VkNativeBufferPropertiesOHOS::safe_VkNativeBufferPropertiesOHOS(const safe_VkNativeBufferPropertiesOHOS& copy_src) +{ + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferPropertiesOHOS& safe_VkNativeBufferPropertiesOHOS::operator=(const safe_VkNativeBufferPropertiesOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferPropertiesOHOS::~safe_VkNativeBufferPropertiesOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferPropertiesOHOS::initialize(const VkNativeBufferPropertiesOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkNativeBufferPropertiesOHOS::initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src) +{ + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS* in_struct) : + sType(in_struct->sType), + format(in_struct->format), + externalFormat(in_struct->externalFormat), + formatFeatures(in_struct->formatFeatures), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS() : + sType(VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS), + pNext(nullptr), + format(), + externalFormat(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() +{} + +safe_VkNativeBufferFormatPropertiesOHOS::safe_VkNativeBufferFormatPropertiesOHOS(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src) +{ + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkNativeBufferFormatPropertiesOHOS& safe_VkNativeBufferFormatPropertiesOHOS::operator=(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkNativeBufferFormatPropertiesOHOS::~safe_VkNativeBufferFormatPropertiesOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(const VkNativeBufferFormatPropertiesOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + externalFormat = in_struct->externalFormat; + formatFeatures = in_struct->formatFeatures; + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkNativeBufferFormatPropertiesOHOS::initialize(const safe_VkNativeBufferFormatPropertiesOHOS* copy_src) +{ + sType = copy_src->sType; + format = copy_src->format; + externalFormat = copy_src->externalFormat; + formatFeatures = copy_src->formatFeatures; + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct) : + sType(in_struct->sType), + buffer(in_struct->buffer) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS() : + sType(VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS), + pNext(nullptr), + buffer(nullptr) +{} + +safe_VkImportNativeBufferInfoOHOS::safe_VkImportNativeBufferInfoOHOS(const safe_VkImportNativeBufferInfoOHOS& copy_src) +{ + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportNativeBufferInfoOHOS& safe_VkImportNativeBufferInfoOHOS::operator=(const safe_VkImportNativeBufferInfoOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportNativeBufferInfoOHOS::~safe_VkImportNativeBufferInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const VkImportNativeBufferInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkImportNativeBufferInfoOHOS::initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src) +{ + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct) : + sType(in_struct->sType), + memory(in_struct->memory) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS() : + sType(VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS), + pNext(nullptr), + memory() +{} + +safe_VkMemoryGetNativeBufferInfoOHOS::safe_VkMemoryGetNativeBufferInfoOHOS(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src) +{ + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetNativeBufferInfoOHOS& safe_VkMemoryGetNativeBufferInfoOHOS::operator=(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetNativeBufferInfoOHOS::~safe_VkMemoryGetNativeBufferInfoOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const VkMemoryGetNativeBufferInfoOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkMemoryGetNativeBufferInfoOHOS::initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src) +{ + sType = copy_src->sType; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS + + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct) : + sType(in_struct->sType), + externalFormat(in_struct->externalFormat) +{ + pNext = SafePnextCopy(in_struct->pNext); +} + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS() : + sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS), + pNext(nullptr), + externalFormat() +{} + +safe_VkExternalFormatOHOS::safe_VkExternalFormatOHOS(const safe_VkExternalFormatOHOS& copy_src) +{ + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalFormatOHOS& safe_VkExternalFormatOHOS::operator=(const safe_VkExternalFormatOHOS& copy_src) +{ + if (©_src == this) return *this; + + if (pNext) + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFormatOHOS::~safe_VkExternalFormatOHOS() +{ + if (pNext) + FreePnextChain(pNext); +} + +void safe_VkExternalFormatOHOS::initialize(const VkExternalFormatOHOS* in_struct) +{ + if (pNext) + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormat = in_struct->externalFormat; + pNext = SafePnextCopy(in_struct->pNext); +} + +void safe_VkExternalFormatOHOS::initialize(const safe_VkExternalFormatOHOS* copy_src) +{ + sType = copy_src->sType; + externalFormat = copy_src->externalFormat; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_OHOS + safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct) : sType(in_struct->sType), @@ -61064,6 +61538,20 @@ void *SafePnextCopy(const void *pNext) { safe_pNext = new safe_VkImportMetalSharedEventInfoEXT(reinterpret_cast(pNext)); break; #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + safe_pNext = new safe_VkNativeBufferUsageOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + safe_pNext = new safe_VkNativeBufferFormatPropertiesOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + safe_pNext = new safe_VkImportNativeBufferInfoOHOS(reinterpret_cast(pNext)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + safe_pNext = new safe_VkExternalFormatOHOS(reinterpret_cast(pNext)); + break; +#endif // VK_USE_PLATFORM_OHOS #ifdef VK_USE_PLATFORM_WIN32_KHR case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast(pNext)); @@ -62434,6 +62922,20 @@ void FreePnextChain(const void *pNext) { delete reinterpret_cast(header); break; #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_OHOS + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_OHOS #ifdef VK_USE_PLATFORM_WIN32_KHR case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: delete reinterpret_cast(header); diff --git a/layers/generated/vk_safe_struct.h b/layers/generated/vk_safe_struct.h index 5410b4bb102a8975c4f038b7df7f23f3c248bc5c..05b2db5d6862727a7ff8b7e22add9adcdecf3253 100644 --- a/layers/generated/vk_safe_struct.h +++ b/layers/generated/vk_safe_struct.h @@ -12564,6 +12564,134 @@ struct safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const *ptr() const { return reinterpret_cast(this); } }; +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkSurfaceCreateInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkSurfaceCreateFlagsOHOS flags; + OHNativeWindow* window{}; + safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct); + safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS& operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS(); + ~safe_VkSurfaceCreateInfoOHOS(); + void initialize(const VkSurfaceCreateInfoOHOS* in_struct); + void initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src); + VkSurfaceCreateInfoOHOS *ptr() { return reinterpret_cast(this); } + VkSurfaceCreateInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkNativeBufferUsageOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t OHOSNativeBufferUsage; + safe_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS* in_struct); + safe_VkNativeBufferUsageOHOS(const safe_VkNativeBufferUsageOHOS& copy_src); + safe_VkNativeBufferUsageOHOS& operator=(const safe_VkNativeBufferUsageOHOS& copy_src); + safe_VkNativeBufferUsageOHOS(); + ~safe_VkNativeBufferUsageOHOS(); + void initialize(const VkNativeBufferUsageOHOS* in_struct); + void initialize(const safe_VkNativeBufferUsageOHOS* copy_src); + VkNativeBufferUsageOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferUsageOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkNativeBufferPropertiesOHOS { + VkStructureType sType; + void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; + safe_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS* in_struct); + safe_VkNativeBufferPropertiesOHOS(const safe_VkNativeBufferPropertiesOHOS& copy_src); + safe_VkNativeBufferPropertiesOHOS& operator=(const safe_VkNativeBufferPropertiesOHOS& copy_src); + safe_VkNativeBufferPropertiesOHOS(); + ~safe_VkNativeBufferPropertiesOHOS(); + void initialize(const VkNativeBufferPropertiesOHOS* in_struct); + void initialize(const safe_VkNativeBufferPropertiesOHOS* copy_src); + VkNativeBufferPropertiesOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferPropertiesOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkNativeBufferFormatPropertiesOHOS { + VkStructureType sType; + void* pNext{}; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + safe_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS* in_struct); + safe_VkNativeBufferFormatPropertiesOHOS(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src); + safe_VkNativeBufferFormatPropertiesOHOS& operator=(const safe_VkNativeBufferFormatPropertiesOHOS& copy_src); + safe_VkNativeBufferFormatPropertiesOHOS(); + ~safe_VkNativeBufferFormatPropertiesOHOS(); + void initialize(const VkNativeBufferFormatPropertiesOHOS* in_struct); + void initialize(const safe_VkNativeBufferFormatPropertiesOHOS* copy_src); + VkNativeBufferFormatPropertiesOHOS *ptr() { return reinterpret_cast(this); } + VkNativeBufferFormatPropertiesOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkImportNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + struct OH_NativeBuffer* buffer{}; + safe_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS* in_struct); + safe_VkImportNativeBufferInfoOHOS(const safe_VkImportNativeBufferInfoOHOS& copy_src); + safe_VkImportNativeBufferInfoOHOS& operator=(const safe_VkImportNativeBufferInfoOHOS& copy_src); + safe_VkImportNativeBufferInfoOHOS(); + ~safe_VkImportNativeBufferInfoOHOS(); + void initialize(const VkImportNativeBufferInfoOHOS* in_struct); + void initialize(const safe_VkImportNativeBufferInfoOHOS* copy_src); + VkImportNativeBufferInfoOHOS *ptr() { return reinterpret_cast(this); } + VkImportNativeBufferInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkMemoryGetNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + safe_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS* in_struct); + safe_VkMemoryGetNativeBufferInfoOHOS(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src); + safe_VkMemoryGetNativeBufferInfoOHOS& operator=(const safe_VkMemoryGetNativeBufferInfoOHOS& copy_src); + safe_VkMemoryGetNativeBufferInfoOHOS(); + ~safe_VkMemoryGetNativeBufferInfoOHOS(); + void initialize(const VkMemoryGetNativeBufferInfoOHOS* in_struct); + void initialize(const safe_VkMemoryGetNativeBufferInfoOHOS* copy_src); + VkMemoryGetNativeBufferInfoOHOS *ptr() { return reinterpret_cast(this); } + VkMemoryGetNativeBufferInfoOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + +#ifdef VK_USE_PLATFORM_OHOS +struct safe_VkExternalFormatOHOS { + VkStructureType sType; + void* pNext{}; + uint64_t externalFormat; + safe_VkExternalFormatOHOS(const VkExternalFormatOHOS* in_struct); + safe_VkExternalFormatOHOS(const safe_VkExternalFormatOHOS& copy_src); + safe_VkExternalFormatOHOS& operator=(const safe_VkExternalFormatOHOS& copy_src); + safe_VkExternalFormatOHOS(); + ~safe_VkExternalFormatOHOS(); + void initialize(const VkExternalFormatOHOS* in_struct); + void initialize(const safe_VkExternalFormatOHOS* copy_src); + VkExternalFormatOHOS *ptr() { return reinterpret_cast(this); } + VkExternalFormatOHOS const *ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_OHOS + struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { VkStructureType sType; const void* pNext{}; diff --git a/layers/generated/vk_typemap_helper.h b/layers/generated/vk_typemap_helper.h index 482097bc2bde6f8b6ea33ca72b3bbbb909689b22..7d690227bc3c532914fbdac46c148fbdf136d448 100644 --- a/layers/generated/vk_typemap_helper.h +++ b/layers/generated/vk_typemap_helper.h @@ -6513,6 +6513,83 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCreateInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferUsageOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferUsageOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkNativeBufferFormatPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkNativeBufferFormatPropertiesOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkImportNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkImportNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkMemoryGetNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetNativeBufferInfoOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS +#ifdef VK_USE_PLATFORM_OHOS +// Map type VkExternalFormatOHOS to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalFormatOHOS Type; +}; + +#endif // VK_USE_PLATFORM_OHOS // Map type VkAccelerationStructureGeometryTrianglesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; diff --git a/layers/generated/vk_validation_error_messages.h b/layers/generated/vk_validation_error_messages.h index 5f2f17afa129445d335a60f3526886a2d0958cc6..50e58c020547084c138479a4da665af14f6bd1c5 100644 --- a/layers/generated/vk_validation_error_messages.h +++ b/layers/generated/vk_validation_error_messages.h @@ -3776,6 +3776,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04602", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", "1.3-extensions"}, {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-04603", "pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK", "1.3-extensions"}, {"VUID-VkMutableDescriptorTypeListEXT-pDescriptorTypes-parameter", "If descriptorTypeCount is not 0, pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid VkDescriptorType values", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-sType-sType", "sType must be VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", "1.3-extensions"}, + {"VUID-VkSurfaceCreateInfoOHOS-window-01248", "window must point to a valid OHOS ANativeWindow", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-flags-parameter", "flags must be a valid combination of VkOpticalFlowExecuteFlagBitsNV values", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkOpticalFlowExecuteInfoNV-pRegions-parameter", "If regionCount is not 0, pRegions must be a valid pointer to an array of regionCount VkRect2D structures", "1.3-extensions"}, @@ -11830,6 +11834,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCreateMicromapEXT-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateMicromapEXT-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkMicromapCreateInfoEXT structure", "1.3-extensions"}, {"VUID-vkCreateMicromapEXT-pMicromap-parameter", "pMicromap must be a valid pointer to a VkMicromapEXT handle", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-instance-parameter", "instance must be a valid VkInstance handle", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkSurfaceCreateInfoOHOS structure", "1.3-extensions"}, + {"VUID-vkCreateSurfaceOHOS-pSurface-parameter", "pSurface must be a valid pointer to a VkSurfaceKHR handle", "1.3-extensions"}, {"VUID-vkCreateOpticalFlowSessionNV-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkCreateOpticalFlowSessionNV-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", "1.3-extensions"}, {"VUID-vkCreateOpticalFlowSessionNV-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkOpticalFlowSessionCreateInfoNV structure", "1.3-extensions"}, diff --git a/patches/patches.json b/patches/patches.json new file mode 100644 index 0000000000000000000000000000000000000000..c72f1c11502c303b501bf9713f7a49483345f458 --- /dev/null +++ b/patches/patches.json @@ -0,0 +1,14 @@ +{ + "patches": [ + { + "project":"graphic_graphic_2d", + "path":"foundation/graphic/graphic_2d", + "pr_url":"https://gitee.com/openharmony/graphic_graphic_2d/pulls/7262" + }, + { + "project":"third_party_spirv-tools", + "path":"third_party/spirv-tools", + "pr_url":"https://gitee.com/openharmony/third_party_spirv-tools/pulls/22" + } + ] +} \ No newline at end of file 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', } #