[vulkan] Merge in tag sdk-1.2.148.0 from upstream.
Bug: 60761
Change-Id: I8719b30995b8965bbafdf37afc66ee162f9bea8d
diff --git a/BUILD.gn b/BUILD.gn
index 756cd3e..2b01f7e 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -15,10 +15,6 @@
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)
-
vulkan_undefine_configs = []
if (is_win) {
vulkan_undefine_configs += [
@@ -27,26 +23,15 @@
]
}
-vulkan_gen_dir = "$target_gen_dir/$vulkan_gen_subdir"
-raw_vulkan_gen_dir = rebase_path(vulkan_gen_dir, root_build_dir)
-
vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir"
-raw_vulkan_data_dir = rebase_path(vulkan_data_dir, root_build_dir)
-raw_root_out_dir = rebase_path(root_out_dir, root_build_dir)
-
-# This special action is needed to remove old VVL objects that are now renamed.
-action("vulkan_clean_old_validation_layer_objects") {
- script = "build-gn/remove_files.py"
-
- # inputs is a (random) new file since the vvl roll, used to ensure the cleanup is done only once
- inputs = [ "layers/gpu_validation.cpp" ]
- outputs = [ "$vulkan_gen_dir/old_vvl_files_are_removed" ]
- args = [
- "$raw_vulkan_gen_dir/old_vvl_files_are_removed",
- "$raw_root_out_dir/libVkLayer*",
- "$raw_root_out_dir/VkLayer*",
- "$raw_vulkan_data_dir/VkLayer*.json",
+config("generated_layers_config") {
+ cflags = [
+ "-Wno-newline-eof",
+ "-Wno-missing-field-initializers",
+ "-Wno-unused-const-variable",
+ "-Wno-sign-compare",
+ "-Wno-conversion",
]
}
@@ -173,10 +158,12 @@
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_clean_old_validation_layer_objects" ]
- json_names = [ "VkLayer_khronos_validation.json" ]
- sources = [ "$vulkan_headers_dir/include/vulkan/vulkan_core.h" ]
+ 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" ]
@@ -186,7 +173,9 @@
rebase_path("layers/json", root_build_dir),
rebase_path(vulkan_data_dir, root_build_dir),
] + rebase_path(sources, root_build_dir)
-
+ if (is_fuchsia) {
+ args += [ "--no-path-prefix" ]
+ }
# The layer JSON files are part of the necessary data deps.
data = outputs
}
@@ -210,11 +199,24 @@
"layers/vk_layer_utils.cpp",
"layers/vk_layer_utils.h",
]
- public_configs = [ ":vulkan_internal_config" ]
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [ "//build/config/compiler:no_chromium_code" ]
+ if (is_fuchsia) {
+ sources += [ "layers/vk_layer_utils_minimal.cpp", "layers/vk_layer_utils_minimal.h" ]
+ }
+ public_configs = [
+ "$vulkan_headers_dir:vulkan_headers_config",
+ ":vulkan_internal_config",
+ ]
public_deps = [ "$vulkan_headers_dir:vulkan_headers" ]
+
configs -= vulkan_undefine_configs
+ if (is_fuchsia) {
+ public_deps += [
+ "//third_party/Vulkan-Loader:dlopen_fuchsia",
+ ]
+ } else {
+ configs -= [ "//build/config/compiler:chromium_code" ]
+ configs += [ "//build/config/compiler:no_chromium_code" ]
+ }
}
config("vulkan_core_validation_config") {
@@ -239,17 +241,28 @@
}
}
+if (is_fuchsia) {
+ library_type = "loadable_module"
+} else {
+ library_type = "shared_library"
+}
+
foreach(layer_info, layers) {
name = layer_info[0]
- shared_library("VkLayer_$name") {
+ target(library_type, "VkLayer_$name") {
defines = []
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [ "//build/config/compiler:no_chromium_code" ]
+ ldflags = []
+ if (is_fuchsia) {
+ configs -= [ "//build/config/fuchsia:thread_safety_annotations" ]
+ ldflags += [ "-static-libstdc++" ]
+ } else {
+ configs -= [ "//build/config/compiler:chromium_code" ]
+ configs += [ "//build/config/compiler:no_chromium_code" ]
+ }
configs -= vulkan_undefine_configs
+ configs += [ ":generated_layers_config" ]
public_configs = [ ":vulkan_layer_config" ]
deps = [
- # Make sure the cleanup of old layers happen before the new ones are compiled.
- ":vulkan_clean_old_validation_layer_objects",
":vulkan_layer_utils",
]
if (layer_info[2] != "") {
@@ -260,10 +273,10 @@
defines += [ "NOMINMAX" ]
sources += [ "layers/VkLayer_$name.def" ]
}
- if (is_linux || is_android) {
- ldflags = [ "-Wl,-Bsymbolic,--exclude-libs,ALL" ]
+ if (is_linux || is_android || is_fuchsia) {
+ ldflags += [ "-Wl,-Bsymbolic,--exclude-libs,ALL" ]
}
- if (use_x11) {
+ if (!is_fuchsia && use_x11) {
defines += [ "VK_USE_PLATFORM_XLIB_KHR" ]
}
if (is_android) {
@@ -278,9 +291,49 @@
}
group("vulkan_validation_layers") {
+ public_deps = []
data_deps = []
foreach(layer_info, layers) {
name = layer_info[0]
- data_deps += [ ":VkLayer_$name" ]
+ if (is_fuchsia) {
+ public_deps += [ ":VkLayer_$name" ]
+ } else {
+ data_deps += [ ":VkLayer_$name" ]
+ }
}
}
+
+source_set("micro_layer_common") {
+ # For layers defined outside this repo
+ public_configs = [ ":vulkan_layer_config" ]
+
+ 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/vk_format_utils.cpp",
+ "layers/vk_format_utils.h",
+ "layers/vk_layer_extension_utils.cpp",
+ "layers/vk_layer_extension_utils.h",
+ "layers/vk_layer_utils_minimal.cpp",
+ "layers/vk_layer_utils_minimal.h",
+ ]
+ public_configs += [
+ "$vulkan_headers_dir:vulkan_headers_config",
+ ":vulkan_internal_config",
+ ]
+ public_deps = []
+ configs -= vulkan_undefine_configs
+ if (is_fuchsia) {
+ public_deps = [
+ "//third_party/Vulkan-Loader:dlopen_fuchsia",
+ ]
+ } else {
+ configs -= [ "//build/config/compiler:chromium_code" ]
+ configs += [ "//build/config/compiler:no_chromium_code" ]
+ }
+}
+
+group("tests") {
+ # TODO(MA-684)
+}
diff --git a/README.fuchsia b/README.fuchsia
new file mode 100644
index 0000000..17b1759
--- /dev/null
+++ b/README.fuchsia
@@ -0,0 +1,8 @@
+Name: Vulkan-ValidationLayers
+License: Apache 2.0
+License File: LICENSE.txt
+Upstream Git: https://github.com/KhronosGroup/Vulkan-ValidationLayers
+Description:
+
+Provides the Khronos official Vulkan validation layers.
+
diff --git a/build-gn/commit_id.py b/build-gn/commit_id.py
index 78e978e..16af01a 100755
--- a/build-gn/commit_id.py
+++ b/build-gn/commit_id.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2.7
# Copyright (C) 2018 The ANGLE Project Authors.
#
diff --git a/build-gn/generate_vulkan_layers_json.py b/build-gn/generate_vulkan_layers_json.py
index 93d105b..323e680 100755
--- a/build-gn/generate_vulkan_layers_json.py
+++ b/build-gn/generate_vulkan_layers_json.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2.7
# Copyright (C) 2016 The ANGLE Project Authors.
#
@@ -35,6 +35,7 @@
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--icd', action='store_true')
+ parser.add_argument('--no-path-prefix', action='store_true')
parser.add_argument('source_dir')
parser.add_argument('target_dir')
parser.add_argument('version_header', help='path to vulkan_core.h')
@@ -95,10 +96,15 @@
return 1
# Set json file prefix and suffix for generating files, default to Linux.
- relative_path_prefix = '../lib'
+ if args.no_path_prefix:
+ relative_path_prefix = ''
+ elif platform.system() == 'Windows':
+ relative_path_prefix = r'..\\' # json-escaped, hence two backslashes.
+ else:
+ relative_path_prefix = '../lib'
+
file_type_suffix = '.so'
if platform.system() == 'Windows':
- relative_path_prefix = r'..\\' # json-escaped, hence two backslashes.
file_type_suffix = '.dll'
elif platform.system() == 'Darwin':
file_type_suffix = '.dylib'
diff --git a/build-gn/layers-fuchsia.gni b/build-gn/layers-fuchsia.gni
new file mode 100644
index 0000000..ee95b2f
--- /dev/null
+++ b/build-gn/layers-fuchsia.gni
@@ -0,0 +1,74 @@
+# Copyright 2018 The Fuchsia Authors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+# This scope makes it easy to incorporate the Vulkan validation layers into a
+# package that is part of the Fuchsia system build.
+#
+# To use it, import this gni file and add the entries of the
+# 'vulkan_validation_layers' scope to the package's 'loadable_modules',
+# 'resources', and 'public_deps' parameters.
+#
+# Example BUILD.gn file:
+#
+# import("//src/graphics/lib/vulkan/layers.gni")
+#
+# package("my_funky_vulkan_using_program") {
+# loadable_modules = [
+# ...
+# ] + vulkan_validation_layers.loadable_modules
+#
+# resources = [
+# ...
+# ] + vulkan_validation_layers.resources
+#
+# public_deps = [
+# ...
+# ] + vulkan_validation_layers.public_deps
+# }
+#
+# This will end up placing the validation libraries within the package's "lib/"
+# directory, where they can be loaded like normal libraries, and place the layer
+# configuration data in the package's "data/vulkan/explicit_layer.d" directory which
+# is mapped to "/config/vulkan/explicit_layer.d"
+
+import("//build_overrides/vulkan_validation_layers.gni")
+
+vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir"
+
+vulkan_validation_layers = {
+ loadable_modules = [
+ {
+ name = "VkLayer_khronos_validation.so"
+ },
+ ]
+
+ resources = [
+ {
+ path = rebase_path("$vulkan_data_dir/VkLayer_khronos_validation.json")
+ dest = "vulkan/explicit_layer.d/VkLayer_khronos_validation.json"
+ },
+ ]
+
+ public_deps = [
+ "//third_party/Vulkan-ValidationLayers:vulkan_gen_json_files",
+ "//third_party/Vulkan-ValidationLayers:vulkan_validation_layers",
+ ]
+}
diff --git a/build-gn/remove_files.py b/build-gn/remove_files.py
index 7095913..ba30527 100755
--- a/build-gn/remove_files.py
+++ b/build-gn/remove_files.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python2.7
# Copyright (C) 2019 The ANGLE Project Authors.
#
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index be03fe2..d986a40 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -10882,6 +10882,27 @@
return ValidateImportSemaphore(pImportSemaphoreFdInfo->semaphore, "vkImportSemaphoreFdKHR");
}
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool CoreChecks::PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo) const {
+ return ValidateImportSemaphore(pImportSemaphoreZirconHandleInfo->semaphore, "vkImportSemaphoreZirconHandleFUCHSIA");
+}
+
+void CoreChecks::PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo, VkResult result) {
+ if (VK_SUCCESS != result) return;
+ RecordImportSemaphoreState(pImportSemaphoreZirconHandleInfo->semaphore, pImportSemaphoreZirconHandleInfo->handleType,
+ pImportSemaphoreZirconHandleInfo->flags);
+}
+
+void CoreChecks::PostCallRecordGetSemaphoreZirconHandleFUCHSIA(VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
+ zx_handle_t *pZirconHandle, VkResult result) {
+ if (VK_SUCCESS != result) return;
+ RecordGetExternalSemaphoreState(pGetZirconHandleInfo->semaphore, pGetZirconHandleInfo->handleType);
+}
+#endif
+
bool CoreChecks::ValidateImportFence(VkFence fence, const char *caller_name) const {
const FENCE_STATE *fence_node = GetFenceState(fence);
bool skip = false;
diff --git a/layers/core_validation.h b/layers/core_validation.h
index 1f73e84..e3e45cf 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -1056,6 +1056,16 @@
const VkMappedMemoryRange* pMemRanges) const;
void PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges,
VkResult result);
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ bool PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const;
+
+ void PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo, VkResult result);
+ void PostCallRecordGetSemaphoreZirconHandleFUCHSIA(VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle, VkResult result);
+#endif
bool PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) const;
bool PreCallValidateBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) const;
bool PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
diff --git a/layers/generated/best_practices.cpp b/layers/generated/best_practices.cpp
index 0a39fb8..800a93d 100644
--- a/layers/generated/best_practices.cpp
+++ b/layers/generated/best_practices.cpp
@@ -2623,6 +2623,143 @@
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkCreateBufferCollectionFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordSetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkSetBufferCollectionConstraintsFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkSetBufferCollectionBufferConstraintsFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkGetBufferCollectionPropertiesFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkGetMemoryZirconHandleFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkGetMemoryZirconHandlePropertiesFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkImportSemaphoreZirconHandleFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void BestPractices::PostCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result) {
+ ValidationStateTracker::PostCallRecordGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, result);
+ if (result != VK_SUCCESS) {
+ static const std::vector<VkResult> error_codes = {VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY};
+ static const std::vector<VkResult> success_codes = {};
+ ValidateReturnCodes("vkGetSemaphoreZirconHandleFUCHSIA", result, error_codes, success_codes);
+ }
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
void BestPractices::PostCallRecordCreateAccelerationStructureKHR(
diff --git a/layers/generated/best_practices.h b/layers/generated/best_practices.h
index 31527fd..e5ddf84 100644
--- a/layers/generated/best_practices.h
+++ b/layers/generated/best_practices.h
@@ -1514,6 +1514,95 @@
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PostCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result);
+
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
void PostCallRecordCreateAccelerationStructureKHR(
diff --git a/layers/generated/chassis.cpp b/layers/generated/chassis.cpp
index eb278e7..3e368b5 100644
--- a/layers/generated/chassis.cpp
+++ b/layers/generated/chassis.cpp
@@ -10249,6 +10249,222 @@
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection);
+ }
+ VkResult result = DispatchCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordCreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection, result);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateSetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordSetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo);
+ }
+ VkResult result = DispatchSetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordSetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo, result);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
+ }
+ VkResult result = DispatchSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo, result);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+ if (skip) return;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+ }
+ DispatchDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
+ }
+ VkResult result = DispatchGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties, result);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ }
+ VkResult result = DispatchGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, result);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties);
+ }
+ VkResult result = DispatchGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties, result);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
+ }
+ VkResult result = DispatchImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo, result);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ bool skip = false;
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->read_lock();
+ skip |= (const_cast<const ValidationObject*>(intercept))->PreCallValidateGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+ }
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PreCallRecordGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ }
+ VkResult result = DispatchGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ for (auto intercept : layer_data->object_dispatch) {
+ auto lock = intercept->write_lock();
+ intercept->PostCallRecordGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, result);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
@@ -11142,6 +11358,33 @@
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
{"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", {kFuncTypePdev, (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT}},
#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkCreateBufferCollectionFUCHSIA", {kFuncTypeDev, (void*)CreateBufferCollectionFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkSetBufferCollectionConstraintsFUCHSIA", {kFuncTypeDev, (void*)SetBufferCollectionConstraintsFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkSetBufferCollectionBufferConstraintsFUCHSIA", {kFuncTypeDev, (void*)SetBufferCollectionBufferConstraintsFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkDestroyBufferCollectionFUCHSIA", {kFuncTypeDev, (void*)DestroyBufferCollectionFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkGetBufferCollectionPropertiesFUCHSIA", {kFuncTypeDev, (void*)GetBufferCollectionPropertiesFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkGetMemoryZirconHandleFUCHSIA", {kFuncTypeDev, (void*)GetMemoryZirconHandleFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkGetMemoryZirconHandlePropertiesFUCHSIA", {kFuncTypeDev, (void*)GetMemoryZirconHandlePropertiesFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkImportSemaphoreZirconHandleFUCHSIA", {kFuncTypeDev, (void*)ImportSemaphoreZirconHandleFUCHSIA}},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ {"vkGetSemaphoreZirconHandleFUCHSIA", {kFuncTypeDev, (void*)GetSemaphoreZirconHandleFUCHSIA}},
+#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
{"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}},
#endif
diff --git a/layers/generated/chassis.h b/layers/generated/chassis.h
index 9a28ad9..72f42fc 100644
--- a/layers/generated/chassis.h
+++ b/layers/generated/chassis.h
@@ -2652,6 +2652,61 @@
IDirectFB* dfb);
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection);
+
+VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+
+VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
@@ -4435,6 +4490,51 @@
virtual void PreCallRecordGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {};
virtual void PostCallRecordGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {};
#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) const { return false; };
+ virtual void PreCallRecordCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {};
+ virtual void PostCallRecordCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateSetBufferCollectionConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageCreateInfo* pImageInfo) const { return false; };
+ virtual void PreCallRecordSetBufferCollectionConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageCreateInfo* pImageInfo) {};
+ virtual void PostCallRecordSetBufferCollectionConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageCreateInfo* pImageInfo, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const { return false; };
+ virtual void PreCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {};
+ virtual void PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) const { return false; };
+ virtual void PreCallRecordDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) {};
+ virtual void PostCallRecordDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) const { return false; };
+ virtual void PreCallRecordGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) {};
+ virtual void PostCallRecordGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) const { return false; };
+ virtual void PreCallRecordGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {};
+ virtual void PostCallRecordGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t ZirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const { return false; };
+ virtual void PreCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t ZirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {};
+ virtual void PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t ZirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const { return false; };
+ virtual void PreCallRecordImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {};
+ virtual void PostCallRecordImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo, VkResult result) {};
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ virtual bool PreCallValidateGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) const { return false; };
+ virtual void PreCallRecordGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {};
+ virtual void PostCallRecordGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle, VkResult result) {};
+#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
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) {};
diff --git a/layers/generated/layer_chassis_dispatch.cpp b/layers/generated/layer_chassis_dispatch.cpp
index f2277ee..8a366b1 100644
--- a/layers/generated/layer_chassis_dispatch.cpp
+++ b/layers/generated/layer_chassis_dispatch.cpp
@@ -79,6 +79,15 @@
}
} break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ safe_VkImportMemoryBufferCollectionFUCHSIA *safe_struct = reinterpret_cast<safe_VkImportMemoryBufferCollectionFUCHSIA *>(cur_pnext);
+ if (safe_struct->collection) {
+ safe_struct->collection = layer_data->Unwrap(safe_struct->collection);
+ }
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
safe_VkMemoryDedicatedAllocateInfo *safe_struct = reinterpret_cast<safe_VkMemoryDedicatedAllocateInfo *>(cur_pnext);
if (safe_struct->image) {
@@ -89,6 +98,24 @@
}
} break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ safe_VkBufferCollectionBufferCreateInfoFUCHSIA *safe_struct = reinterpret_cast<safe_VkBufferCollectionBufferCreateInfoFUCHSIA *>(cur_pnext);
+ if (safe_struct->collection) {
+ safe_struct->collection = layer_data->Unwrap(safe_struct->collection);
+ }
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ safe_VkBufferCollectionImageCreateInfoFUCHSIA *safe_struct = reinterpret_cast<safe_VkBufferCollectionImageCreateInfoFUCHSIA *>(cur_pnext);
+ if (safe_struct->collection) {
+ safe_struct->collection = layer_data->Unwrap(safe_struct->collection);
+ }
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
safe_VkImageSwapchainCreateInfoKHR *safe_struct = reinterpret_cast<safe_VkImageSwapchainCreateInfoKHR *>(cur_pnext);
if (safe_struct->swapchain) {
@@ -1786,7 +1813,16 @@
{
auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (!wrap_handles) return layer_data->device_dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
- VkResult result = layer_data->device_dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ safe_VkBufferCreateInfo var_local_pCreateInfo;
+ safe_VkBufferCreateInfo *local_pCreateInfo = NULL;
+ {
+ if (pCreateInfo) {
+ local_pCreateInfo = &var_local_pCreateInfo;
+ local_pCreateInfo->initialize(pCreateInfo);
+ WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
+ }
+ }
+ VkResult result = layer_data->device_dispatch_table.CreateBuffer(device, (const VkBufferCreateInfo*)local_pCreateInfo, pAllocator, pBuffer);
if (VK_SUCCESS == result) {
*pBuffer = layer_data->WrapNew(*pBuffer);
}
@@ -7686,6 +7722,198 @@
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.CreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection);
+ VkResult result = layer_data->device_dispatch_table.CreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection);
+ if (VK_SUCCESS == result) {
+ *pCollection = layer_data->WrapNew(*pCollection);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.SetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo);
+ safe_VkImageCreateInfo var_local_pImageInfo;
+ safe_VkImageCreateInfo *local_pImageInfo = NULL;
+ {
+ collection = layer_data->Unwrap(collection);
+ if (pImageInfo) {
+ local_pImageInfo = &var_local_pImageInfo;
+ local_pImageInfo->initialize(pImageInfo);
+ WrapPnextChainHandles(layer_data, local_pImageInfo->pNext);
+ }
+ }
+ VkResult result = layer_data->device_dispatch_table.SetBufferCollectionConstraintsFUCHSIA(device, collection, (const VkImageCreateInfo*)local_pImageInfo);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
+ {
+ collection = layer_data->Unwrap(collection);
+ }
+ VkResult result = layer_data->device_dispatch_table.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void DispatchDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.DestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+ uint64_t collection_id = reinterpret_cast<uint64_t &>(collection);
+ auto iter = unique_id_mapping.pop(collection_id);
+ if (iter != unique_id_mapping.end()) {
+ collection = (VkBufferCollectionFUCHSIA)iter->second;
+ } else {
+ collection = (VkBufferCollectionFUCHSIA)0;
+ }
+ layer_data->device_dispatch_table.DestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
+
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
+ {
+ collection = layer_data->Unwrap(collection);
+ }
+ VkResult result = layer_data->device_dispatch_table.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA var_local_pGetZirconHandleInfo;
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA *local_pGetZirconHandleInfo = NULL;
+ {
+ if (pGetZirconHandleInfo) {
+ local_pGetZirconHandleInfo = &var_local_pGetZirconHandleInfo;
+ local_pGetZirconHandleInfo->initialize(pGetZirconHandleInfo);
+ if (pGetZirconHandleInfo->memory) {
+ local_pGetZirconHandleInfo->memory = layer_data->Unwrap(pGetZirconHandleInfo->memory);
+ }
+ }
+ }
+ VkResult result = layer_data->device_dispatch_table.GetMemoryZirconHandleFUCHSIA(device, (const VkMemoryGetZirconHandleInfoFUCHSIA*)local_pGetZirconHandleInfo, pZirconHandle);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = layer_data->device_dispatch_table.GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA var_local_pImportSemaphoreZirconHandleInfo;
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA *local_pImportSemaphoreZirconHandleInfo = NULL;
+ {
+ if (pImportSemaphoreZirconHandleInfo) {
+ local_pImportSemaphoreZirconHandleInfo = &var_local_pImportSemaphoreZirconHandleInfo;
+ local_pImportSemaphoreZirconHandleInfo->initialize(pImportSemaphoreZirconHandleInfo);
+ if (pImportSemaphoreZirconHandleInfo->semaphore) {
+ local_pImportSemaphoreZirconHandleInfo->semaphore = layer_data->Unwrap(pImportSemaphoreZirconHandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = layer_data->device_dispatch_table.ImportSemaphoreZirconHandleFUCHSIA(device, (const VkImportSemaphoreZirconHandleInfoFUCHSIA*)local_pImportSemaphoreZirconHandleInfo);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+VkResult DispatchGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle)
+{
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ if (!wrap_handles) return layer_data->device_dispatch_table.GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA var_local_pGetZirconHandleInfo;
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA *local_pGetZirconHandleInfo = NULL;
+ {
+ if (pGetZirconHandleInfo) {
+ local_pGetZirconHandleInfo = &var_local_pGetZirconHandleInfo;
+ local_pGetZirconHandleInfo->initialize(pGetZirconHandleInfo);
+ if (pGetZirconHandleInfo->semaphore) {
+ local_pGetZirconHandleInfo->semaphore = layer_data->Unwrap(pGetZirconHandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = layer_data->device_dispatch_table.GetSemaphoreZirconHandleFUCHSIA(device, (const VkSemaphoreGetZirconHandleInfoFUCHSIA*)local_pGetZirconHandleInfo, pZirconHandle);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
VkResult DispatchCreateAccelerationStructureKHR(
diff --git a/layers/generated/layer_chassis_dispatch.h b/layers/generated/layer_chassis_dispatch.h
index b450025..ab9c056 100644
--- a/layers/generated/layer_chassis_dispatch.h
+++ b/layers/generated/layer_chassis_dispatch.h
@@ -2006,6 +2006,61 @@
uint32_t queueFamilyIndex,
IDirectFB* dfb);
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+void DispatchDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+VkResult DispatchGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_ENABLE_BETA_EXTENSIONS
VkResult DispatchCreateAccelerationStructureKHR(
VkDevice device,
diff --git a/layers/generated/object_tracker.cpp b/layers/generated/object_tracker.cpp
index 7ad9696..25e9059 100644
--- a/layers/generated/object_tracker.cpp
+++ b/layers/generated/object_tracker.cpp
@@ -74,6 +74,7 @@
skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePerformanceConfigurationINTEL, error_code);
skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNV, error_code);
skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypePrivateDataSlotEXT, error_code);
+ skip |= ReportLeakedDeviceObjects(device, kVulkanObjectTypeBufferCollectionFUCHSIA, error_code);
return skip;
}
@@ -115,6 +116,7 @@
DestroyUndestroyedObjects(kVulkanObjectTypePerformanceConfigurationINTEL);
DestroyUndestroyedObjects(kVulkanObjectTypeIndirectCommandsLayoutNV);
DestroyUndestroyedObjects(kVulkanObjectTypePrivateDataSlotEXT);
+ DestroyUndestroyedObjects(kVulkanObjectTypeBufferCollectionFUCHSIA);
}
@@ -5702,6 +5704,157 @@
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+
+void ObjectLifetimes::PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result) {
+ if (result != VK_SUCCESS) return;
+ CreateObject(*pCollection, kVulkanObjectTypeBufferCollectionFUCHSIA, pAllocator);
+
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateDestroyObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA, pAllocator, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+
+void ObjectLifetimes::PreCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
+ RecordDestroyObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA);
+
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateObject(collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ if (pGetZirconHandleInfo) {
+ skip |= ValidateObject(pGetZirconHandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, kVUIDUndefined, kVUIDUndefined);
+ }
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ if (pImportSemaphoreZirconHandleInfo) {
+ skip |= ValidateObject(pImportSemaphoreZirconHandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, kVUIDUndefined, kVUIDUndefined);
+ }
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool ObjectLifetimes::PreCallValidateGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const {
+ bool skip = false;
+ skip |= ValidateObject(device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
+ if (pGetZirconHandleInfo) {
+ skip |= ValidateObject(pGetZirconHandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, kVUIDUndefined, kVUIDUndefined);
+ }
+
+ return skip;
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureKHR(
diff --git a/layers/generated/object_tracker.h b/layers/generated/object_tracker.h
index 2a0b4ba..7e52355 100644
--- a/layers/generated/object_tracker.h
+++ b/layers/generated/object_tracker.h
@@ -2548,6 +2548,80 @@
IDirectFB* dfb) const;
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) const;
+void PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) const;
+void PreCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
bool PreCallValidateCreateAccelerationStructureKHR(
VkDevice device,
diff --git a/layers/generated/parameter_validation.cpp b/layers/generated/parameter_validation.cpp
index 2ab7444..f48c41d 100644
--- a/layers/generated/parameter_validation.cpp
+++ b/layers/generated/parameter_validation.cpp
@@ -71,9 +71,9 @@
const DECORATE_UNUSED VkExternalFenceFeatureFlags AllVkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR;
const DECORATE_UNUSED 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 DECORATE_UNUSED VkExternalMemoryFeatureFlags AllVkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
-const DECORATE_UNUSED 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;
+const DECORATE_UNUSED 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_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
const DECORATE_UNUSED VkExternalSemaphoreFeatureFlags AllVkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
-const DECORATE_UNUSED 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;
+const DECORATE_UNUSED 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_TEMP_ZIRCON_EVENT_BIT_FUCHSIA;
const DECORATE_UNUSED VkFenceImportFlags AllVkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT|VK_FENCE_IMPORT_TEMPORARY_BIT_KHR;
const DECORATE_UNUSED 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;
const DECORATE_UNUSED VkPeerMemoryFeatureFlags AllVkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT|VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR|VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR;
@@ -90,9 +90,9 @@
const DECORATE_UNUSED VkMemoryAllocateFlagsKHR AllVkMemoryAllocateFlagBitsKHR = 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;
const DECORATE_UNUSED VkPeerMemoryFeatureFlagsKHR AllVkPeerMemoryFeatureFlagBitsKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT|VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR|VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR;
const DECORATE_UNUSED VkExternalMemoryFeatureFlagsKHR AllVkExternalMemoryFeatureFlagBitsKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
-const DECORATE_UNUSED VkExternalMemoryHandleTypeFlagsKHR AllVkExternalMemoryHandleTypeFlagBitsKHR = 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;
+const DECORATE_UNUSED VkExternalMemoryHandleTypeFlagsKHR AllVkExternalMemoryHandleTypeFlagBitsKHR = 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_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
const DECORATE_UNUSED VkExternalSemaphoreFeatureFlagsKHR AllVkExternalSemaphoreFeatureFlagBitsKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
-const DECORATE_UNUSED VkExternalSemaphoreHandleTypeFlagsKHR AllVkExternalSemaphoreHandleTypeFlagBitsKHR = 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;
+const DECORATE_UNUSED VkExternalSemaphoreHandleTypeFlagsKHR AllVkExternalSemaphoreHandleTypeFlagBitsKHR = 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_TEMP_ZIRCON_EVENT_BIT_FUCHSIA;
const DECORATE_UNUSED VkSemaphoreImportFlagsKHR AllVkSemaphoreImportFlagBitsKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT|VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR;
const DECORATE_UNUSED VkExternalFenceFeatureFlagsKHR AllVkExternalFenceFeatureFlagBitsKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR;
const DECORATE_UNUSED VkExternalFenceHandleTypeFlagsKHR AllVkExternalFenceHandleTypeFlagBitsKHR = 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;
@@ -122,7 +122,7 @@
const std::vector<VkResult> AllVkResultEnums = {VK_SUCCESS, VK_NOT_READY, VK_TIMEOUT, VK_EVENT_SET, VK_EVENT_RESET, VK_INCOMPLETE, VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_DEVICE_MEMORY, VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_DEVICE_LOST, VK_ERROR_MEMORY_MAP_FAILED, VK_ERROR_LAYER_NOT_PRESENT, VK_ERROR_EXTENSION_NOT_PRESENT, VK_ERROR_FEATURE_NOT_PRESENT, VK_ERROR_INCOMPATIBLE_DRIVER, VK_ERROR_TOO_MANY_OBJECTS, VK_ERROR_FORMAT_NOT_SUPPORTED, VK_ERROR_FRAGMENTED_POOL, VK_ERROR_UNKNOWN, VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, VK_ERROR_SURFACE_LOST_KHR, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, VK_SUBOPTIMAL_KHR, VK_ERROR_OUT_OF_DATE_KHR, VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, VK_ERROR_VALIDATION_FAILED_EXT, VK_ERROR_INVALID_SHADER_NV, VK_ERROR_OUT_OF_POOL_MEMORY_KHR, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, VK_ERROR_INCOMPATIBLE_VERSION_KHR, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, VK_ERROR_FRAGMENTATION_EXT, VK_ERROR_NOT_PERMITTED_EXT, VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, VK_THREAD_IDLE_KHR, VK_THREAD_DONE_KHR, VK_OPERATION_DEFERRED_KHR, VK_OPERATION_NOT_DEFERRED_KHR, VK_PIPELINE_COMPILE_REQUIRED_EXT, VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT, };
const std::vector<VkImageLayout> AllVkImageLayoutEnums = {VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR, };
-const std::vector<VkObjectType> AllVkObjectTypeEnums = {VK_OBJECT_TYPE_UNKNOWN, VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_PHYSICAL_DEVICE, VK_OBJECT_TYPE_DEVICE, VK_OBJECT_TYPE_QUEUE, VK_OBJECT_TYPE_SEMAPHORE, VK_OBJECT_TYPE_COMMAND_BUFFER, VK_OBJECT_TYPE_FENCE, VK_OBJECT_TYPE_DEVICE_MEMORY, VK_OBJECT_TYPE_BUFFER, VK_OBJECT_TYPE_IMAGE, VK_OBJECT_TYPE_EVENT, VK_OBJECT_TYPE_QUERY_POOL, VK_OBJECT_TYPE_BUFFER_VIEW, VK_OBJECT_TYPE_IMAGE_VIEW, VK_OBJECT_TYPE_SHADER_MODULE, VK_OBJECT_TYPE_PIPELINE_CACHE, VK_OBJECT_TYPE_PIPELINE_LAYOUT, VK_OBJECT_TYPE_RENDER_PASS, VK_OBJECT_TYPE_PIPELINE, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, VK_OBJECT_TYPE_SAMPLER, VK_OBJECT_TYPE_DESCRIPTOR_POOL, VK_OBJECT_TYPE_DESCRIPTOR_SET, VK_OBJECT_TYPE_FRAMEBUFFER, VK_OBJECT_TYPE_COMMAND_POOL, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SURFACE_KHR, VK_OBJECT_TYPE_SWAPCHAIN_KHR, VK_OBJECT_TYPE_DISPLAY_KHR, VK_OBJECT_TYPE_DISPLAY_MODE_KHR, VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, };
+const std::vector<VkObjectType> AllVkObjectTypeEnums = {VK_OBJECT_TYPE_UNKNOWN, VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_PHYSICAL_DEVICE, VK_OBJECT_TYPE_DEVICE, VK_OBJECT_TYPE_QUEUE, VK_OBJECT_TYPE_SEMAPHORE, VK_OBJECT_TYPE_COMMAND_BUFFER, VK_OBJECT_TYPE_FENCE, VK_OBJECT_TYPE_DEVICE_MEMORY, VK_OBJECT_TYPE_BUFFER, VK_OBJECT_TYPE_IMAGE, VK_OBJECT_TYPE_EVENT, VK_OBJECT_TYPE_QUERY_POOL, VK_OBJECT_TYPE_BUFFER_VIEW, VK_OBJECT_TYPE_IMAGE_VIEW, VK_OBJECT_TYPE_SHADER_MODULE, VK_OBJECT_TYPE_PIPELINE_CACHE, VK_OBJECT_TYPE_PIPELINE_LAYOUT, VK_OBJECT_TYPE_RENDER_PASS, VK_OBJECT_TYPE_PIPELINE, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, VK_OBJECT_TYPE_SAMPLER, VK_OBJECT_TYPE_DESCRIPTOR_POOL, VK_OBJECT_TYPE_DESCRIPTOR_SET, VK_OBJECT_TYPE_FRAMEBUFFER, VK_OBJECT_TYPE_COMMAND_POOL, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SURFACE_KHR, VK_OBJECT_TYPE_SWAPCHAIN_KHR, VK_OBJECT_TYPE_DISPLAY_KHR, VK_OBJECT_TYPE_DISPLAY_MODE_KHR, VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, };
const std::vector<VkVendorId> AllVkVendorIdEnums = {VK_VENDOR_ID_VIV, VK_VENDOR_ID_VSI, VK_VENDOR_ID_KAZAN, VK_VENDOR_ID_CODEPLAY, VK_VENDOR_ID_MESA, };
const std::vector<VkPipelineCacheHeaderVersion> AllVkPipelineCacheHeaderVersionEnums = {VK_PIPELINE_CACHE_HEADER_VERSION_ONE, };
const std::vector<VkSystemAllocationScope> AllVkSystemAllocationScopeEnums = {VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, VK_SYSTEM_ALLOCATION_SCOPE_CACHE, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, };
@@ -181,7 +181,7 @@
const std::vector<VkShaderFloatControlsIndependenceKHR> AllVkShaderFloatControlsIndependenceKHREnums = {VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR, };
const std::vector<VkSemaphoreTypeKHR> AllVkSemaphoreTypeKHREnums = {VK_SEMAPHORE_TYPE_BINARY, VK_SEMAPHORE_TYPE_TIMELINE, VK_SEMAPHORE_TYPE_BINARY_KHR, VK_SEMAPHORE_TYPE_TIMELINE_KHR, };
const std::vector<VkPipelineExecutableStatisticFormatKHR> AllVkPipelineExecutableStatisticFormatKHREnums = {VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR, };
-const std::vector<VkDebugReportObjectTypeEXT> AllVkDebugReportObjectTypeEXTEnums = {VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, };
+const std::vector<VkDebugReportObjectTypeEXT> AllVkDebugReportObjectTypeEXTEnums = {VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT, };
const std::vector<VkRasterizationOrderAMD> AllVkRasterizationOrderAMDEnums = {VK_RASTERIZATION_ORDER_STRICT_AMD, VK_RASTERIZATION_ORDER_RELAXED_AMD, };
const std::vector<VkShaderInfoTypeAMD> AllVkShaderInfoTypeAMDEnums = {VK_SHADER_INFO_TYPE_STATISTICS_AMD, VK_SHADER_INFO_TYPE_BINARY_AMD, VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, };
const std::vector<VkValidationCheckEXT> AllVkValidationCheckEXTEnums = {VK_VALIDATION_CHECK_ALL_EXT, VK_VALIDATION_CHECK_SHADERS_EXT, };
@@ -2025,6 +2025,46 @@
skip |= validate_bool32("VkPhysicalDeviceImageRobustnessFeaturesEXT", "robustImageAccess", structure->robustImageAccess);
} break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ // Validation code for VkFuchsiaImageFormatFUCHSIA structure members
+ case VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA: { // Covers VUID-VkFuchsiaImageFormatFUCHSIA-sType-sType
+ VkFuchsiaImageFormatFUCHSIA *structure = (VkFuchsiaImageFormatFUCHSIA *) header;
+ skip |= validate_required_pointer("VkFuchsiaImageFormatFUCHSIA", "imageFormat", structure->imageFormat, kVUIDUndefined);
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ // Validation code for VkImportMemoryBufferCollectionFUCHSIA structure members
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: { // Covers VUID-VkImportMemoryBufferCollectionFUCHSIA-sType-sType
+ VkImportMemoryBufferCollectionFUCHSIA *structure = (VkImportMemoryBufferCollectionFUCHSIA *) header;
+ skip |= validate_required_handle("VkImportMemoryBufferCollectionFUCHSIA", "collection", structure->collection);
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ // Validation code for VkBufferCollectionImageCreateInfoFUCHSIA structure members
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: { // Covers VUID-VkBufferCollectionImageCreateInfoFUCHSIA-sType-sType
+ VkBufferCollectionImageCreateInfoFUCHSIA *structure = (VkBufferCollectionImageCreateInfoFUCHSIA *) header;
+ skip |= validate_required_handle("VkBufferCollectionImageCreateInfoFUCHSIA", "collection", structure->collection);
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ // Validation code for VkBufferCollectionBufferCreateInfoFUCHSIA structure members
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: { // Covers VUID-VkBufferCollectionBufferCreateInfoFUCHSIA-sType-sType
+ VkBufferCollectionBufferCreateInfoFUCHSIA *structure = (VkBufferCollectionBufferCreateInfoFUCHSIA *) header;
+ skip |= validate_required_handle("VkBufferCollectionBufferCreateInfoFUCHSIA", "collection", structure->collection);
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ // Validation code for VkImportMemoryZirconHandleInfoFUCHSIA structure members
+ case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: { // Covers VUID-VkImportMemoryZirconHandleInfoFUCHSIA-sType-sType
+ VkImportMemoryZirconHandleInfoFUCHSIA *structure = (VkImportMemoryZirconHandleInfoFUCHSIA *) header;
+ skip |= validate_flags("VkImportMemoryZirconHandleInfoFUCHSIA", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, kOptionalSingleBit, kVUIDUndefined);
+ } break;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
// Validation code for VkPhysicalDeviceRayTracingFeaturesKHR structure members
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR: { // Covers VUID-VkPhysicalDeviceRayTracingFeaturesKHR-sType-sType
@@ -2494,9 +2534,9 @@
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_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, 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_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_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_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, 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, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique");
+ skip |= validate_struct_pnext("vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfo, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportAndroidHardwareBufferInfoANDROID, VkImportMemoryBufferCollectionFUCHSIA, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryZirconHandleInfoFUCHSIA, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryPriorityAllocateInfoEXT", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedVulkanHeaderVersion, "VUID-VkMemoryAllocateInfo-pNext-pNext", "VUID-VkMemoryAllocateInfo-sType-unique");
}
if (pAllocator != NULL)
{
@@ -3148,9 +3188,9 @@
skip |= validate_struct_type("vkCreateBuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, true, "VUID-vkCreateBuffer-pCreateInfo-parameter", "VUID-VkBufferCreateInfo-sType-sType");
if (pCreateInfo != NULL)
{
- const VkStructureType allowed_structs_VkBufferCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO };
+ const VkStructureType allowed_structs_VkBufferCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO };
- skip |= validate_struct_pnext("vkCreateBuffer", "pCreateInfo->pNext", "VkBufferDeviceAddressCreateInfoEXT, VkBufferOpaqueCaptureAddressCreateInfo, VkDedicatedAllocationBufferCreateInfoNV, VkExternalMemoryBufferCreateInfo", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkBufferCreateInfo), allowed_structs_VkBufferCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkBufferCreateInfo-pNext-pNext", "VUID-VkBufferCreateInfo-sType-unique");
+ skip |= validate_struct_pnext("vkCreateBuffer", "pCreateInfo->pNext", "VkBufferCollectionBufferCreateInfoFUCHSIA, VkBufferDeviceAddressCreateInfoEXT, VkBufferOpaqueCaptureAddressCreateInfo, VkDedicatedAllocationBufferCreateInfoNV, VkExternalMemoryBufferCreateInfo", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkBufferCreateInfo), allowed_structs_VkBufferCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkBufferCreateInfo-pNext-pNext", "VUID-VkBufferCreateInfo-sType-unique");
skip |= validate_flags("vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkBufferCreateInfo-flags-parameter");
@@ -3289,9 +3329,9 @@
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_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, 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_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 };
+ 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_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA, 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 };
- skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique");
+ skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkFuchsiaImageFormatFUCHSIA, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique");
skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter");
@@ -12003,6 +12043,248 @@
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool StatelessValidation::PreCallValidateCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) const {
+ bool skip = false;
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkCreateBufferCollectionFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_buffer_collection) skip |= OutputExtensionError("vkCreateBufferCollectionFUCHSIA", VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
+ skip |= validate_struct_type("vkCreateBufferCollectionFUCHSIA", "pImportInfo", "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA", pImportInfo, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pImportInfo != NULL)
+ {
+ skip |= validate_struct_pnext("vkCreateBufferCollectionFUCHSIA", "pImportInfo->pNext", NULL, pImportInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+ }
+ if (pAllocator != NULL)
+ {
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), "VUID-VkAllocationCallbacks-pfnAllocation-00632");
+
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), "VUID-VkAllocationCallbacks-pfnReallocation-00633");
+
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), "VUID-VkAllocationCallbacks-pfnFree-00634");
+
+ if (pAllocator->pfnInternalAllocation != NULL)
+ {
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pAllocator->pfnInternalFree", reinterpret_cast<const void*>(pAllocator->pfnInternalFree), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635");
+
+ }
+
+ if (pAllocator->pfnInternalFree != NULL)
+ {
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pAllocator->pfnInternalAllocation", reinterpret_cast<const void*>(pAllocator->pfnInternalAllocation), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635");
+
+ }
+ }
+ skip |= validate_required_pointer("vkCreateBufferCollectionFUCHSIA", "pCollection", pCollection, kVUIDUndefined);
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) const {
+ bool skip = false;
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkSetBufferCollectionConstraintsFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_buffer_collection) skip |= OutputExtensionError("vkSetBufferCollectionConstraintsFUCHSIA", VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
+ skip |= validate_required_handle("vkSetBufferCollectionConstraintsFUCHSIA", "collection", collection);
+ skip |= validate_struct_type("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pImageInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true, kVUIDUndefined, "VUID-VkImageCreateInfo-sType-sType");
+ if (pImageInfo != 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_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA, 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 };
+
+ skip |= validate_struct_pnext("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->pNext", "VkBufferCollectionImageCreateInfoFUCHSIA, VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkFuchsiaImageFormatFUCHSIA, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkImageSwapchainCreateInfoKHR", pImageInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext", "VUID-VkImageCreateInfo-sType-unique");
+
+ skip |= validate_flags("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->imageType", "VkImageType", AllVkImageTypeEnums, pImageInfo->imageType, "VUID-VkImageCreateInfo-imageType-parameter");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->format", "VkFormat", AllVkFormatEnums, pImageInfo->format, "VUID-VkImageCreateInfo-format-parameter");
+
+ // No xml-driven validation
+
+ skip |= validate_flags("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pImageInfo->samples, kRequiredSingleBit, "VUID-VkImageCreateInfo-samples-parameter", "VUID-VkImageCreateInfo-samples-parameter");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pImageInfo->tiling, "VUID-VkImageCreateInfo-tiling-parameter");
+
+ skip |= validate_flags("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageInfo->usage, kRequiredFlags, "VUID-VkImageCreateInfo-usage-parameter", "VUID-VkImageCreateInfo-usage-requiredbitmask");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pImageInfo->sharingMode, "VUID-VkImageCreateInfo-sharingMode-parameter");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionConstraintsFUCHSIA", "pImageInfo->initialLayout", "VkImageLayout", AllVkImageLayoutEnums, pImageInfo->initialLayout, "VUID-VkImageCreateInfo-initialLayout-parameter");
+ }
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const {
+ bool skip = false;
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkSetBufferCollectionBufferConstraintsFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_buffer_collection) skip |= OutputExtensionError("vkSetBufferCollectionBufferConstraintsFUCHSIA", VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
+ skip |= validate_required_handle("vkSetBufferCollectionBufferConstraintsFUCHSIA", "collection", collection);
+ skip |= validate_struct_type("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo", "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA", pBufferConstraintsInfo, VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pBufferConstraintsInfo != NULL)
+ {
+ skip |= validate_struct_pnext("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pNext", NULL, pBufferConstraintsInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+
+ skip |= validate_struct_type("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pBufferCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", pBufferConstraintsInfo->pBufferCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, true, kVUIDUndefined, "VUID-VkBufferCreateInfo-sType-sType");
+
+ if (pBufferConstraintsInfo->pBufferCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkBufferCreateInfo[] = { VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO };
+
+ skip |= validate_struct_pnext("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pBufferCreateInfo->pNext", "VkBufferCollectionBufferCreateInfoFUCHSIA, VkBufferDeviceAddressCreateInfoEXT, VkBufferOpaqueCaptureAddressCreateInfo, VkDedicatedAllocationBufferCreateInfoNV, VkExternalMemoryBufferCreateInfo", pBufferConstraintsInfo->pBufferCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkBufferCreateInfo), allowed_structs_VkBufferCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkBufferCreateInfo-pNext-pNext", "VUID-VkBufferCreateInfo-sType-unique");
+
+ skip |= validate_flags("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pBufferCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pBufferConstraintsInfo->pBufferCreateInfo->flags, kOptionalFlags, "VUID-VkBufferCreateInfo-flags-parameter");
+
+ skip |= validate_flags("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pBufferCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pBufferConstraintsInfo->pBufferCreateInfo->usage, kRequiredFlags, "VUID-VkBufferCreateInfo-usage-parameter", "VUID-VkBufferCreateInfo-usage-requiredbitmask");
+
+ skip |= validate_ranged_enum("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->pBufferCreateInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pBufferConstraintsInfo->pBufferCreateInfo->sharingMode, "VUID-VkBufferCreateInfo-sharingMode-parameter");
+ }
+
+ skip |= validate_flags("vkSetBufferCollectionBufferConstraintsFUCHSIA", "pBufferConstraintsInfo->requiredFormatFeatures", "VkFormatFeatureFlagBits", AllVkFormatFeatureFlagBits, pBufferConstraintsInfo->requiredFormatFeatures, kRequiredFlags, kVUIDUndefined, kVUIDUndefined);
+ }
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) const {
+ bool skip = false;
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkDestroyBufferCollectionFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_buffer_collection) skip |= OutputExtensionError("vkDestroyBufferCollectionFUCHSIA", VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
+ skip |= validate_required_handle("vkDestroyBufferCollectionFUCHSIA", "collection", collection);
+ if (pAllocator != NULL)
+ {
+ skip |= validate_required_pointer("vkDestroyBufferCollectionFUCHSIA", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), "VUID-VkAllocationCallbacks-pfnAllocation-00632");
+
+ skip |= validate_required_pointer("vkDestroyBufferCollectionFUCHSIA", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), "VUID-VkAllocationCallbacks-pfnReallocation-00633");
+
+ skip |= validate_required_pointer("vkDestroyBufferCollectionFUCHSIA", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), "VUID-VkAllocationCallbacks-pfnFree-00634");
+
+ if (pAllocator->pfnInternalAllocation != NULL)
+ {
+ skip |= validate_required_pointer("vkDestroyBufferCollectionFUCHSIA", "pAllocator->pfnInternalFree", reinterpret_cast<const void*>(pAllocator->pfnInternalFree), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635");
+
+ }
+
+ if (pAllocator->pfnInternalFree != NULL)
+ {
+ skip |= validate_required_pointer("vkDestroyBufferCollectionFUCHSIA", "pAllocator->pfnInternalAllocation", reinterpret_cast<const void*>(pAllocator->pfnInternalAllocation), "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635");
+
+ }
+ }
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) const {
+ bool skip = false;
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkGetBufferCollectionPropertiesFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_buffer_collection) skip |= OutputExtensionError("vkGetBufferCollectionPropertiesFUCHSIA", VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
+ skip |= validate_required_handle("vkGetBufferCollectionPropertiesFUCHSIA", "collection", collection);
+ skip |= validate_struct_type("vkGetBufferCollectionPropertiesFUCHSIA", "pProperties", "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA", pProperties, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ return skip;
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool StatelessValidation::PreCallValidateGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const {
+ bool skip = false;
+ if (!device_extensions.vk_khr_external_memory) skip |= OutputExtensionError("vkGetMemoryZirconHandleFUCHSIA", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_khr_external_memory_capabilities) skip |= OutputExtensionError("vkGetMemoryZirconHandleFUCHSIA", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkGetMemoryZirconHandleFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ skip |= validate_struct_type("vkGetMemoryZirconHandleFUCHSIA", "pGetZirconHandleInfo", "VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA", pGetZirconHandleInfo, VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pGetZirconHandleInfo != NULL)
+ {
+ skip |= validate_struct_pnext("vkGetMemoryZirconHandleFUCHSIA", "pGetZirconHandleInfo->pNext", NULL, pGetZirconHandleInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+
+ skip |= validate_required_handle("vkGetMemoryZirconHandleFUCHSIA", "pGetZirconHandleInfo->memory", pGetZirconHandleInfo->memory);
+
+ skip |= validate_flags("vkGetMemoryZirconHandleFUCHSIA", "pGetZirconHandleInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pGetZirconHandleInfo->handleType, kRequiredSingleBit, kVUIDUndefined, kVUIDUndefined);
+ }
+ skip |= validate_required_pointer("vkGetMemoryZirconHandleFUCHSIA", "pZirconHandle", pZirconHandle, kVUIDUndefined);
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const {
+ bool skip = false;
+ if (!device_extensions.vk_khr_external_memory) skip |= OutputExtensionError("vkGetMemoryZirconHandlePropertiesFUCHSIA", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+ if (!device_extensions.vk_khr_external_memory_capabilities) skip |= OutputExtensionError("vkGetMemoryZirconHandlePropertiesFUCHSIA", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_external_memory) skip |= OutputExtensionError("vkGetMemoryZirconHandlePropertiesFUCHSIA", VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME);
+ skip |= validate_flags("vkGetMemoryZirconHandlePropertiesFUCHSIA", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, kRequiredSingleBit, kVUIDUndefined, kVUIDUndefined);
+ skip |= validate_struct_type("vkGetMemoryZirconHandlePropertiesFUCHSIA", "pMemoryZirconHandleProperties", "VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA", pMemoryZirconHandleProperties, VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pMemoryZirconHandleProperties != NULL)
+ {
+ skip |= validate_struct_pnext("vkGetMemoryZirconHandlePropertiesFUCHSIA", "pMemoryZirconHandleProperties->pNext", NULL, pMemoryZirconHandleProperties->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+ }
+ return skip;
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+bool StatelessValidation::PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const {
+ bool skip = false;
+ if (!device_extensions.vk_khr_external_semaphore) skip |= OutputExtensionError("vkImportSemaphoreZirconHandleFUCHSIA", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+ if (!device_extensions.vk_khr_external_semaphore_capabilities) skip |= OutputExtensionError("vkImportSemaphoreZirconHandleFUCHSIA", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_external_semaphore) skip |= OutputExtensionError("vkImportSemaphoreZirconHandleFUCHSIA", VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+ skip |= validate_struct_type("vkImportSemaphoreZirconHandleFUCHSIA", "pImportSemaphoreZirconHandleInfo", "VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA", pImportSemaphoreZirconHandleInfo, VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pImportSemaphoreZirconHandleInfo != NULL)
+ {
+ skip |= validate_struct_pnext("vkImportSemaphoreZirconHandleFUCHSIA", "pImportSemaphoreZirconHandleInfo->pNext", NULL, pImportSemaphoreZirconHandleInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+
+ skip |= validate_required_handle("vkImportSemaphoreZirconHandleFUCHSIA", "pImportSemaphoreZirconHandleInfo->semaphore", pImportSemaphoreZirconHandleInfo->semaphore);
+
+ skip |= validate_flags("vkImportSemaphoreZirconHandleFUCHSIA", "pImportSemaphoreZirconHandleInfo->flags", "VkSemaphoreImportFlagBits", AllVkSemaphoreImportFlagBits, pImportSemaphoreZirconHandleInfo->flags, kOptionalFlags, kVUIDUndefined);
+
+ skip |= validate_flags("vkImportSemaphoreZirconHandleFUCHSIA", "pImportSemaphoreZirconHandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pImportSemaphoreZirconHandleInfo->handleType, kRequiredSingleBit, kVUIDUndefined, kVUIDUndefined);
+ }
+ return skip;
+}
+
+bool StatelessValidation::PreCallValidateGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const {
+ bool skip = false;
+ if (!device_extensions.vk_khr_external_semaphore) skip |= OutputExtensionError("vkGetSemaphoreZirconHandleFUCHSIA", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+ if (!device_extensions.vk_khr_external_semaphore_capabilities) skip |= OutputExtensionError("vkGetSemaphoreZirconHandleFUCHSIA", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+ if (!device_extensions.vk_fuchsia_external_semaphore) skip |= OutputExtensionError("vkGetSemaphoreZirconHandleFUCHSIA", VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+ skip |= validate_struct_type("vkGetSemaphoreZirconHandleFUCHSIA", "pGetZirconHandleInfo", "VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA", pGetZirconHandleInfo, VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA, true, kVUIDUndefined, kVUIDUndefined);
+ if (pGetZirconHandleInfo != NULL)
+ {
+ skip |= validate_struct_pnext("vkGetSemaphoreZirconHandleFUCHSIA", "pGetZirconHandleInfo->pNext", NULL, pGetZirconHandleInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined, kVUIDUndefined);
+
+ skip |= validate_required_handle("vkGetSemaphoreZirconHandleFUCHSIA", "pGetZirconHandleInfo->semaphore", pGetZirconHandleInfo->semaphore);
+
+ skip |= validate_flags("vkGetSemaphoreZirconHandleFUCHSIA", "pGetZirconHandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pGetZirconHandleInfo->handleType, kRequiredSingleBit, kVUIDUndefined, kVUIDUndefined);
+ }
+ skip |= validate_required_pointer("vkGetSemaphoreZirconHandleFUCHSIA", "pZirconHandle", pZirconHandle, kVUIDUndefined);
+ return skip;
+}
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
bool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR(
diff --git a/layers/generated/parameter_validation.h b/layers/generated/parameter_validation.h
index 7ab0463..178b9fd 100644
--- a/layers/generated/parameter_validation.h
+++ b/layers/generated/parameter_validation.h
@@ -1970,6 +1970,61 @@
uint32_t queueFamilyIndex,
IDirectFB* dfb) const;
#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const;
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+bool PreCallValidateGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) const;
+#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
bool PreCallValidateCreateAccelerationStructureKHR(
VkDevice device,
diff --git a/layers/generated/thread_safety.cpp b/layers/generated/thread_safety.cpp
index f9377a5..f8bdc3d 100644
--- a/layers/generated/thread_safety.cpp
+++ b/layers/generated/thread_safety.cpp
@@ -7111,6 +7111,162 @@
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void ThreadSafety::PreCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection) {
+ StartReadObjectParentInstance(device, "vkCreateBufferCollectionFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkCreateBufferCollectionFUCHSIA");
+ if (result == VK_SUCCESS) {
+ CreateObject(*pCollection);
+ }
+}
+
+void ThreadSafety::PreCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo) {
+ StartReadObjectParentInstance(device, "vkSetBufferCollectionConstraintsFUCHSIA");
+ StartReadObject(collection, "vkSetBufferCollectionConstraintsFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkSetBufferCollectionConstraintsFUCHSIA");
+ FinishReadObject(collection, "vkSetBufferCollectionConstraintsFUCHSIA");
+}
+
+void ThreadSafety::PreCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+ StartReadObjectParentInstance(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA");
+ StartReadObject(collection, "vkSetBufferCollectionBufferConstraintsFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA");
+ FinishReadObject(collection, "vkSetBufferCollectionBufferConstraintsFUCHSIA");
+}
+
+void ThreadSafety::PreCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
+ StartReadObjectParentInstance(device, "vkDestroyBufferCollectionFUCHSIA");
+ StartReadObject(collection, "vkDestroyBufferCollectionFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
+ FinishReadObjectParentInstance(device, "vkDestroyBufferCollectionFUCHSIA");
+ FinishReadObject(collection, "vkDestroyBufferCollectionFUCHSIA");
+}
+
+void ThreadSafety::PreCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) {
+ StartReadObjectParentInstance(device, "vkGetBufferCollectionPropertiesFUCHSIA");
+ StartReadObject(collection, "vkGetBufferCollectionPropertiesFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkGetBufferCollectionPropertiesFUCHSIA");
+ FinishReadObject(collection, "vkGetBufferCollectionPropertiesFUCHSIA");
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void ThreadSafety::PreCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
+ StartReadObjectParentInstance(device, "vkGetMemoryZirconHandleFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkGetMemoryZirconHandleFUCHSIA");
+}
+
+void ThreadSafety::PreCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
+ StartReadObjectParentInstance(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA");
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void ThreadSafety::PreCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
+ StartReadObjectParentInstance(device, "vkImportSemaphoreZirconHandleFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkImportSemaphoreZirconHandleFUCHSIA");
+}
+
+void ThreadSafety::PreCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
+ StartReadObjectParentInstance(device, "vkGetSemaphoreZirconHandleFUCHSIA");
+}
+
+void ThreadSafety::PostCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result) {
+ FinishReadObjectParentInstance(device, "vkGetSemaphoreZirconHandleFUCHSIA");
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
void ThreadSafety::PreCallRecordCreateAccelerationStructureKHR(
diff --git a/layers/generated/thread_safety.h b/layers/generated/thread_safety.h
index 530c3fd..e29b750 100644
--- a/layers/generated/thread_safety.h
+++ b/layers/generated/thread_safety.h
@@ -326,6 +326,7 @@
counter<VkCommandPool> c_VkCommandPoolContents;
counter<VkAccelerationStructureKHR> c_VkAccelerationStructureKHR;
counter<VkBuffer> c_VkBuffer;
+ counter<VkBufferCollectionFUCHSIA> c_VkBufferCollectionFUCHSIA;
counter<VkBufferView> c_VkBufferView;
counter<VkCommandPool> c_VkCommandPool;
counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT;
@@ -378,6 +379,7 @@
#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
c_VkAccelerationStructureKHR("VkAccelerationStructureKHR", kVulkanObjectTypeAccelerationStructureKHR, this),
c_VkBuffer("VkBuffer", kVulkanObjectTypeBuffer, this),
+ c_VkBufferCollectionFUCHSIA("VkBufferCollectionFUCHSIA", kVulkanObjectTypeBufferCollectionFUCHSIA, this),
c_VkBufferView("VkBufferView", kVulkanObjectTypeBufferView, this),
c_VkCommandPool("VkCommandPool", kVulkanObjectTypeCommandPool, this),
c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", kVulkanObjectTypeDebugReportCallbackEXT, this),
@@ -466,6 +468,7 @@
#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
WRAPPER(VkAccelerationStructureKHR)
WRAPPER(VkBuffer)
+WRAPPER(VkBufferCollectionFUCHSIA)
WRAPPER(VkBufferView)
WRAPPER(VkCommandPool)
WRAPPER_PARENT_INSTANCE(VkDebugReportCallbackEXT)
@@ -4845,6 +4848,115 @@
VkResult result);
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PreCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection);
+
+void PostCallRecordCreateBufferCollectionFUCHSIA(
+ VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ VkResult result);
+
+void PreCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo);
+
+void PostCallRecordSetBufferCollectionConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageCreateInfo* pImageInfo,
+ VkResult result);
+
+void PreCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+
+void PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
+ VkResult result);
+
+void PreCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator);
+
+void PostCallRecordDestroyBufferCollectionFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator);
+
+void PreCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties);
+
+void PostCallRecordGetBufferCollectionPropertiesFUCHSIA(
+ VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties,
+ VkResult result);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PreCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+
+void PostCallRecordGetMemoryZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result);
+
+void PreCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+
+void PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t ZirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
+ VkResult result);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+void PreCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+
+void PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
+ VkResult result);
+
+void PreCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle);
+
+void PostCallRecordGetSemaphoreZirconHandleFUCHSIA(
+ VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle,
+ VkResult result);
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
void PreCallRecordCreateAccelerationStructureKHR(
diff --git a/layers/generated/vk_dispatch_table_helper.h b/layers/generated/vk_dispatch_table_helper.h
index b492bec..b2cc5a6 100644
--- a/layers/generated/vk_dispatch_table_helper.h
+++ b/layers/generated/vk_dispatch_table_helper.h
@@ -385,6 +385,33 @@
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
static VKAPI_ATTR VkBool32 VKAPI_CALL StubGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) { return VK_FALSE; };
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubSetBufferCollectionConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageCreateInfo* pImageInfo) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR void VKAPI_CALL StubDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) { };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t ZirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { return VK_SUCCESS; };
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_ENABLE_BETA_EXTENSIONS
static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; };
#endif // VK_ENABLE_BETA_EXTENSIONS
@@ -537,6 +564,7 @@
{"vkCopyMemoryToAccelerationStructureKHR", "VK_KHR_ray_tracing"},
{"vkCreateAccelerationStructureKHR", "VK_KHR_ray_tracing"},
{"vkCreateAccelerationStructureNV", "VK_NV_ray_tracing"},
+ {"vkCreateBufferCollectionFUCHSIA", "VK_FUCHSIA_buffer_collection"},
{"vkCreateDeferredOperationKHR", "VK_KHR_deferred_host_operations"},
{"vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1"},
{"vkCreateDescriptorUpdateTemplateKHR", "VK_KHR_descriptor_update_template"},
@@ -556,6 +584,7 @@
{"vkDeferredOperationJoinKHR", "VK_KHR_deferred_host_operations"},
{"vkDestroyAccelerationStructureKHR", "VK_KHR_ray_tracing"},
{"vkDestroyAccelerationStructureNV", "VK_NV_ray_tracing"},
+ {"vkDestroyBufferCollectionFUCHSIA", "VK_FUCHSIA_buffer_collection"},
{"vkDestroyDeferredOperationKHR", "VK_KHR_deferred_host_operations"},
{"vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1"},
{"vkDestroyDescriptorUpdateTemplateKHR", "VK_KHR_descriptor_update_template"},
@@ -571,6 +600,7 @@
{"vkGetAccelerationStructureMemoryRequirementsKHR", "VK_KHR_ray_tracing"},
{"vkGetAccelerationStructureMemoryRequirementsNV", "VK_NV_ray_tracing"},
{"vkGetAndroidHardwareBufferPropertiesANDROID", "VK_ANDROID_external_memory_android_hardware_buffer"},
+ {"vkGetBufferCollectionPropertiesFUCHSIA", "VK_FUCHSIA_buffer_collection"},
{"vkGetBufferDeviceAddress", "VK_VERSION_1_2"},
{"vkGetBufferDeviceAddressEXT", "VK_EXT_buffer_device_address"},
{"vkGetBufferDeviceAddressKHR", "VK_KHR_buffer_device_address"},
@@ -609,6 +639,8 @@
{"vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32"},
{"vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32"},
{"vkGetMemoryWin32HandlePropertiesKHR", "VK_KHR_external_memory_win32"},
+ {"vkGetMemoryZirconHandleFUCHSIA", "VK_FUCHSIA_external_memory"},
+ {"vkGetMemoryZirconHandlePropertiesFUCHSIA", "VK_FUCHSIA_external_memory"},
{"vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing"},
{"vkGetPerformanceParameterINTEL", "VK_INTEL_performance_query"},
{"vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties"},
@@ -624,6 +656,7 @@
{"vkGetSemaphoreCounterValueKHR", "VK_KHR_timeline_semaphore"},
{"vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd"},
{"vkGetSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32"},
+ {"vkGetSemaphoreZirconHandleFUCHSIA", "VK_FUCHSIA_external_semaphore"},
{"vkGetShaderInfoAMD", "VK_AMD_shader_info"},
{"vkGetSwapchainCounterEXT", "VK_EXT_display_control"},
{"vkGetSwapchainGrallocUsage2ANDROID", "VK_ANDROID_native_buffer"},
@@ -635,6 +668,7 @@
{"vkImportFenceWin32HandleKHR", "VK_KHR_external_fence_win32"},
{"vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd"},
{"vkImportSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32"},
+ {"vkImportSemaphoreZirconHandleFUCHSIA", "VK_FUCHSIA_external_semaphore"},
{"vkInitializePerformanceApiINTEL", "VK_INTEL_performance_query"},
{"vkMergeValidationCachesEXT", "VK_EXT_validation_cache"},
{"vkQueueBeginDebugUtilsLabelEXT", "VK_EXT_debug_utils"},
@@ -650,6 +684,8 @@
{"vkReleaseProfilingLockKHR", "VK_KHR_performance_query"},
{"vkResetQueryPool", "VK_VERSION_1_2"},
{"vkResetQueryPoolEXT", "VK_EXT_host_query_reset"},
+ {"vkSetBufferCollectionBufferConstraintsFUCHSIA", "VK_FUCHSIA_buffer_collection"},
+ {"vkSetBufferCollectionConstraintsFUCHSIA", "VK_FUCHSIA_buffer_collection"},
{"vkSetDebugUtilsObjectNameEXT", "VK_EXT_debug_utils"},
{"vkSetDebugUtilsObjectTagEXT", "VK_EXT_debug_utils"},
{"vkSetHdrMetadataEXT", "VK_EXT_hdr_metadata"},
@@ -1244,6 +1280,42 @@
if (table->SetPrivateDataEXT == nullptr) { table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)StubSetPrivateDataEXT; }
table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT) gpa(device, "vkGetPrivateDataEXT");
if (table->GetPrivateDataEXT == nullptr) { table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)StubGetPrivateDataEXT; }
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->CreateBufferCollectionFUCHSIA = (PFN_vkCreateBufferCollectionFUCHSIA) gpa(device, "vkCreateBufferCollectionFUCHSIA");
+ if (table->CreateBufferCollectionFUCHSIA == nullptr) { table->CreateBufferCollectionFUCHSIA = (PFN_vkCreateBufferCollectionFUCHSIA)StubCreateBufferCollectionFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->SetBufferCollectionConstraintsFUCHSIA = (PFN_vkSetBufferCollectionConstraintsFUCHSIA) gpa(device, "vkSetBufferCollectionConstraintsFUCHSIA");
+ if (table->SetBufferCollectionConstraintsFUCHSIA == nullptr) { table->SetBufferCollectionConstraintsFUCHSIA = (PFN_vkSetBufferCollectionConstraintsFUCHSIA)StubSetBufferCollectionConstraintsFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->SetBufferCollectionBufferConstraintsFUCHSIA = (PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA) gpa(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA");
+ if (table->SetBufferCollectionBufferConstraintsFUCHSIA == nullptr) { table->SetBufferCollectionBufferConstraintsFUCHSIA = (PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)StubSetBufferCollectionBufferConstraintsFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->DestroyBufferCollectionFUCHSIA = (PFN_vkDestroyBufferCollectionFUCHSIA) gpa(device, "vkDestroyBufferCollectionFUCHSIA");
+ if (table->DestroyBufferCollectionFUCHSIA == nullptr) { table->DestroyBufferCollectionFUCHSIA = (PFN_vkDestroyBufferCollectionFUCHSIA)StubDestroyBufferCollectionFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->GetBufferCollectionPropertiesFUCHSIA = (PFN_vkGetBufferCollectionPropertiesFUCHSIA) gpa(device, "vkGetBufferCollectionPropertiesFUCHSIA");
+ if (table->GetBufferCollectionPropertiesFUCHSIA == nullptr) { table->GetBufferCollectionPropertiesFUCHSIA = (PFN_vkGetBufferCollectionPropertiesFUCHSIA)StubGetBufferCollectionPropertiesFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->GetMemoryZirconHandleFUCHSIA = (PFN_vkGetMemoryZirconHandleFUCHSIA) gpa(device, "vkGetMemoryZirconHandleFUCHSIA");
+ if (table->GetMemoryZirconHandleFUCHSIA == nullptr) { table->GetMemoryZirconHandleFUCHSIA = (PFN_vkGetMemoryZirconHandleFUCHSIA)StubGetMemoryZirconHandleFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->GetMemoryZirconHandlePropertiesFUCHSIA = (PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA) gpa(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA");
+ if (table->GetMemoryZirconHandlePropertiesFUCHSIA == nullptr) { table->GetMemoryZirconHandlePropertiesFUCHSIA = (PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)StubGetMemoryZirconHandlePropertiesFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->ImportSemaphoreZirconHandleFUCHSIA = (PFN_vkImportSemaphoreZirconHandleFUCHSIA) gpa(device, "vkImportSemaphoreZirconHandleFUCHSIA");
+ if (table->ImportSemaphoreZirconHandleFUCHSIA == nullptr) { table->ImportSemaphoreZirconHandleFUCHSIA = (PFN_vkImportSemaphoreZirconHandleFUCHSIA)StubImportSemaphoreZirconHandleFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ table->GetSemaphoreZirconHandleFUCHSIA = (PFN_vkGetSemaphoreZirconHandleFUCHSIA) gpa(device, "vkGetSemaphoreZirconHandleFUCHSIA");
+ if (table->GetSemaphoreZirconHandleFUCHSIA == nullptr) { table->GetSemaphoreZirconHandleFUCHSIA = (PFN_vkGetSemaphoreZirconHandleFUCHSIA)StubGetSemaphoreZirconHandleFUCHSIA; }
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_ENABLE_BETA_EXTENSIONS
table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR) gpa(device, "vkCreateAccelerationStructureKHR");
if (table->CreateAccelerationStructureKHR == nullptr) { table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)StubCreateAccelerationStructureKHR; }
diff --git a/layers/generated/vk_enum_string_helper.h b/layers/generated/vk_enum_string_helper.h
index b256eeb..d745b05 100644
--- a/layers/generated/vk_enum_string_helper.h
+++ b/layers/generated/vk_enum_string_helper.h
@@ -194,6 +194,16 @@
return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO";
case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA";
+ case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA";
case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
@@ -398,6 +408,8 @@
return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
return "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV";
+ case VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA";
case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV";
case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
@@ -460,6 +472,8 @@
return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA";
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
@@ -984,6 +998,16 @@
return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
return "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD";
+ case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
+ case VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA";
+ case VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
+ return "VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
@@ -1202,6 +1226,8 @@
return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR";
case VK_OBJECT_TYPE_BUFFER:
return "VK_OBJECT_TYPE_BUFFER";
+ case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA:
+ return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA";
case VK_OBJECT_TYPE_BUFFER_VIEW:
return "VK_OBJECT_TYPE_BUFFER_VIEW";
case VK_OBJECT_TYPE_COMMAND_BUFFER:
@@ -4120,6 +4146,8 @@
return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA";
default:
return "Unhandled VkExternalMemoryHandleTypeFlagBits";
}
@@ -4302,6 +4330,8 @@
return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA";
default:
return "Unhandled VkExternalSemaphoreHandleTypeFlagBits";
}
@@ -4852,6 +4882,8 @@
return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA";
default:
return "Unhandled VkExternalMemoryHandleTypeFlagBitsKHR";
}
@@ -4918,6 +4950,8 @@
return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA";
default:
return "Unhandled VkExternalSemaphoreHandleTypeFlagBitsKHR";
}
@@ -5449,6 +5483,8 @@
{
case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT:
return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT";
case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
diff --git a/layers/generated/vk_extension_helper.h b/layers/generated/vk_extension_helper.h
index 6d7755a..2d47931 100644
--- a/layers/generated/vk_extension_helper.h
+++ b/layers/generated/vk_extension_helper.h
@@ -403,6 +403,9 @@
ExtEnabled vk_ext_validation_cache{kNotEnabled};
ExtEnabled vk_ext_vertex_attribute_divisor{kNotEnabled};
ExtEnabled vk_ext_ycbcr_image_arrays{kNotEnabled};
+ ExtEnabled vk_fuchsia_buffer_collection{kNotEnabled};
+ ExtEnabled vk_fuchsia_external_memory{kNotEnabled};
+ ExtEnabled vk_fuchsia_external_semaphore{kNotEnabled};
ExtEnabled vk_ggp_frame_token{kNotEnabled};
ExtEnabled vk_google_decorate_string{kNotEnabled};
ExtEnabled vk_google_display_timing{kNotEnabled};
@@ -656,6 +659,20 @@
{&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
std::make_pair(VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_ycbcr_image_arrays, {{
{&DeviceExtensions::vk_khr_sampler_ycbcr_conversion, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME}}})),
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ std::make_pair(VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_fuchsia_buffer_collection, {{
+ {&DeviceExtensions::vk_fuchsia_external_memory, VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME}}})),
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ std::make_pair(VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_fuchsia_external_memory, {{
+ {&DeviceExtensions::vk_khr_external_memory_capabilities, VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME},
+ {&DeviceExtensions::vk_khr_external_memory, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME}}})),
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ std::make_pair(VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_fuchsia_external_semaphore, {{
+ {&DeviceExtensions::vk_khr_external_semaphore_capabilities, VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME},
+ {&DeviceExtensions::vk_khr_external_semaphore, VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME}}})),
+#endif
#ifdef VK_USE_PLATFORM_GGP
std::make_pair(VK_GGP_FRAME_TOKEN_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ggp_frame_token, {{
{&DeviceExtensions::vk_khr_swapchain, VK_KHR_SWAPCHAIN_EXTENSION_NAME},
@@ -1046,6 +1063,15 @@
VK_EXT_VALIDATION_CACHE_EXTENSION_NAME,
VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
+#endif
#ifdef VK_USE_PLATFORM_GGP
VK_GGP_FRAME_TOKEN_EXTENSION_NAME,
#endif
diff --git a/layers/generated/vk_layer_dispatch_table.h b/layers/generated/vk_layer_dispatch_table.h
index e1e4de0..e287718 100644
--- a/layers/generated/vk_layer_dispatch_table.h
+++ b/layers/generated/vk_layer_dispatch_table.h
@@ -723,6 +723,39 @@
PFN_vkSetPrivateDataEXT SetPrivateDataEXT;
PFN_vkGetPrivateDataEXT GetPrivateDataEXT;
+ // ---- VK_FUCHSIA_buffer_collection extension commands
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkCreateBufferCollectionFUCHSIA CreateBufferCollectionFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkSetBufferCollectionConstraintsFUCHSIA SetBufferCollectionConstraintsFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA SetBufferCollectionBufferConstraintsFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkDestroyBufferCollectionFUCHSIA DestroyBufferCollectionFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkGetBufferCollectionPropertiesFUCHSIA GetBufferCollectionPropertiesFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+ // ---- VK_FUCHSIA_external_memory extension commands
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkGetMemoryZirconHandleFUCHSIA GetMemoryZirconHandleFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA GetMemoryZirconHandlePropertiesFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+ // ---- VK_FUCHSIA_external_semaphore extension commands
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkImportSemaphoreZirconHandleFUCHSIA ImportSemaphoreZirconHandleFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ PFN_vkGetSemaphoreZirconHandleFUCHSIA GetSemaphoreZirconHandleFUCHSIA;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
// ---- VK_KHR_ray_tracing extension commands
#ifdef VK_ENABLE_BETA_EXTENSIONS
PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR;
diff --git a/layers/generated/vk_object_types.h b/layers/generated/vk_object_types.h
index 0b2236d..8410f5d 100644
--- a/layers/generated/vk_object_types.h
+++ b/layers/generated/vk_object_types.h
@@ -76,7 +76,8 @@
kVulkanObjectTypePerformanceConfigurationINTEL = 37,
kVulkanObjectTypeIndirectCommandsLayoutNV = 38,
kVulkanObjectTypePrivateDataSlotEXT = 39,
- kVulkanObjectTypeMax = 40,
+ kVulkanObjectTypeBufferCollectionFUCHSIA = 40,
+ kVulkanObjectTypeMax = 41,
// Aliases for backwards compatibilty of "promoted" types
kVulkanObjectTypeDescriptorUpdateTemplateKHR = kVulkanObjectTypeDescriptorUpdateTemplate,
kVulkanObjectTypeSamplerYcbcrConversionKHR = kVulkanObjectTypeSamplerYcbcrConversion,
@@ -125,6 +126,7 @@
"VkPerformanceConfigurationINTEL",
"VkIndirectCommandsLayoutNV",
"VkPrivateDataSlotEXT",
+ "VkBufferCollectionFUCHSIA",
};
// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version
@@ -173,6 +175,11 @@
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypePerformanceConfigurationINTEL
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeIndirectCommandsLayoutNV
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypePrivateDataSlotEXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT, // kVulkanObjectTypeBufferCollectionFUCHSIA
+#else
+ VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeBufferCollectionFUCHSIA
+#endif
};
// Helper function to get Official Vulkan VkObjectType enum from the internal layers version
@@ -217,6 +224,7 @@
case kVulkanObjectTypePerformanceConfigurationINTEL: return VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL;
case kVulkanObjectTypeIndirectCommandsLayoutNV: return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV;
case kVulkanObjectTypePrivateDataSlotEXT: return VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT;
+ case kVulkanObjectTypeBufferCollectionFUCHSIA: return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA;
default: return VK_OBJECT_TYPE_UNKNOWN;
}
};
@@ -263,6 +271,7 @@
case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: return kVulkanObjectTypePerformanceConfigurationINTEL;
case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: return kVulkanObjectTypeIndirectCommandsLayoutNV;
case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT: return kVulkanObjectTypePrivateDataSlotEXT;
+ case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: return kVulkanObjectTypeBufferCollectionFUCHSIA;
default: return kVulkanObjectTypeUnknown;
}
};
@@ -304,6 +313,7 @@
case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: return VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: return VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR;
+ case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT: return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA;
default: return VK_OBJECT_TYPE_UNKNOWN;
}
}
@@ -345,6 +355,7 @@
case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: return VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: return VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT;
case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: return VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
+ case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: return VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT;
default: return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
}
}
@@ -450,6 +461,19 @@
template <> struct VulkanObjectTypeInfo<kVulkanObjectTypeBuffer> {
typedef VkBuffer Type;
};
+#ifdef VK_USE_PLATFORM_FUCHSIA
+template <> struct VkHandleInfo<VkBufferCollectionFUCHSIA> {
+ static const VulkanObjectType kVulkanObjectType = kVulkanObjectTypeBufferCollectionFUCHSIA;
+ static const VkDebugReportObjectTypeEXT kDebugReportObjectType = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT;
+ static const VkObjectType kVkObjectType = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA;
+ static const char* Typename() {
+ return "VkBufferCollectionFUCHSIA";
+ }
+};
+template <> struct VulkanObjectTypeInfo<kVulkanObjectTypeBufferCollectionFUCHSIA> {
+ typedef VkBufferCollectionFUCHSIA Type;
+};
+#endif
template <> struct VkHandleInfo<VkBufferView> {
static const VulkanObjectType kVulkanObjectType = kVulkanObjectTypeBufferView;
static const VkDebugReportObjectTypeEXT kDebugReportObjectType = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT;
diff --git a/layers/generated/vk_safe_struct.cpp b/layers/generated/vk_safe_struct.cpp
index 5690393..0717a0a 100644
--- a/layers/generated/vk_safe_struct.cpp
+++ b/layers/generated/vk_safe_struct.cpp
@@ -32724,6 +32724,771 @@
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ collectionToken(in_struct->collectionToken)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ collectionToken = copy_src.collectionToken;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA& safe_VkBufferCollectionCreateInfoFUCHSIA::operator=(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ collectionToken = copy_src.collectionToken;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::~safe_VkBufferCollectionCreateInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ collectionToken = in_struct->collectionToken;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ collectionToken = copy_src->collectionToken;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkFuchsiaImageFormatFUCHSIA::safe_VkFuchsiaImageFormatFUCHSIA(const VkFuchsiaImageFormatFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ imageFormat(in_struct->imageFormat),
+ imageFormatSize(in_struct->imageFormatSize)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkFuchsiaImageFormatFUCHSIA::safe_VkFuchsiaImageFormatFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA),
+ pNext(nullptr),
+ imageFormat(nullptr)
+{}
+
+safe_VkFuchsiaImageFormatFUCHSIA::safe_VkFuchsiaImageFormatFUCHSIA(const safe_VkFuchsiaImageFormatFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ imageFormat = copy_src.imageFormat;
+ imageFormatSize = copy_src.imageFormatSize;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFuchsiaImageFormatFUCHSIA& safe_VkFuchsiaImageFormatFUCHSIA::operator=(const safe_VkFuchsiaImageFormatFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ imageFormat = copy_src.imageFormat;
+ imageFormatSize = copy_src.imageFormatSize;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkFuchsiaImageFormatFUCHSIA::~safe_VkFuchsiaImageFormatFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkFuchsiaImageFormatFUCHSIA::initialize(const VkFuchsiaImageFormatFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ imageFormat = in_struct->imageFormat;
+ imageFormatSize = in_struct->imageFormatSize;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkFuchsiaImageFormatFUCHSIA::initialize(const safe_VkFuchsiaImageFormatFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ imageFormat = copy_src->imageFormat;
+ imageFormatSize = copy_src->imageFormatSize;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ collection(in_struct->collection),
+ index(in_struct->index)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA& safe_VkImportMemoryBufferCollectionFUCHSIA::operator=(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::~safe_VkImportMemoryBufferCollectionFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ collection = in_struct->collection;
+ index = in_struct->index;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ collection = copy_src->collection;
+ index = copy_src->index;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ collection(in_struct->collection),
+ index(in_struct->index)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA& safe_VkBufferCollectionImageCreateInfoFUCHSIA::operator=(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::~safe_VkBufferCollectionImageCreateInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ collection = in_struct->collection;
+ index = in_struct->index;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ collection = copy_src->collection;
+ index = copy_src->index;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ pBufferCreateInfo(nullptr),
+ requiredFormatFeatures(in_struct->requiredFormatFeatures),
+ minCount(in_struct->minCount)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+ if (in_struct->pBufferCreateInfo)
+ pBufferCreateInfo = new safe_VkBufferCreateInfo(in_struct->pBufferCreateInfo);
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA),
+ pNext(nullptr),
+ pBufferCreateInfo(nullptr)
+{}
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ pBufferCreateInfo = nullptr;
+ requiredFormatFeatures = copy_src.requiredFormatFeatures;
+ minCount = copy_src.minCount;
+ pNext = SafePnextCopy(copy_src.pNext);
+ if (copy_src.pBufferCreateInfo)
+ pBufferCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pBufferCreateInfo);
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA& safe_VkBufferConstraintsInfoFUCHSIA::operator=(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pBufferCreateInfo)
+ delete pBufferCreateInfo;
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ pBufferCreateInfo = nullptr;
+ requiredFormatFeatures = copy_src.requiredFormatFeatures;
+ minCount = copy_src.minCount;
+ pNext = SafePnextCopy(copy_src.pNext);
+ if (copy_src.pBufferCreateInfo)
+ pBufferCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pBufferCreateInfo);
+
+ return *this;
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA::~safe_VkBufferConstraintsInfoFUCHSIA()
+{
+ if (pBufferCreateInfo)
+ delete pBufferCreateInfo;
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ pBufferCreateInfo = nullptr;
+ requiredFormatFeatures = in_struct->requiredFormatFeatures;
+ minCount = in_struct->minCount;
+ pNext = SafePnextCopy(in_struct->pNext);
+ if (in_struct->pBufferCreateInfo)
+ pBufferCreateInfo = new safe_VkBufferCreateInfo(in_struct->pBufferCreateInfo);
+}
+
+void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ pBufferCreateInfo = nullptr;
+ requiredFormatFeatures = copy_src->requiredFormatFeatures;
+ minCount = copy_src->minCount;
+ pNext = SafePnextCopy(copy_src->pNext);
+ if (copy_src->pBufferCreateInfo)
+ pBufferCreateInfo = new safe_VkBufferCreateInfo(*copy_src->pBufferCreateInfo);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ collection(in_struct->collection),
+ index(in_struct->index)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA& safe_VkBufferCollectionBufferCreateInfoFUCHSIA::operator=(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ collection = copy_src.collection;
+ index = copy_src.index;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::~safe_VkBufferCollectionBufferCreateInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ collection = in_struct->collection;
+ index = in_struct->index;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ collection = copy_src->collection;
+ index = copy_src->index;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ memoryTypeBits(in_struct->memoryTypeBits),
+ count(in_struct->count)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ memoryTypeBits = copy_src.memoryTypeBits;
+ count = copy_src.count;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA& safe_VkBufferCollectionPropertiesFUCHSIA::operator=(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ memoryTypeBits = copy_src.memoryTypeBits;
+ count = copy_src.count;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::~safe_VkBufferCollectionPropertiesFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ memoryTypeBits = in_struct->memoryTypeBits;
+ count = in_struct->count;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ memoryTypeBits = copy_src->memoryTypeBits;
+ count = copy_src->count;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ handleType = copy_src.handleType;
+ handle = copy_src.handle;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA& safe_VkImportMemoryZirconHandleInfoFUCHSIA::operator=(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ handleType = copy_src.handleType;
+ handle = copy_src.handle;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::~safe_VkImportMemoryZirconHandleInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ handleType = copy_src->handleType;
+ handle = copy_src->handle;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ memoryTypeBits(in_struct->memoryTypeBits)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ memoryTypeBits = copy_src.memoryTypeBits;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA& safe_VkMemoryZirconHandlePropertiesFUCHSIA::operator=(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ memoryTypeBits = copy_src.memoryTypeBits;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::~safe_VkMemoryZirconHandlePropertiesFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ memoryTypeBits = in_struct->memoryTypeBits;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ memoryTypeBits = copy_src->memoryTypeBits;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ memory(in_struct->memory),
+ handleType(in_struct->handleType)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ memory = copy_src.memory;
+ handleType = copy_src.handleType;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA& safe_VkMemoryGetZirconHandleInfoFUCHSIA::operator=(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ memory = copy_src.memory;
+ handleType = copy_src.handleType;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::~safe_VkMemoryGetZirconHandleInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ memory = in_struct->memory;
+ handleType = in_struct->handleType;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ memory = copy_src->memory;
+ handleType = copy_src->handleType;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ semaphore(in_struct->semaphore),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ semaphore = copy_src.semaphore;
+ flags = copy_src.flags;
+ handleType = copy_src.handleType;
+ handle = copy_src.handle;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::operator=(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ semaphore = copy_src.semaphore;
+ flags = copy_src.flags;
+ handleType = copy_src.handleType;
+ handle = copy_src.handle;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ semaphore = in_struct->semaphore;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ semaphore = copy_src->semaphore;
+ flags = copy_src->flags;
+ handleType = copy_src->handleType;
+ handle = copy_src->handle;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct) :
+ sType(in_struct->sType),
+ semaphore(in_struct->semaphore),
+ handleType(in_struct->handleType)
+{
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA() :
+ sType(VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA),
+ pNext(nullptr)
+{}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src)
+{
+ sType = copy_src.sType;
+ semaphore = copy_src.semaphore;
+ handleType = copy_src.handleType;
+ pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::operator=(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src)
+{
+ if (©_src == this) return *this;
+
+ if (pNext)
+ FreePnextChain(pNext);
+
+ sType = copy_src.sType;
+ semaphore = copy_src.semaphore;
+ handleType = copy_src.handleType;
+ pNext = SafePnextCopy(copy_src.pNext);
+
+ return *this;
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA()
+{
+ if (pNext)
+ FreePnextChain(pNext);
+}
+
+void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct)
+{
+ sType = in_struct->sType;
+ semaphore = in_struct->semaphore;
+ handleType = in_struct->handleType;
+ pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src)
+{
+ sType = copy_src->sType;
+ semaphore = copy_src->semaphore;
+ handleType = copy_src->handleType;
+ pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -35142,6 +35907,23 @@
safe_pNext = new safe_VkExternalFormatANDROID(reinterpret_cast<const VkExternalFormatANDROID *>(pNext));
break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ case VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA:
+ safe_pNext = new safe_VkFuchsiaImageFormatFUCHSIA(reinterpret_cast<const VkFuchsiaImageFormatFUCHSIA *>(pNext));
+ break;
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+ safe_pNext = new safe_VkImportMemoryBufferCollectionFUCHSIA(reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>(pNext));
+ break;
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+ safe_pNext = new safe_VkBufferCollectionImageCreateInfoFUCHSIA(reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>(pNext));
+ break;
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+ safe_pNext = new safe_VkBufferCollectionBufferCreateInfoFUCHSIA(reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA *>(pNext));
+ break;
+ case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+ safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext));
+ break;
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_GGP
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast<const VkPresentFrameTokenGGP *>(pNext));
@@ -35920,6 +36702,23 @@
delete reinterpret_cast<const safe_VkExternalFormatANDROID *>(header);
break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ case VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA:
+ delete reinterpret_cast<const safe_VkFuchsiaImageFormatFUCHSIA *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+ delete reinterpret_cast<const safe_VkImportMemoryBufferCollectionFUCHSIA *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+ delete reinterpret_cast<const safe_VkBufferCollectionImageCreateInfoFUCHSIA *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+ delete reinterpret_cast<const safe_VkBufferCollectionBufferCreateInfoFUCHSIA *>(header);
+ break;
+ case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+ delete reinterpret_cast<const safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
+ break;
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_GGP
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
delete reinterpret_cast<const safe_VkPresentFrameTokenGGP *>(header);
diff --git a/layers/generated/vk_safe_struct.h b/layers/generated/vk_safe_struct.h
index ad1fe8e..f51de8b 100644
--- a/layers/generated/vk_safe_struct.h
+++ b/layers/generated/vk_safe_struct.h
@@ -7628,6 +7628,223 @@
};
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkBufferCollectionCreateInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ zx_handle_t collectionToken;
+ safe_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* in_struct);
+ safe_VkBufferCollectionCreateInfoFUCHSIA(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionCreateInfoFUCHSIA();
+ ~safe_VkBufferCollectionCreateInfoFUCHSIA();
+ void initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src);
+ VkBufferCollectionCreateInfoFUCHSIA *ptr() { return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>(this); }
+ VkBufferCollectionCreateInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkFuchsiaImageFormatFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ const void* imageFormat;
+ uint32_t imageFormatSize;
+ safe_VkFuchsiaImageFormatFUCHSIA(const VkFuchsiaImageFormatFUCHSIA* in_struct);
+ safe_VkFuchsiaImageFormatFUCHSIA(const safe_VkFuchsiaImageFormatFUCHSIA& copy_src);
+ safe_VkFuchsiaImageFormatFUCHSIA& operator=(const safe_VkFuchsiaImageFormatFUCHSIA& copy_src);
+ safe_VkFuchsiaImageFormatFUCHSIA();
+ ~safe_VkFuchsiaImageFormatFUCHSIA();
+ void initialize(const VkFuchsiaImageFormatFUCHSIA* in_struct);
+ void initialize(const safe_VkFuchsiaImageFormatFUCHSIA* copy_src);
+ VkFuchsiaImageFormatFUCHSIA *ptr() { return reinterpret_cast<VkFuchsiaImageFormatFUCHSIA *>(this); }
+ VkFuchsiaImageFormatFUCHSIA const *ptr() const { return reinterpret_cast<VkFuchsiaImageFormatFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkImportMemoryBufferCollectionFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCollectionFUCHSIA collection;
+ uint32_t index;
+ safe_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA* in_struct);
+ safe_VkImportMemoryBufferCollectionFUCHSIA(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src);
+ safe_VkImportMemoryBufferCollectionFUCHSIA& operator=(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src);
+ safe_VkImportMemoryBufferCollectionFUCHSIA();
+ ~safe_VkImportMemoryBufferCollectionFUCHSIA();
+ void initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct);
+ void initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src);
+ VkImportMemoryBufferCollectionFUCHSIA *ptr() { return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA *>(this); }
+ VkImportMemoryBufferCollectionFUCHSIA const *ptr() const { return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkBufferCollectionImageCreateInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCollectionFUCHSIA collection;
+ uint32_t index;
+ safe_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct);
+ safe_VkBufferCollectionImageCreateInfoFUCHSIA(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionImageCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionImageCreateInfoFUCHSIA();
+ ~safe_VkBufferCollectionImageCreateInfoFUCHSIA();
+ void initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src);
+ VkBufferCollectionImageCreateInfoFUCHSIA *ptr() { return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>(this); }
+ VkBufferCollectionImageCreateInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkBufferConstraintsInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ safe_VkBufferCreateInfo* pBufferCreateInfo;
+ VkFormatFeatureFlags requiredFormatFeatures;
+ uint32_t minCount;
+ safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct);
+ safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src);
+ safe_VkBufferConstraintsInfoFUCHSIA& operator=(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src);
+ safe_VkBufferConstraintsInfoFUCHSIA();
+ ~safe_VkBufferConstraintsInfoFUCHSIA();
+ void initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src);
+ VkBufferConstraintsInfoFUCHSIA *ptr() { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>(this); }
+ VkBufferConstraintsInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkBufferCollectionBufferCreateInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCollectionFUCHSIA collection;
+ uint32_t index;
+ safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct);
+ safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionBufferCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+ safe_VkBufferCollectionBufferCreateInfoFUCHSIA();
+ ~safe_VkBufferCollectionBufferCreateInfoFUCHSIA();
+ void initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src);
+ VkBufferCollectionBufferCreateInfoFUCHSIA *ptr() { return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>(this); }
+ VkBufferCollectionBufferCreateInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkBufferCollectionPropertiesFUCHSIA {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t memoryTypeBits;
+ uint32_t count;
+ safe_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* in_struct);
+ safe_VkBufferCollectionPropertiesFUCHSIA(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src);
+ safe_VkBufferCollectionPropertiesFUCHSIA& operator=(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src);
+ safe_VkBufferCollectionPropertiesFUCHSIA();
+ ~safe_VkBufferCollectionPropertiesFUCHSIA();
+ void initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct);
+ void initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src);
+ VkBufferCollectionPropertiesFUCHSIA *ptr() { return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>(this); }
+ VkBufferCollectionPropertiesFUCHSIA const *ptr() const { return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkImportMemoryZirconHandleInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBits handleType;
+ zx_handle_t handle;
+ safe_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct);
+ safe_VkImportMemoryZirconHandleInfoFUCHSIA(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkImportMemoryZirconHandleInfoFUCHSIA& operator=(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkImportMemoryZirconHandleInfoFUCHSIA();
+ ~safe_VkImportMemoryZirconHandleInfoFUCHSIA();
+ void initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src);
+ VkImportMemoryZirconHandleInfoFUCHSIA *ptr() { return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA *>(this); }
+ VkImportMemoryZirconHandleInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkMemoryZirconHandlePropertiesFUCHSIA {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t memoryTypeBits;
+ safe_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct);
+ safe_VkMemoryZirconHandlePropertiesFUCHSIA(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src);
+ safe_VkMemoryZirconHandlePropertiesFUCHSIA& operator=(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src);
+ safe_VkMemoryZirconHandlePropertiesFUCHSIA();
+ ~safe_VkMemoryZirconHandlePropertiesFUCHSIA();
+ void initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct);
+ void initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src);
+ VkMemoryZirconHandlePropertiesFUCHSIA *ptr() { return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>(this); }
+ VkMemoryZirconHandlePropertiesFUCHSIA const *ptr() const { return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkMemoryGetZirconHandleInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+ VkExternalMemoryHandleTypeFlagBits handleType;
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct);
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA& operator=(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkMemoryGetZirconHandleInfoFUCHSIA();
+ ~safe_VkMemoryGetZirconHandleInfoFUCHSIA();
+ void initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src);
+ VkMemoryGetZirconHandleInfoFUCHSIA *ptr() { return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA *>(this); }
+ VkMemoryGetZirconHandleInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkImportSemaphoreZirconHandleInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkSemaphoreImportFlags flags;
+ VkExternalSemaphoreHandleTypeFlagBits handleType;
+ zx_handle_t handle;
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct);
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& operator=(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkImportSemaphoreZirconHandleInfoFUCHSIA();
+ ~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA();
+ void initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src);
+ VkImportSemaphoreZirconHandleInfoFUCHSIA *ptr() { return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA *>(this); }
+ VkImportSemaphoreZirconHandleInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkSemaphoreGetZirconHandleInfoFUCHSIA {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBits handleType;
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct);
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& operator=(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+ safe_VkSemaphoreGetZirconHandleInfoFUCHSIA();
+ ~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA();
+ void initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct);
+ void initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src);
+ VkSemaphoreGetZirconHandleInfoFUCHSIA *ptr() { return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA *>(this); }
+ VkSemaphoreGetZirconHandleInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA const *>(this); }
+};
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_ENABLE_BETA_EXTENSIONS
union safe_VkDeviceOrHostAddressKHR {
VkDeviceAddress deviceAddress;
diff --git a/layers/generated/vk_typemap_helper.h b/layers/generated/vk_typemap_helper.h
index 6099b96..68d3401 100644
--- a/layers/generated/vk_typemap_helper.h
+++ b/layers/generated/vk_typemap_helper.h
@@ -3906,6 +3906,138 @@
};
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkBufferCollectionCreateInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA> {
+ typedef VkBufferCollectionCreateInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkFuchsiaImageFormatFUCHSIA to id VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA
+template <> struct LvlTypeMap<VkFuchsiaImageFormatFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_FUCHSIA_IMAGE_FORMAT_FUCHSIA> {
+ typedef VkFuchsiaImageFormatFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportMemoryBufferCollectionFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA
+template <> struct LvlTypeMap<VkImportMemoryBufferCollectionFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA> {
+ typedef VkImportMemoryBufferCollectionFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionImageCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkBufferCollectionImageCreateInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA> {
+ typedef VkBufferCollectionImageCreateInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkBufferConstraintsInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA> {
+ typedef VkBufferConstraintsInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionBufferCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkBufferCollectionBufferCreateInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA> {
+ typedef VkBufferCollectionBufferCreateInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionPropertiesFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA
+template <> struct LvlTypeMap<VkBufferCollectionPropertiesFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA> {
+ typedef VkBufferCollectionPropertiesFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportMemoryZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkImportMemoryZirconHandleInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA> {
+ typedef VkImportMemoryZirconHandleInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkMemoryZirconHandlePropertiesFUCHSIA to id VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA
+template <> struct LvlTypeMap<VkMemoryZirconHandlePropertiesFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA> {
+ typedef VkMemoryZirconHandlePropertiesFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkMemoryGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkMemoryGetZirconHandleInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEMP_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA> {
+ typedef VkMemoryGetZirconHandleInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportSemaphoreZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkImportSemaphoreZirconHandleInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEMP_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA> {
+ typedef VkImportSemaphoreZirconHandleInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkSemaphoreGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA
+template <> struct LvlTypeMap<VkSemaphoreGetZirconHandleInfoFUCHSIA> {
+ static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEMP_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA> {
+ typedef VkSemaphoreGetZirconHandleInfoFUCHSIA Type;
+};
+
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_ENABLE_BETA_EXTENSIONS
// Map type VkRayTracingShaderGroupCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR
template <> struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoKHR> {
diff --git a/layers/parameter_validation_utils.cpp b/layers/parameter_validation_utils.cpp
index 21b7fb4..9e49a30 100644
--- a/layers/parameter_validation_utils.cpp
+++ b/layers/parameter_validation_utils.cpp
@@ -229,6 +229,7 @@
tmp_features2_state.features = {};
}
// Use pCreateInfo->pNext to get full chain
+ FreePnextChain(stateless_validation->device_createinfo_pnext);
stateless_validation->device_createinfo_pnext = SafePnextCopy(pCreateInfo->pNext);
stateless_validation->physical_device_features2 = tmp_features2_state;
}
diff --git a/layers/state_tracker.cpp b/layers/state_tracker.cpp
index 1a8ba24..4b026f5 100644
--- a/layers/state_tracker.cpp
+++ b/layers/state_tracker.cpp
@@ -4923,6 +4923,16 @@
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_FUCHSIA
+void ValidationStateTracker::PostCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
+ VkSurfaceKHR *pSurface, VkResult result) {
+ if (VK_SUCCESS != result) return;
+ RecordVulkanSurface(pSurface);
+}
+#endif // VK_USE_PLATFORM_FUCHSIA
+
#ifdef VK_USE_PLATFORM_IOS_MVK
void ValidationStateTracker::PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
diff --git a/layers/state_tracker.h b/layers/state_tracker.h
index 7cb3404..a1cd210 100644
--- a/layers/state_tracker.h
+++ b/layers/state_tracker.h
@@ -1136,6 +1136,11 @@
void PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_FUCHSIA
+ void PostCallRecordCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+ VkResult result);
+#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_IOS_MVK
void PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp
index e794de6..804d3a1 100644
--- a/layers/vk_layer_utils.cpp
+++ b/layers/vk_layer_utils.cpp
@@ -209,20 +209,3 @@
}
}
-VK_LAYER_EXPORT VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func) {
- VkLayerInstanceCreateInfo *chain_info = (VkLayerInstanceCreateInfo *)pCreateInfo->pNext;
- while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && chain_info->function == func)) {
- chain_info = (VkLayerInstanceCreateInfo *)chain_info->pNext;
- }
- assert(chain_info != NULL);
- return chain_info;
-}
-
-VK_LAYER_EXPORT VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func) {
- VkLayerDeviceCreateInfo *chain_info = (VkLayerDeviceCreateInfo *)pCreateInfo->pNext;
- while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && chain_info->function == func)) {
- chain_info = (VkLayerDeviceCreateInfo *)chain_info->pNext;
- }
- assert(chain_info != NULL);
- return chain_info;
-}
diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h
index 81bcf29..7771b75 100644
--- a/layers/vk_layer_utils.h
+++ b/layers/vk_layer_utils.h
@@ -29,6 +29,7 @@
#include <vector>
#include <set>
#include "cast_utils.h"
+#include "vk_layer_utils_minimal.h"
#include "vk_format_utils.h"
#include "vk_layer_logging.h"
@@ -138,12 +139,6 @@
return stream_join(stream, sep, values.cbegin(), values.cend());
}
-typedef void *dispatch_key;
-static inline dispatch_key get_dispatch_key(const void *object) { return (dispatch_key) * (VkLayerDispatchTable **)object; }
-
-VK_LAYER_EXPORT VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func);
-VK_LAYER_EXPORT VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func);
-
static inline bool IsPowerOfTwo(unsigned x) { return x && !(x & (x - 1)); }
static inline uint32_t SampleCountSize(VkSampleCountFlagBits sample_count) {
@@ -230,6 +225,14 @@
#include <shared_mutex>
#endif
+#ifndef NO_THREAD_SAFETY_ANALYSIS
+#if defined(__clang__)
+#define NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
+#else
+#define NO_THREAD_SAFETY_ANALYSIS
+#endif
+#endif
+
class ReadWriteLock {
private:
#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2 && \
@@ -240,9 +243,9 @@
#endif
public:
- void lock() { m_lock.lock(); }
+ void lock() NO_THREAD_SAFETY_ANALYSIS { m_lock.lock(); }
+ void unlock() NO_THREAD_SAFETY_ANALYSIS { m_lock.unlock(); }
bool try_lock() { return m_lock.try_lock(); }
- void unlock() { m_lock.unlock(); }
#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2 && \
(!defined(_LIBCPP_VERSION) || __cplusplus >= 201703)
void lock_shared() { m_lock.lock_shared(); }
diff --git a/layers/vk_layer_utils_minimal.cpp b/layers/vk_layer_utils_minimal.cpp
new file mode 100644
index 0000000..c47ae3e
--- /dev/null
+++ b/layers/vk_layer_utils_minimal.cpp
@@ -0,0 +1,47 @@
+/* Copyright (c) 2015-2016, 2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2016, 2019 Valve Corporation
+ * Copyright (c) 2015-2016, 2019 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Dave Houlton <daveh@lunarg.com>
+ *
+ */
+
+#include <cassert>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "vulkan/vulkan.h"
+#include "vk_layer_utils_minimal.h"
+
+VK_LAYER_EXPORT VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func) {
+ VkLayerInstanceCreateInfo *chain_info = (VkLayerInstanceCreateInfo *)pCreateInfo->pNext;
+ while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && chain_info->function == func)) {
+ chain_info = (VkLayerInstanceCreateInfo *)chain_info->pNext;
+ }
+ assert(chain_info != NULL);
+ return chain_info;
+}
+
+VK_LAYER_EXPORT VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func) {
+ VkLayerDeviceCreateInfo *chain_info = (VkLayerDeviceCreateInfo *)pCreateInfo->pNext;
+ while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && chain_info->function == func)) {
+ chain_info = (VkLayerDeviceCreateInfo *)chain_info->pNext;
+ }
+ assert(chain_info != NULL);
+ return chain_info;
+}
diff --git a/layers/vk_layer_utils_minimal.h b/layers/vk_layer_utils_minimal.h
new file mode 100644
index 0000000..390f815
--- /dev/null
+++ b/layers/vk_layer_utils_minimal.h
@@ -0,0 +1,35 @@
+/* Copyright (c) 2015-2017, 2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2017, 2019 Valve Corporation
+ * Copyright (c) 2015-2017, 2019 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: Dave Houlton <daveh@lunarg.com>
+ */
+
+#pragma once
+
+#include <vulkan/vk_layer.h>
+#include "vk_layer_dispatch_table.h"
+
+#ifdef __cplusplus
+
+typedef void *dispatch_key;
+static inline dispatch_key get_dispatch_key(const void *object) { return (dispatch_key) * (VkLayerDispatchTable **)object; }
+
+VK_LAYER_EXPORT VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func);
+VK_LAYER_EXPORT VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func);
+
+#endif
diff --git a/layers/vk_loader_platform.h b/layers/vk_loader_platform.h
index 3c7528b..e490f03 100644
--- a/layers/vk_loader_platform.h
+++ b/layers/vk_loader_platform.h
@@ -28,12 +28,16 @@
#include <WinSock2.h>
#endif // _WIN32
+#if defined(__Fuchsia__)
+#include "dlopen_fuchsia.h"
+#endif // defined(__Fuchsia__)
+
#include "vulkan/vk_platform.h"
// sdk_platform header redefines NOMINMAX
#undef NOMINMAX
#include "vulkan/vk_sdk_platform.h"
-#if defined(__linux__) || defined(__APPLE__)
+#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__)
/* Linux-specific common code: */
// Headers:
@@ -101,14 +105,27 @@
// Dynamic Loading of libraries:
typedef void *loader_platform_dl_handle;
-static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) {
+static inline loader_platform_dl_handle loader_platform_open_library_or_driver(const char *libPath, bool driver) {
+#ifdef __Fuchsia__
+ return dlopen_fuchsia(libPath, RTLD_LAZY | RTLD_LOCAL, driver);
+#else
// When loading the library, we use RTLD_LAZY so that not all symbols have to be
// resolved at this time (which improves performance). Note that if not all symbols
// can be resolved, this could cause crashes later. Use the LD_BIND_NOW environment
// variable to force all symbols to be resolved here.
return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL);
+#endif
}
-static inline const char *loader_platform_open_library_error(const char *libPath) { return dlerror(); }
+static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) {
+ return loader_platform_open_library_or_driver(libPath, false);
+}
+static inline const char *loader_platform_open_library_error(const char *libPath) {
+#ifdef __Fuchsia__
+ return dlerror_fuchsia();
+#else
+ return dlerror();
+#endif
+}
static inline void loader_platform_close_library(loader_platform_dl_handle library) { dlclose(library); }
static inline void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) {
assert(library);
