Switch to using pre-generated header files
Generating them was adding 10s of seconds to the
build time.
Change-Id: Id932fc775771d2e22f2c65822f2ff973232d1aa2
diff --git a/BUILD.gn b/BUILD.gn
index 8d7aa0f..3cd4b3a 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -33,45 +33,9 @@
}
group("extra_vulkan_headers") {
- public_configs = [ ":include_extra_vulkan_headers"]
- deps = [ ":generate_extra_vulkan_headers" ]
+ public_configs = [ ":include_extra_vulkan_headers" ]
}
config("include_extra_vulkan_headers") {
- include_dirs = [ "$target_gen_dir/generated/include" ]
-}
-
-action("generate_extra_vulkan_headers") {
- script = "build-fuchsia/fuchsia-generate.sh"
- args = [ rebase_path(target_gen_dir, "." ) ]
- inputs = [
- "scripts/dispatch_table_helper_generator.py",
- "scripts/helper_file_generator.py",
- "scripts/loader_extension_generator.py",
- "scripts/lvl_genvk.py",
- "scripts/object_tracker_generator.py",
- "scripts/parameter_validation_generator.py",
- "scripts/threading_generator.py",
- "scripts/unique_objects_generator.py",
- ]
- sources = [
- "include/vulkan/vulkan.h",
- "scripts/vk.xml",
- ]
- outputs = [
- "$target_gen_dir/generated/include/vk_safe_struct.h",
- "$target_gen_dir/generated/include/vk_safe_struct.cpp",
- "$target_gen_dir/generated/include/vk_struct_size_helper.h",
- "$target_gen_dir/generated/include/vk_struct_size_helper.c",
- "$target_gen_dir/generated/include/vk_enum_string_helper.h",
- "$target_gen_dir/generated/include/vk_extension_helper.h",
- "$target_gen_dir/generated/include/vk_object_types.h",
- "$target_gen_dir/generated/include/vk_dispatch_table_helper.h",
- "$target_gen_dir/generated/include/thread_check.h",
- "$target_gen_dir/generated/include/parameter_validation.h",
- "$target_gen_dir/generated/include/unique_objects_wrappers.h",
- "$target_gen_dir/generated/include/vk_loader_extensions.h",
- "$target_gen_dir/generated/include/vk_loader_extensions.c",
- "$target_gen_dir/generated/include/vk_layer_dispatch_table.h",
- ]
+ include_dirs = [ "build-fuchsia/generated/include" ]
}
diff --git a/README_FUCHSIA.md b/README_FUCHSIA.md
index 3ba4266..fb91701 100644
--- a/README_FUCHSIA.md
+++ b/README_FUCHSIA.md
@@ -2,7 +2,14 @@
- The `BUILD.gn` files are for building as a part of Fuchsia using `GN`.
- The `build-fuchsia` directory contains customized scripts to generate some of
-the necessary header files. They are used in the root `BUILD.gn` file.
+the necessary header files. These header files are pre-generated and used in the
+root `BUILD.gn` file.
+- To regenerate the header files after an update, run the following command:
+```
+cd $FUCHSIA_ROOT/third_party/vulkan_loader_and_validation_layers
+./build-fuchsia/fuchsia-generate.sh build-fuchsia
+```
+
- The header files `vulkan.h` and `vulkan.hpp` are generated from `vk.xml`. If
`vk.xml` changes, regenerate the files with the following steps:
diff --git a/build-fuchsia/generated/include/parameter_validation.h b/build-fuchsia/generated/include/parameter_validation.h
new file mode 100644
index 0000000..facb1ca
--- /dev/null
+++ b/build-fuchsia/generated/include/parameter_validation.h
@@ -0,0 +1,7900 @@
+/*
+** Copyright (c) 2015-2017 The Khronos Group 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.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+#ifndef PARAMETER_VALIDATION_H
+#define PARAMETER_VALIDATION_H 1
+
+#include <string>
+
+#include "vulkan/vulkan.h"
+#include "vk_layer_extension_utils.h"
+#include "parameter_validation_utils.h"
+
+#ifndef UNUSED_PARAMETER
+#define UNUSED_PARAMETER(x) (void)(x)
+#endif // UNUSED_PARAMETER
+
+namespace parameter_validation {
+const uint32_t GeneratedHeaderVersion = 57;
+
+const VkAccessFlags AllVkAccessFlagBits = VK_ACCESS_INDIRECT_COMMAND_READ_BIT|VK_ACCESS_INDEX_READ_BIT|VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|VK_ACCESS_UNIFORM_READ_BIT|VK_ACCESS_INPUT_ATTACHMENT_READ_BIT|VK_ACCESS_SHADER_READ_BIT|VK_ACCESS_SHADER_WRITE_BIT|VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT|VK_ACCESS_HOST_READ_BIT|VK_ACCESS_HOST_WRITE_BIT|VK_ACCESS_MEMORY_READ_BIT|VK_ACCESS_MEMORY_WRITE_BIT|VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX|VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX|VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT;
+const VkAttachmentDescriptionFlags AllVkAttachmentDescriptionFlagBits = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT;
+const VkBufferCreateFlags AllVkBufferCreateFlagBits = VK_BUFFER_CREATE_SPARSE_BINDING_BIT|VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT|VK_BUFFER_CREATE_SPARSE_ALIASED_BIT;
+const VkBufferUsageFlags AllVkBufferUsageFlagBits = VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_INDEX_BUFFER_BIT|VK_BUFFER_USAGE_VERTEX_BUFFER_BIT|VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
+const VkColorComponentFlags AllVkColorComponentFlagBits = VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT;
+const VkCommandBufferResetFlags AllVkCommandBufferResetFlagBits = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT;
+const VkCommandBufferUsageFlags AllVkCommandBufferUsageFlagBits = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT|VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT|VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+const VkCommandPoolCreateFlags AllVkCommandPoolCreateFlagBits = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT|VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+const VkCommandPoolResetFlags AllVkCommandPoolResetFlagBits = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT;
+const VkCullModeFlags AllVkCullModeFlagBits = VK_CULL_MODE_NONE|VK_CULL_MODE_FRONT_BIT|VK_CULL_MODE_BACK_BIT|VK_CULL_MODE_FRONT_AND_BACK;
+const VkDependencyFlags AllVkDependencyFlagBits = VK_DEPENDENCY_BY_REGION_BIT|VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX|VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX;
+const VkDescriptorPoolCreateFlags AllVkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+const VkDescriptorSetLayoutCreateFlags AllVkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
+const VkFenceCreateFlags AllVkFenceCreateFlagBits = VK_FENCE_CREATE_SIGNALED_BIT;
+const VkFormatFeatureFlags AllVkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT|VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT|VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT|VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT|VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT|VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT|VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT|VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT|VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT|VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_FORMAT_FEATURE_BLIT_SRC_BIT|VK_FORMAT_FEATURE_BLIT_DST_BIT|VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT|VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG|VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR|VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR|VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
+const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT;
+const VkImageCreateFlags AllVkImageCreateFlagBits = VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT|VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT|VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT|VK_IMAGE_CREATE_BIND_SFR_BIT_KHX|VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR;
+const VkImageUsageFlags AllVkImageUsageFlagBits = VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+const VkMemoryHeapFlags AllVkMemoryHeapFlagBits = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT|VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX;
+const VkMemoryPropertyFlags AllVkMemoryPropertyFlagBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+const VkPipelineCreateFlags AllVkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT|VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DERIVATIVE_BIT|VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX|VK_PIPELINE_CREATE_DISPATCH_BASE_KHX;
+const VkPipelineStageFlags AllVkPipelineStageFlagBits = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT|VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT|VK_PIPELINE_STAGE_VERTEX_INPUT_BIT|VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT|VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT|VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT|VK_PIPELINE_STAGE_HOST_BIT|VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT|VK_PIPELINE_STAGE_ALL_COMMANDS_BIT|VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX;
+const VkQueryControlFlags AllVkQueryControlFlagBits = VK_QUERY_CONTROL_PRECISE_BIT;
+const VkQueryPipelineStatisticFlags AllVkQueryPipelineStatisticFlagBits = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT|VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
+const VkQueryResultFlags AllVkQueryResultFlagBits = VK_QUERY_RESULT_64_BIT|VK_QUERY_RESULT_WAIT_BIT|VK_QUERY_RESULT_WITH_AVAILABILITY_BIT|VK_QUERY_RESULT_PARTIAL_BIT;
+const VkQueueFlags AllVkQueueFlagBits = VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_TRANSFER_BIT|VK_QUEUE_SPARSE_BINDING_BIT;
+const VkSampleCountFlags AllVkSampleCountFlagBits = VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_2_BIT|VK_SAMPLE_COUNT_4_BIT|VK_SAMPLE_COUNT_8_BIT|VK_SAMPLE_COUNT_16_BIT|VK_SAMPLE_COUNT_32_BIT|VK_SAMPLE_COUNT_64_BIT;
+const VkShaderStageFlags AllVkShaderStageFlagBits = VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT|VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT|VK_SHADER_STAGE_GEOMETRY_BIT|VK_SHADER_STAGE_FRAGMENT_BIT|VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_ALL_GRAPHICS|VK_SHADER_STAGE_ALL;
+const VkSparseImageFormatFlags AllVkSparseImageFormatFlagBits = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT|VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT|VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT;
+const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_BIND_METADATA_BIT;
+const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FRONT_AND_BACK;
+const VkSubpassDescriptionFlags AllVkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX|VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX;
+const VkCompositeAlphaFlagsKHR AllVkCompositeAlphaFlagBitsKHR = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR|VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+const VkSurfaceTransformFlagsKHR AllVkSurfaceTransformFlagBitsKHR = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR|VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
+const VkSwapchainCreateFlagsKHR AllVkSwapchainCreateFlagBitsKHR = VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX;
+const VkDisplayPlaneAlphaFlagsKHR AllVkDisplayPlaneAlphaFlagBitsKHR = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR;
+const VkExternalMemoryFeatureFlagsKHR AllVkExternalMemoryFeatureFlagBitsKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
+const VkExternalMemoryHandleTypeFlagsKHR AllVkExternalMemoryHandleTypeFlagBitsKHR = 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_FUCHSIA_VMO_BIT_KHR;
+const VkExternalSemaphoreFeatureFlagsKHR AllVkExternalSemaphoreFeatureFlagBitsKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
+const VkExternalSemaphoreHandleTypeFlagsKHR AllVkExternalSemaphoreHandleTypeFlagBitsKHR = 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_FUCHSIA_FENCE_BIT_KHR;
+const VkSemaphoreImportFlagsKHR AllVkSemaphoreImportFlagBitsKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR;
+const VkExternalFenceFeatureFlagsKHR AllVkExternalFenceFeatureFlagBitsKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR;
+const VkExternalFenceHandleTypeFlagsKHR AllVkExternalFenceHandleTypeFlagBitsKHR = 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 VkFenceImportFlagsKHR AllVkFenceImportFlagBitsKHR = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR;
+const VkDebugReportFlagsEXT AllVkDebugReportFlagBitsEXT = VK_DEBUG_REPORT_INFORMATION_BIT_EXT|VK_DEBUG_REPORT_WARNING_BIT_EXT|VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT|VK_DEBUG_REPORT_ERROR_BIT_EXT|VK_DEBUG_REPORT_DEBUG_BIT_EXT;
+const VkExternalMemoryFeatureFlagsNV AllVkExternalMemoryFeatureFlagBitsNV = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV;
+const VkExternalMemoryHandleTypeFlagsNV AllVkExternalMemoryHandleTypeFlagBitsNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV;
+const VkDeviceGroupPresentModeFlagsKHX AllVkDeviceGroupPresentModeFlagBitsKHX = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX|VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX;
+const VkMemoryAllocateFlagsKHX AllVkMemoryAllocateFlagBitsKHX = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX;
+const VkPeerMemoryFeatureFlagsKHX AllVkPeerMemoryFeatureFlagBitsKHX = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX|VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX;
+const VkIndirectCommandsLayoutUsageFlagsNVX AllVkIndirectCommandsLayoutUsageFlagBitsNVX = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX|VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX|VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX|VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX;
+const VkObjectEntryUsageFlagsNVX AllVkObjectEntryUsageFlagBitsNVX = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX|VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX;
+const VkSurfaceCounterFlagsEXT AllVkSurfaceCounterFlagBitsEXT = VK_SURFACE_COUNTER_VBLANK_EXT;
+
+const std::vector<VkPipelineCacheHeaderVersion> AllVkPipelineCacheHeaderVersionEnums = {VK_PIPELINE_CACHE_HEADER_VERSION_ONE, };
+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_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, };
+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, };
+const std::vector<VkInternalAllocationType> AllVkInternalAllocationTypeEnums = {VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, };
+const std::vector<VkFormat> AllVkFormatEnums = {VK_FORMAT_UNDEFINED, VK_FORMAT_R4G4_UNORM_PACK8, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_R8_USCALED, VK_FORMAT_R8_SSCALED, VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_USCALED, VK_FORMAT_R8G8_SSCALED, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_USCALED, VK_FORMAT_R8G8B8_SSCALED, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_B8G8R8_SNORM, VK_FORMAT_B8G8R8_USCALED, VK_FORMAT_B8G8R8_SSCALED, VK_FORMAT_B8G8R8_UINT, VK_FORMAT_B8G8R8_SINT, VK_FORMAT_B8G8R8_SRGB, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_USCALED, VK_FORMAT_R8G8B8A8_SSCALED, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SNORM, VK_FORMAT_B8G8R8A8_USCALED, VK_FORMAT_B8G8R8A8_SSCALED, VK_FORMAT_B8G8R8A8_UINT, VK_FORMAT_B8G8R8A8_SINT, VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SNORM_PACK32, VK_FORMAT_A8B8G8R8_USCALED_PACK32, VK_FORMAT_A8B8G8R8_SSCALED_PACK32, VK_FORMAT_A8B8G8R8_UINT_PACK32, VK_FORMAT_A8B8G8R8_SINT_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_SNORM_PACK32, VK_FORMAT_A2R10G10B10_USCALED_PACK32, VK_FORMAT_A2R10G10B10_SSCALED_PACK32, VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_SINT_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_SNORM_PACK32, VK_FORMAT_A2B10G10R10_USCALED_PACK32, VK_FORMAT_A2B10G10R10_SSCALED_PACK32, VK_FORMAT_A2B10G10R10_UINT_PACK32, VK_FORMAT_A2B10G10R10_SINT_PACK32, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_R16_USCALED, VK_FORMAT_R16_SSCALED, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_USCALED, VK_FORMAT_R16G16_SSCALED, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16_UNORM, VK_FORMAT_R16G16B16_SNORM, VK_FORMAT_R16G16B16_USCALED, VK_FORMAT_R16G16B16_SSCALED, VK_FORMAT_R16G16B16_UINT, VK_FORMAT_R16G16B16_SINT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_USCALED, VK_FORMAT_R16G16B16A16_SSCALED, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_SINT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R64_UINT, VK_FORMAT_R64_SINT, VK_FORMAT_R64_SFLOAT, VK_FORMAT_R64G64_UINT, VK_FORMAT_R64G64_SINT, VK_FORMAT_R64G64_SFLOAT, VK_FORMAT_R64G64B64_UINT, VK_FORMAT_R64G64B64_SINT, VK_FORMAT_R64G64B64_SFLOAT, VK_FORMAT_R64G64B64A64_UINT, VK_FORMAT_R64G64B64A64_SINT, VK_FORMAT_R64G64B64A64_SFLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_D16_UNORM, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT, VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC6H_UFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, };
+const std::vector<VkImageType> AllVkImageTypeEnums = {VK_IMAGE_TYPE_1D, VK_IMAGE_TYPE_2D, VK_IMAGE_TYPE_3D, };
+const std::vector<VkImageTiling> AllVkImageTilingEnums = {VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_LINEAR, VK_IMAGE_TILING_SCANOUT_GOOGLE, };
+const std::vector<VkPhysicalDeviceType> AllVkPhysicalDeviceTypeEnums = {VK_PHYSICAL_DEVICE_TYPE_OTHER, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, VK_PHYSICAL_DEVICE_TYPE_CPU, };
+const std::vector<VkQueryType> AllVkQueryTypeEnums = {VK_QUERY_TYPE_OCCLUSION, VK_QUERY_TYPE_PIPELINE_STATISTICS, VK_QUERY_TYPE_TIMESTAMP, };
+const std::vector<VkSharingMode> AllVkSharingModeEnums = {VK_SHARING_MODE_EXCLUSIVE, VK_SHARING_MODE_CONCURRENT, };
+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_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, };
+const std::vector<VkImageViewType> AllVkImageViewTypeEnums = {VK_IMAGE_VIEW_TYPE_1D, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, };
+const std::vector<VkComponentSwizzle> AllVkComponentSwizzleEnums = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A, };
+const std::vector<VkVertexInputRate> AllVkVertexInputRateEnums = {VK_VERTEX_INPUT_RATE_VERTEX, VK_VERTEX_INPUT_RATE_INSTANCE, };
+const std::vector<VkPrimitiveTopology> AllVkPrimitiveTopologyEnums = {VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, };
+const std::vector<VkPolygonMode> AllVkPolygonModeEnums = {VK_POLYGON_MODE_FILL, VK_POLYGON_MODE_LINE, VK_POLYGON_MODE_POINT, VK_POLYGON_MODE_FILL_RECTANGLE_NV, };
+const std::vector<VkFrontFace> AllVkFrontFaceEnums = {VK_FRONT_FACE_COUNTER_CLOCKWISE, VK_FRONT_FACE_CLOCKWISE, };
+const std::vector<VkCompareOp> AllVkCompareOpEnums = {VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_OR_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_COMPARE_OP_ALWAYS, };
+const std::vector<VkStencilOp> AllVkStencilOpEnums = {VK_STENCIL_OP_KEEP, VK_STENCIL_OP_ZERO, VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_INCREMENT_AND_CLAMP, VK_STENCIL_OP_DECREMENT_AND_CLAMP, VK_STENCIL_OP_INVERT, VK_STENCIL_OP_INCREMENT_AND_WRAP, VK_STENCIL_OP_DECREMENT_AND_WRAP, };
+const std::vector<VkLogicOp> AllVkLogicOpEnums = {VK_LOGIC_OP_CLEAR, VK_LOGIC_OP_AND, VK_LOGIC_OP_AND_REVERSE, VK_LOGIC_OP_COPY, VK_LOGIC_OP_AND_INVERTED, VK_LOGIC_OP_NO_OP, VK_LOGIC_OP_XOR, VK_LOGIC_OP_OR, VK_LOGIC_OP_NOR, VK_LOGIC_OP_EQUIVALENT, VK_LOGIC_OP_INVERT, VK_LOGIC_OP_OR_REVERSE, VK_LOGIC_OP_COPY_INVERTED, VK_LOGIC_OP_OR_INVERTED, VK_LOGIC_OP_NAND, VK_LOGIC_OP_SET, };
+const std::vector<VkBlendFactor> AllVkBlendFactorEnums = {VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_SRC_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, VK_BLEND_FACTOR_DST_COLOR, VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, };
+const std::vector<VkBlendOp> AllVkBlendOpEnums = {VK_BLEND_OP_ADD, VK_BLEND_OP_SUBTRACT, VK_BLEND_OP_REVERSE_SUBTRACT, VK_BLEND_OP_MIN, VK_BLEND_OP_MAX, VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_MULTIPLY_EXT, VK_BLEND_OP_SCREEN_EXT, VK_BLEND_OP_OVERLAY_EXT, VK_BLEND_OP_DARKEN_EXT, VK_BLEND_OP_LIGHTEN_EXT, VK_BLEND_OP_COLORDODGE_EXT, VK_BLEND_OP_COLORBURN_EXT, VK_BLEND_OP_HARDLIGHT_EXT, VK_BLEND_OP_SOFTLIGHT_EXT, VK_BLEND_OP_DIFFERENCE_EXT, VK_BLEND_OP_EXCLUSION_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_HSL_HUE_EXT, VK_BLEND_OP_HSL_SATURATION_EXT, VK_BLEND_OP_HSL_COLOR_EXT, VK_BLEND_OP_HSL_LUMINOSITY_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, VK_BLEND_OP_BLUE_EXT, };
+const std::vector<VkDynamicState> AllVkDynamicStateEnums = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, VK_DYNAMIC_STATE_DEPTH_BIAS, VK_DYNAMIC_STATE_BLEND_CONSTANTS, VK_DYNAMIC_STATE_DEPTH_BOUNDS, VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, };
+const std::vector<VkFilter> AllVkFilterEnums = {VK_FILTER_NEAREST, VK_FILTER_LINEAR, VK_FILTER_CUBIC_IMG, };
+const std::vector<VkSamplerMipmapMode> AllVkSamplerMipmapModeEnums = {VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR, };
+const std::vector<VkSamplerAddressMode> AllVkSamplerAddressModeEnums = {VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, };
+const std::vector<VkBorderColor> AllVkBorderColorEnums = {VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, VK_BORDER_COLOR_INT_OPAQUE_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, VK_BORDER_COLOR_INT_OPAQUE_WHITE, };
+const std::vector<VkDescriptorType> AllVkDescriptorTypeEnums = {VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, };
+const std::vector<VkAttachmentLoadOp> AllVkAttachmentLoadOpEnums = {VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE, };
+const std::vector<VkAttachmentStoreOp> AllVkAttachmentStoreOpEnums = {VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_STORE_OP_DONT_CARE, };
+const std::vector<VkPipelineBindPoint> AllVkPipelineBindPointEnums = {VK_PIPELINE_BIND_POINT_GRAPHICS, VK_PIPELINE_BIND_POINT_COMPUTE, };
+const std::vector<VkCommandBufferLevel> AllVkCommandBufferLevelEnums = {VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_BUFFER_LEVEL_SECONDARY, };
+const std::vector<VkIndexType> AllVkIndexTypeEnums = {VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, };
+const std::vector<VkSubpassContents> AllVkSubpassContentsEnums = {VK_SUBPASS_CONTENTS_INLINE, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, };
+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_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_OBJECT_TABLE_NVX, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, };
+const std::vector<VkColorSpaceKHR> AllVkColorSpaceKHREnums = {VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, VK_COLOR_SPACE_BT709_LINEAR_EXT, VK_COLOR_SPACE_BT709_NONLINEAR_EXT, VK_COLOR_SPACE_BT2020_LINEAR_EXT, VK_COLOR_SPACE_HDR10_ST2084_EXT, VK_COLOR_SPACE_DOLBYVISION_EXT, VK_COLOR_SPACE_HDR10_HLG_EXT, VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, VK_COLOR_SPACE_PASS_THROUGH_EXT, VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, };
+const std::vector<VkPresentModeKHR> AllVkPresentModeKHREnums = {VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, };
+const std::vector<VkDescriptorUpdateTemplateTypeKHR> AllVkDescriptorUpdateTemplateTypeKHREnums = {VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_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_DISPLAY_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, };
+const std::vector<VkRasterizationOrderAMD> AllVkRasterizationOrderAMDEnums = {VK_RASTERIZATION_ORDER_STRICT_AMD, VK_RASTERIZATION_ORDER_RELAXED_AMD, };
+const std::vector<VkValidationCheckEXT> AllVkValidationCheckEXTEnums = {VK_VALIDATION_CHECK_ALL_EXT, VK_VALIDATION_CHECK_SHADERS_EXT, };
+const std::vector<VkIndirectCommandsTokenTypeNVX> AllVkIndirectCommandsTokenTypeNVXEnums = {VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, };
+const std::vector<VkObjectEntryTypeNVX> AllVkObjectEntryTypeNVXEnums = {VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, };
+const std::vector<VkDisplayPowerStateEXT> AllVkDisplayPowerStateEXTEnums = {VK_DISPLAY_POWER_STATE_OFF_EXT, VK_DISPLAY_POWER_STATE_SUSPEND_EXT, VK_DISPLAY_POWER_STATE_ON_EXT, };
+const std::vector<VkDeviceEventTypeEXT> AllVkDeviceEventTypeEXTEnums = {VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, };
+const std::vector<VkDisplayEventTypeEXT> AllVkDisplayEventTypeEXTEnums = {VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, };
+const std::vector<VkViewportCoordinateSwizzleNV> AllVkViewportCoordinateSwizzleNVEnums = {VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, };
+const std::vector<VkDiscardRectangleModeEXT> AllVkDiscardRectangleModeEXTEnums = {VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, };
+const std::vector<VkSamplerReductionModeEXT> AllVkSamplerReductionModeEXTEnums = {VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, VK_SAMPLER_REDUCTION_MODE_MIN_EXT, VK_SAMPLER_REDUCTION_MODE_MAX_EXT, };
+const std::vector<VkBlendOverlapEXT> AllVkBlendOverlapEXTEnums = {VK_BLEND_OVERLAP_UNCORRELATED_EXT, VK_BLEND_OVERLAP_DISJOINT_EXT, VK_BLEND_OVERLAP_CONJOINT_EXT, };
+const std::vector<VkCoverageModulationModeNV> AllVkCoverageModulationModeNVEnums = {VK_COVERAGE_MODULATION_MODE_NONE_NV, VK_COVERAGE_MODULATION_MODE_RGB_NV, VK_COVERAGE_MODULATION_MODE_ALPHA_NV, VK_COVERAGE_MODULATION_MODE_RGBA_NV, };
+
+
+static bool parameter_validation_vkCreateInstance(
+ instance_layer_data* layer_data,
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateInstance", "pCreateInfo", "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, true, VALIDATION_ERROR_0be2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateInstance", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0be09005);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo", "VK_STRUCTURE_TYPE_APPLICATION_INFO", pCreateInfo->pApplicationInfo, VK_STRUCTURE_TYPE_APPLICATION_INFO, false, VALIDATION_ERROR_0062b00b);
+
+ if (pCreateInfo->pApplicationInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo->pNext", NULL, pCreateInfo->pApplicationInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0061c40d);
+ }
+
+ skipCall |= validate_string_array(layer_data->report_data, "vkCreateInstance", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0be29001);
+
+ skipCall |= validate_string_array(layer_data->report_data, "vkCreateInstance", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0be28e01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateInstance", "pInstance", pInstance, VALIDATION_ERROR_21219c01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyInstance(
+ instance_layer_data* layer_data,
+ const VkAllocationCallbacks* pAllocator)
+{
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkEnumeratePhysicalDevices(
+ instance_layer_data* layer_data,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkEnumeratePhysicalDevices", "pPhysicalDeviceCount", "pPhysicalDevices", pPhysicalDeviceCount, pPhysicalDevices, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2801dc01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceFeatures(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceFeatures* pFeatures)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceFeatures", "pFeatures", pFeatures, VALIDATION_ERROR_2c016e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceFormatProperties(
+ instance_layer_data* layer_data,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceFormatProperties", "format", "VkFormat", AllVkFormatEnums, format, VALIDATION_ERROR_2c409201);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceFormatProperties", "pFormatProperties", pFormatProperties, VALIDATION_ERROR_2c417601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceImageFormatProperties(
+ instance_layer_data* layer_data,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "format", "VkFormat", AllVkFormatEnums, format, VALIDATION_ERROR_2ca09201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "type", "VkImageType", AllVkImageTypeEnums, type, VALIDATION_ERROR_2ca30401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, VALIDATION_ERROR_2ca2fa01);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, VALIDATION_ERROR_2ca30603);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false, false, VALIDATION_ERROR_2ca09001);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties", "pImageFormatProperties", pImageFormatProperties, VALIDATION_ERROR_2ca18401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceProperties(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceProperties* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceProperties", "pProperties", pProperties, VALIDATION_ERROR_2d61f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(
+ instance_layer_data* layer_data,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceQueueFamilyProperties", "pQueueFamilyPropertyCount", "pQueueFamilyProperties", pQueueFamilyPropertyCount, pQueueFamilyProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2da20001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceMemoryProperties(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceMemoryProperties", "pMemoryProperties", pMemoryProperties, VALIDATION_ERROR_2ce1b001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateDevice(
+ instance_layer_data* layer_data,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDevice", "pCreateInfo", "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, true, VALIDATION_ERROR_0562b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateDevice", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_05609005);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCreateDevice", "pCreateInfo->queueCreateInfoCount", "pCreateInfo->pQueueCreateInfos", "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", pCreateInfo->queueCreateInfoCount, pCreateInfo->pQueueCreateInfos, VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, true, true, VALIDATION_ERROR_0561fe01);
+
+ if (pCreateInfo->pQueueCreateInfos != NULL)
+ {
+ for (uint32_t queueCreateInfoIndex = 0; queueCreateInfoIndex < pCreateInfo->queueCreateInfoCount; ++queueCreateInfoIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].pNext", ParameterName::IndexVector{ queueCreateInfoIndex }), NULL, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_06c1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].flags", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].flags, VALIDATION_ERROR_06c09005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].queueCount", ParameterName::IndexVector{ queueCreateInfoIndex }), ParameterName("pCreateInfo->pQueueCreateInfos[%i].pQueuePriorities", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].queueCount, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pQueuePriorities, true, true, VALIDATION_ERROR_06c29e1b, VALIDATION_ERROR_06c20401);
+ }
+ }
+
+ skipCall |= validate_string_array(layer_data->report_data, "vkCreateDevice", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_05629001);
+
+ skipCall |= validate_string_array(layer_data->report_data, "vkCreateDevice", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_05628e01);
+
+ if (pCreateInfo->pEnabledFeatures != NULL)
+ {
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->robustBufferAccess", pCreateInfo->pEnabledFeatures->robustBufferAccess);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fullDrawIndexUint32", pCreateInfo->pEnabledFeatures->fullDrawIndexUint32);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->imageCubeArray", pCreateInfo->pEnabledFeatures->imageCubeArray);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->independentBlend", pCreateInfo->pEnabledFeatures->independentBlend);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->geometryShader", pCreateInfo->pEnabledFeatures->geometryShader);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->tessellationShader", pCreateInfo->pEnabledFeatures->tessellationShader);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sampleRateShading", pCreateInfo->pEnabledFeatures->sampleRateShading);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->dualSrcBlend", pCreateInfo->pEnabledFeatures->dualSrcBlend);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->logicOp", pCreateInfo->pEnabledFeatures->logicOp);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiDrawIndirect", pCreateInfo->pEnabledFeatures->multiDrawIndirect);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance", pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthClamp", pCreateInfo->pEnabledFeatures->depthClamp);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBiasClamp", pCreateInfo->pEnabledFeatures->depthBiasClamp);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fillModeNonSolid", pCreateInfo->pEnabledFeatures->fillModeNonSolid);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBounds", pCreateInfo->pEnabledFeatures->depthBounds);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->wideLines", pCreateInfo->pEnabledFeatures->wideLines);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->largePoints", pCreateInfo->pEnabledFeatures->largePoints);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->alphaToOne", pCreateInfo->pEnabledFeatures->alphaToOne);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiViewport", pCreateInfo->pEnabledFeatures->multiViewport);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->samplerAnisotropy", pCreateInfo->pEnabledFeatures->samplerAnisotropy);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionETC2", pCreateInfo->pEnabledFeatures->textureCompressionETC2);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR", pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionBC", pCreateInfo->pEnabledFeatures->textureCompressionBC);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->occlusionQueryPrecise", pCreateInfo->pEnabledFeatures->occlusionQueryPrecise);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery", pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics", pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics", pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize", pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderImageGatherExtended", pCreateInfo->pEnabledFeatures->shaderImageGatherExtended);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats", pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample", pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderClipDistance", pCreateInfo->pEnabledFeatures->shaderClipDistance);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderCullDistance", pCreateInfo->pEnabledFeatures->shaderCullDistance);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderFloat64", pCreateInfo->pEnabledFeatures->shaderFloat64);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt64", pCreateInfo->pEnabledFeatures->shaderInt64);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt16", pCreateInfo->pEnabledFeatures->shaderInt16);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceResidency", pCreateInfo->pEnabledFeatures->shaderResourceResidency);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceMinLod", pCreateInfo->pEnabledFeatures->shaderResourceMinLod);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseBinding", pCreateInfo->pEnabledFeatures->sparseBinding);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyBuffer", pCreateInfo->pEnabledFeatures->sparseResidencyBuffer);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage2D", pCreateInfo->pEnabledFeatures->sparseResidencyImage2D);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage3D", pCreateInfo->pEnabledFeatures->sparseResidencyImage3D);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency2Samples", pCreateInfo->pEnabledFeatures->sparseResidency2Samples);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency4Samples", pCreateInfo->pEnabledFeatures->sparseResidency4Samples);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency8Samples", pCreateInfo->pEnabledFeatures->sparseResidency8Samples);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency16Samples", pCreateInfo->pEnabledFeatures->sparseResidency16Samples);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyAliased", pCreateInfo->pEnabledFeatures->sparseResidencyAliased);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->variableMultisampleRate", pCreateInfo->pEnabledFeatures->variableMultisampleRate);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->inheritedQueries", pCreateInfo->pEnabledFeatures->inheritedQueries);
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDevice", "pDevice", pDevice, VALIDATION_ERROR_1fc13801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyDevice(
+ layer_data* layer_data,
+ const VkAllocationCallbacks* pAllocator)
+{
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkEnumerateInstanceExtensionProperties(
+ layer_data* layer_data,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkEnumerateInstanceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_27a1f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkEnumerateDeviceExtensionProperties(
+ instance_layer_data* layer_data,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ UNUSED_PARAMETER(pLayerName);
+
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkEnumerateDeviceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2761f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDeviceQueue(
+ layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+ UNUSED_PARAMETER(queueIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetDeviceQueue", "pQueue", pQueue, VALIDATION_ERROR_2961fc01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkQueueSubmit(
+ layer_data* layer_data,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ UNUSED_PARAMETER(fence);
+
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkQueueSubmit", "submitCount", "pSubmits", "VK_STRUCTURE_TYPE_SUBMIT_INFO", submitCount, pSubmits, VK_STRUCTURE_TYPE_SUBMIT_INFO, false, true, VALIDATION_ERROR_31a24001);
+
+ if (pSubmits != NULL)
+ {
+ for (uint32_t submitIndex = 0; submitIndex < submitCount; ++submitIndex)
+ {
+ const VkStructureType allowed_structs_VkSubmitInfo[] = { VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX, VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].pNext", ParameterName::IndexVector{ submitIndex }), "VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfoKHX, VkWin32KeyedMutexAcquireReleaseInfoKHR, VkWin32KeyedMutexAcquireReleaseInfoNV", pSubmits[submitIndex].pNext, ARRAY_SIZE(allowed_structs_VkSubmitInfo), allowed_structs_VkSubmitInfo, GeneratedHeaderVersion, VALIDATION_ERROR_13c1c40d);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].waitSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pWaitSemaphores", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].waitSemaphoreCount, pSubmits[submitIndex].pWaitSemaphores, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_13c27601);
+
+ skipCall |= validate_flags_array(layer_data->report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].waitSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pWaitDstStageMask", ParameterName::IndexVector{ submitIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pSubmits[submitIndex].waitSemaphoreCount, pSubmits[submitIndex].pWaitDstStageMask, false, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].commandBufferCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pCommandBuffers", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].commandBufferCount, pSubmits[submitIndex].pCommandBuffers, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_13c11401);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].signalSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pSignalSemaphores", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].signalSemaphoreCount, pSubmits[submitIndex].pSignalSemaphores, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_13c23401);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkAllocateMemory(
+ layer_data* layer_data,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true, VALIDATION_ERROR_0c62b00b);
+
+ if (pAllocateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkMemoryAllocateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, 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_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FUCHSIA_HANDLE_INFO_KHR, 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_KHX, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV, VkExportMemoryAllocateInfoKHR, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, VkExportMemoryWin32HandleInfoNV, VkImportMemoryFdInfoKHR, VkImportMemoryFuchsiaHandleInfoKHR, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkMemoryAllocateFlagsInfoKHX, VkMemoryDedicatedAllocateInfoKHR", pAllocateInfo->pNext, ARRAY_SIZE(allowed_structs_VkMemoryAllocateInfo), allowed_structs_VkMemoryAllocateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0c61c40d);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAllocateMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAllocateMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAllocateMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAllocateMemory", "pMemory", pMemory, VALIDATION_ERROR_16c1aa01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkFreeMemory(
+ layer_data* layer_data,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(memory);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkFreeMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkFreeMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkFreeMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkMapMemory(
+ layer_data* layer_data,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ UNUSED_PARAMETER(offset);
+ UNUSED_PARAMETER(size);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkMapMemory", "memory", memory);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkMapMemory", "flags", flags, VALIDATION_ERROR_31209005);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkMapMemory", "ppData", ppData, VALIDATION_ERROR_31228c01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkUnmapMemory(
+ layer_data* layer_data,
+ VkDeviceMemory memory)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUnmapMemory", "memory", memory);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkFlushMappedMemoryRanges(
+ layer_data* layer_data,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkFlushMappedMemoryRanges", "memoryRangeCount", "pMemoryRanges", "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", memoryRangeCount, pMemoryRanges, VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, true, true, VALIDATION_ERROR_2821b201);
+
+ if (pMemoryRanges != NULL)
+ {
+ for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0c21c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkInvalidateMappedMemoryRanges(
+ layer_data* layer_data,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkInvalidateMappedMemoryRanges", "memoryRangeCount", "pMemoryRanges", "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", memoryRangeCount, pMemoryRanges, VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, true, true, VALIDATION_ERROR_3101b201);
+
+ if (pMemoryRanges != NULL)
+ {
+ for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0c21c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDeviceMemoryCommitment(
+ layer_data* layer_data,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetDeviceMemoryCommitment", "memory", memory);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetDeviceMemoryCommitment", "pCommittedMemoryInBytes", pCommittedMemoryInBytes, VALIDATION_ERROR_29211801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkBindBufferMemory(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ UNUSED_PARAMETER(memoryOffset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindBufferMemory", "buffer", buffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindBufferMemory", "memory", memory);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkBindImageMemory(
+ layer_data* layer_data,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ UNUSED_PARAMETER(memoryOffset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindImageMemory", "image", image);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindImageMemory", "memory", memory);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetBufferMemoryRequirements(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetBufferMemoryRequirements", "buffer", buffer);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetBufferMemoryRequirements", "pMemoryRequirements", pMemoryRequirements, VALIDATION_ERROR_28a1b401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetImageMemoryRequirements(
+ layer_data* layer_data,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetImageMemoryRequirements", "image", image);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetImageMemoryRequirements", "pMemoryRequirements", pMemoryRequirements, VALIDATION_ERROR_2a21b401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetImageSparseMemoryRequirements(
+ layer_data* layer_data,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetImageSparseMemoryRequirements", "image", image);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetImageSparseMemoryRequirements", "pSparseMemoryRequirementCount", "pSparseMemoryRequirements", pSparseMemoryRequirementCount, pSparseMemoryRequirements, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2a423801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(
+ instance_layer_data* layer_data,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "format", "VkFormat", AllVkFormatEnums, format, VALIDATION_ERROR_2de09201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "type", "VkImageType", AllVkImageTypeEnums, type, VALIDATION_ERROR_2de30401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, samples, true, true, VALIDATION_ERROR_2de2b401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, VALIDATION_ERROR_2de30603);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, VALIDATION_ERROR_2de2fa01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2de1f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkQueueBindSparse(
+ layer_data* layer_data,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ UNUSED_PARAMETER(fence);
+
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkQueueBindSparse", "bindInfoCount", "pBindInfo", "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", bindInfoCount, pBindInfo, VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, false, true, VALIDATION_ERROR_3160f801);
+
+ if (pBindInfo != NULL)
+ {
+ for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex)
+ {
+ const VkStructureType allowed_structs_VkBindSparseInfo[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pNext", ParameterName::IndexVector{ bindInfoIndex }), "VkDeviceGroupBindSparseInfoKHX", pBindInfo[bindInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkBindSparseInfo), allowed_structs_VkBindSparseInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0121c40d);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].waitSemaphoreCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pWaitSemaphores", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].waitSemaphoreCount, pBindInfo[bindInfoIndex].pWaitSemaphores, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_01227601);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].bufferBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pBufferBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].bufferBindCount, pBindInfo[bindInfoIndex].pBufferBinds, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_01210201);
+
+ if (pBindInfo[bindInfoIndex].pBufferBinds != NULL)
+ {
+ for (uint32_t bufferBindIndex = 0; bufferBindIndex < pBindInfo[bindInfoIndex].bufferBindCount; ++bufferBindIndex)
+ {
+ skipCall |= validate_required_handle(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].buffer", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].buffer);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds, true, true, VALIDATION_ERROR_12c0141b, VALIDATION_ERROR_12c0fe01);
+
+ if (pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds != NULL)
+ {
+ for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount; ++bindIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds[bindIndex].flags, false, false, VALIDATION_ERROR_13409001);
+ }
+ }
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].imageOpaqueBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pImageOpaqueBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].imageOpaqueBindCount, pBindInfo[bindInfoIndex].pImageOpaqueBinds, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_01218c01);
+
+ if (pBindInfo[bindInfoIndex].pImageOpaqueBinds != NULL)
+ {
+ for (uint32_t imageOpaqueBindIndex = 0; imageOpaqueBindIndex < pBindInfo[bindInfoIndex].imageOpaqueBindCount; ++imageOpaqueBindIndex)
+ {
+ skipCall |= validate_required_handle(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].image);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds, true, true, VALIDATION_ERROR_1320141b, VALIDATION_ERROR_1320fe01);
+
+ if (pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds != NULL)
+ {
+ for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount; ++bindIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds[bindIndex].flags, false, false, VALIDATION_ERROR_13409001);
+ }
+ }
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].imageBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pImageBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].imageBindCount, pBindInfo[bindInfoIndex].pImageBinds, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_01218001);
+
+ if (pBindInfo[bindInfoIndex].pImageBinds != NULL)
+ {
+ for (uint32_t imageBindIndex = 0; imageBindIndex < pBindInfo[bindInfoIndex].imageBindCount; ++imageBindIndex)
+ {
+ skipCall |= validate_required_handle(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].image);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds, true, true, VALIDATION_ERROR_1300141b, VALIDATION_ERROR_1300fe01);
+
+ if (pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds != NULL)
+ {
+ for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount; ++bindIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].subresource.aspectMask", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].subresource.aspectMask, true, false, VALIDATION_ERROR_0a400c03);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].flags, false, false, VALIDATION_ERROR_12e09001);
+ }
+ }
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].signalSemaphoreCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pSignalSemaphores", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].signalSemaphoreCount, pBindInfo[bindInfoIndex].pSignalSemaphores, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_01223401);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateFence(
+ layer_data* layer_data,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateFence", "pCreateInfo", "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, true, VALIDATION_ERROR_0922b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkFenceCreateInfo[] = { VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateFence", "pCreateInfo->pNext", "VkExportFenceCreateInfoKHR, VkExportFenceWin32HandleInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkFenceCreateInfo), allowed_structs_VkFenceCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0921c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateFence", "pCreateInfo->flags", "VkFenceCreateFlagBits", AllVkFenceCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_09209001);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFence", "pFence", pFence, VALIDATION_ERROR_20417001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyFence(
+ layer_data* layer_data,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(fence);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkResetFences(
+ layer_data* layer_data,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkResetFences", "fenceCount", "pFences", fenceCount, pFences, true, true);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetFenceStatus(
+ layer_data* layer_data,
+ VkFence fence)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetFenceStatus", "fence", fence);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkWaitForFences(
+ layer_data* layer_data,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ UNUSED_PARAMETER(timeout);
+
+ bool skipCall = false;
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkWaitForFences", "fenceCount", "pFences", fenceCount, pFences, true, true);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkWaitForFences", "waitAll", waitAll);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateSemaphore(
+ layer_data* layer_data,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateSemaphore", "pCreateInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, true, VALIDATION_ERROR_1282b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkSemaphoreCreateInfo[] = { VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateSemaphore", "pCreateInfo->pNext", "VkExportSemaphoreCreateInfoKHR, VkExportSemaphoreWin32HandleInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSemaphoreCreateInfo), allowed_structs_VkSemaphoreCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_1281c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateSemaphore", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_12809005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSemaphore", "pSemaphore", pSemaphore, VALIDATION_ERROR_22422801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroySemaphore(
+ layer_data* layer_data,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(semaphore);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateEvent(
+ layer_data* layer_data,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateEvent", "pCreateInfo", "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, true, VALIDATION_ERROR_07e2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateEvent", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_07e1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateEvent", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_07e09005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateEvent", "pEvent", pEvent, VALIDATION_ERROR_20215e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyEvent(
+ layer_data* layer_data,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(event);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetEventStatus(
+ layer_data* layer_data,
+ VkEvent event)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetEventStatus", "event", event);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkSetEvent(
+ layer_data* layer_data,
+ VkEvent event)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkSetEvent", "event", event);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkResetEvent(
+ layer_data* layer_data,
+ VkEvent event)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkResetEvent", "event", event);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateQueryPool(
+ layer_data* layer_data,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateQueryPool", "pCreateInfo", "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, true, VALIDATION_ERROR_11c2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateQueryPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_11c1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateQueryPool", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_11c09005);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateQueryPool", "pCreateInfo->queryType", "VkQueryType", AllVkQueryTypeEnums, pCreateInfo->queryType, VALIDATION_ERROR_11c29a01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateQueryPool", "pQueryPool", pQueryPool, VALIDATION_ERROR_21e1fa01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyQueryPool(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(queryPool);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetQueryPoolResults(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ UNUSED_PARAMETER(firstQuery);
+ UNUSED_PARAMETER(queryCount);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetQueryPoolResults", "queryPool", queryPool);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetQueryPoolResults", "dataSize", "pData", dataSize, pData, true, true, VALIDATION_ERROR_2fa03c1b, VALIDATION_ERROR_2fa12201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false, false, VALIDATION_ERROR_2fa09001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateBuffer(
+ layer_data* layer_data,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateBuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, true, VALIDATION_ERROR_0142b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkBufferCreateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateBuffer", "pCreateInfo->pNext", "VkDedicatedAllocationBufferCreateInfoNV, VkExternalMemoryBufferCreateInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkBufferCreateInfo), allowed_structs_VkBufferCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0141c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_01409001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateBuffer", "pCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pCreateInfo->usage, true, false, VALIDATION_ERROR_01430603);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateBuffer", "pCreateInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->sharingMode, VALIDATION_ERROR_0142c001);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBuffer", "pBuffer", pBuffer, VALIDATION_ERROR_1ec10001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyBuffer(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(buffer);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateBufferView(
+ layer_data* layer_data,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateBufferView", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, true, VALIDATION_ERROR_01a2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateBufferView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_01a1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateBufferView", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_01a09005);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateBufferView", "pCreateInfo->buffer", pCreateInfo->buffer);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateBufferView", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, VALIDATION_ERROR_01a09201);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateBufferView", "pView", pView, VALIDATION_ERROR_1ee26a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyBufferView(
+ layer_data* layer_data,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(bufferView);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateImage(
+ layer_data* layer_data,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true, VALIDATION_ERROR_09e2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkImageCreateInfo[] = { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateImage", "pCreateInfo->pNext", "VkDedicatedAllocationImageCreateInfoNV, VkExternalMemoryImageCreateInfoKHR, VkExternalMemoryImageCreateInfoNV, VkImageSwapchainCreateInfoKHX", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_09e1c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_09e09001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImage", "pCreateInfo->imageType", "VkImageType", AllVkImageTypeEnums, pCreateInfo->imageType, VALIDATION_ERROR_09e0ac01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImage", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, VALIDATION_ERROR_09e09201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateImage", "pCreateInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->samples, true, true, VALIDATION_ERROR_09e2b401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImage", "pCreateInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pCreateInfo->tiling, VALIDATION_ERROR_09e2fa01);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateImage", "pCreateInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->usage, true, false, VALIDATION_ERROR_09e30603);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImage", "pCreateInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->sharingMode, VALIDATION_ERROR_09e2c001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImage", "pCreateInfo->initialLayout", "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->initialLayout, VALIDATION_ERROR_09e0b801);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImage", "pImage", pImage, VALIDATION_ERROR_20c17e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyImage(
+ layer_data* layer_data,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(image);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetImageSubresourceLayout(
+ layer_data* layer_data,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetImageSubresourceLayout", "image", image);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetImageSubresourceLayout", "pSubresource", pSubresource, VALIDATION_ERROR_2a624401);
+
+ if (pSubresource != NULL)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkGetImageSubresourceLayout", "pSubresource->aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pSubresource->aspectMask, true, false, VALIDATION_ERROR_0a400c03);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetImageSubresourceLayout", "pLayout", pLayout, VALIDATION_ERROR_2a61a201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateImageView(
+ layer_data* layer_data,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateImageView", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, true, VALIDATION_ERROR_0ac2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateImageView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0ac1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateImageView", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0ac09005);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateImageView", "pCreateInfo->image", pCreateInfo->image);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->viewType", "VkImageViewType", AllVkImageViewTypeEnums, pCreateInfo->viewType, VALIDATION_ERROR_0ac30801);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->format", "VkFormat", AllVkFormatEnums, pCreateInfo->format, VALIDATION_ERROR_0ac09201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->components.r", "VkComponentSwizzle", AllVkComponentSwizzleEnums, pCreateInfo->components.r, VALIDATION_ERROR_02e2a201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->components.g", "VkComponentSwizzle", AllVkComponentSwizzleEnums, pCreateInfo->components.g, VALIDATION_ERROR_02e09a01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->components.b", "VkComponentSwizzle", AllVkComponentSwizzleEnums, pCreateInfo->components.b, VALIDATION_ERROR_02e01001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateImageView", "pCreateInfo->components.a", "VkComponentSwizzle", AllVkComponentSwizzleEnums, pCreateInfo->components.a, VALIDATION_ERROR_02e00001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateImageView", "pCreateInfo->subresourceRange.aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pCreateInfo->subresourceRange.aspectMask, true, false, VALIDATION_ERROR_0a800c03);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateImageView", "pView", pView, VALIDATION_ERROR_20e26a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyImageView(
+ layer_data* layer_data,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(imageView);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateShaderModule(
+ layer_data* layer_data,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateShaderModule", "pCreateInfo", "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, true, VALIDATION_ERROR_12a2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateShaderModule", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_12a1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateShaderModule", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_12a09005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateShaderModule", "pCreateInfo->codeSize", "pCreateInfo->pCode", pCreateInfo->codeSize, pCreateInfo->pCode, true, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_12a10c01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateShaderModule", "pShaderModule", pShaderModule, VALIDATION_ERROR_22622e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyShaderModule(
+ layer_data* layer_data,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(shaderModule);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreatePipelineCache(
+ layer_data* layer_data,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreatePipelineCache", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, true, VALIDATION_ERROR_0f02b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreatePipelineCache", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0f01c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreatePipelineCache", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0f009005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreatePipelineCache", "pCreateInfo->initialDataSize", "pCreateInfo->pInitialData", pCreateInfo->initialDataSize, pCreateInfo->pInitialData, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0f019601);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineCache", "pPipelineCache", pPipelineCache, VALIDATION_ERROR_21a1de01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyPipelineCache(
+ layer_data* layer_data,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(pipelineCache);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPipelineCacheData(
+ layer_data* layer_data,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPipelineCacheData", "pipelineCache", pipelineCache);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPipelineCacheData", "pDataSize", "pData", pDataSize, pData, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2f812201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkMergePipelineCaches(
+ layer_data* layer_data,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkMergePipelineCaches", "dstCache", dstCache);
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkMergePipelineCaches", "srcCacheCount", "pSrcCaches", srcCacheCount, pSrcCaches, true, true);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateGraphicsPipelines(
+ layer_data* layer_data,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ UNUSED_PARAMETER(pipelineCache);
+
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCreateGraphicsPipelines", "createInfoCount", "pCreateInfos", "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", createInfoCount, pCreateInfos, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, true, true, VALIDATION_ERROR_20812001);
+
+ if (pCreateInfos != NULL)
+ {
+ for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
+ {
+ const VkStructureType allowed_structs_VkGraphicsPipelineCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineDiscardRectangleStateCreateInfoEXT", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkGraphicsPipelineCreateInfo), allowed_structs_VkGraphicsPipelineCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0961c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false, false, VALIDATION_ERROR_09609001);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].stageCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pStages", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", pCreateInfos[createInfoIndex].stageCount, pCreateInfos[createInfoIndex].pStages, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, true, true, VALIDATION_ERROR_09623e01);
+
+ if (pCreateInfos[createInfoIndex].pStages != NULL)
+ {
+ for (uint32_t stageIndex = 0; stageIndex < pCreateInfos[createInfoIndex].stageCount; ++stageIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), NULL, pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_1061c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].flags, VALIDATION_ERROR_10609005);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].stage", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].stage, true, true, VALIDATION_ERROR_1062d801);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].module", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].module);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pName", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pName, VALIDATION_ERROR_1061c001);
+
+ if (pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo != NULL)
+ {
+ skipCall |= validate_array(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->dataSize", ParameterName::IndexVector{ createInfoIndex, stageIndex }), ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->pData", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->dataSize, pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->pData, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_13612201);
+ }
+ }
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pVertexInputState, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, true, VALIDATION_ERROR_10a2b00b);
+
+ if (pCreateInfos[createInfoIndex].pVertexInputState != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pVertexInputState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_10a1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->flags, VALIDATION_ERROR_10a09005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->vertexBindingDescriptionCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pVertexInputState->pVertexBindingDescriptions", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->vertexBindingDescriptionCount, pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_10a26601);
+
+ if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions != NULL)
+ {
+ for (uint32_t vertexBindingDescriptionIndex = 0; vertexBindingDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexBindingDescriptionCount; ++vertexBindingDescriptionIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pVertexBindingDescriptions[%i].inputRate", ParameterName::IndexVector{ createInfoIndex, vertexBindingDescriptionIndex }), "VkVertexInputRate", AllVkVertexInputRateEnums, pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions[vertexBindingDescriptionIndex].inputRate, VALIDATION_ERROR_14c0ba01);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->vertexAttributeDescriptionCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pVertexInputState->pVertexAttributeDescriptions", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->vertexAttributeDescriptionCount, pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_10a26401);
+
+ if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions != NULL)
+ {
+ for (uint32_t vertexAttributeDescriptionIndex = 0; vertexAttributeDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexAttributeDescriptionCount; ++vertexAttributeDescriptionIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pVertexAttributeDescriptions[%i].format", ParameterName::IndexVector{ createInfoIndex, vertexAttributeDescriptionIndex }), "VkFormat", AllVkFormatEnums, pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions[vertexAttributeDescriptionIndex].format, VALIDATION_ERROR_14a09201);
+ }
+ }
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pInputAssemblyState, VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, true, VALIDATION_ERROR_0fc2b00b);
+
+ if (pCreateInfos[createInfoIndex].pInputAssemblyState != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pInputAssemblyState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0fc1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->flags, VALIDATION_ERROR_0fc09005);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->topology", ParameterName::IndexVector{ createInfoIndex }), "VkPrimitiveTopology", AllVkPrimitiveTopologyEnums, pCreateInfos[createInfoIndex].pInputAssemblyState->topology, VALIDATION_ERROR_0fc30001);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->primitiveRestartEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->primitiveRestartEnable);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pRasterizationState, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, true, VALIDATION_ERROR_1022b00b);
+
+ if (pCreateInfos[createInfoIndex].pRasterizationState != NULL)
+ {
+ const VkStructureType allowed_structs_VkPipelineRasterizationStateCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineRasterizationStateRasterizationOrderAMD", pCreateInfos[createInfoIndex].pRasterizationState->pNext, ARRAY_SIZE(allowed_structs_VkPipelineRasterizationStateCreateInfo), allowed_structs_VkPipelineRasterizationStateCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_1021c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->flags, VALIDATION_ERROR_10209005);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthClampEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthClampEnable);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->rasterizerDiscardEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->rasterizerDiscardEnable);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->polygonMode", ParameterName::IndexVector{ createInfoIndex }), "VkPolygonMode", AllVkPolygonModeEnums, pCreateInfos[createInfoIndex].pRasterizationState->polygonMode, VALIDATION_ERROR_10228601);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->cullMode", ParameterName::IndexVector{ createInfoIndex }), "VkCullModeFlagBits", AllVkCullModeFlagBits, pCreateInfos[createInfoIndex].pRasterizationState->cullMode, false, false, VALIDATION_ERROR_10203a01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->frontFace", ParameterName::IndexVector{ createInfoIndex }), "VkFrontFace", AllVkFrontFaceEnums, pCreateInfos[createInfoIndex].pRasterizationState->frontFace, VALIDATION_ERROR_10209801);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthBiasEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthBiasEnable);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pDynamicState, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, false, VALIDATION_ERROR_0fa2b00b);
+
+ if (pCreateInfos[createInfoIndex].pDynamicState != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pDynamicState->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0fa1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pDynamicState->flags, VALIDATION_ERROR_0fa09005);
+
+ skipCall |= validate_ranged_enum_array(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->dynamicStateCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pDynamicState->pDynamicStates", ParameterName::IndexVector{ createInfoIndex }), "VkDynamicState", AllVkDynamicStateEnums, pCreateInfos[createInfoIndex].pDynamicState->dynamicStateCount, pCreateInfos[createInfoIndex].pDynamicState->pDynamicStates, true, true);
+ }
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].renderPass", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].renderPass);
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateGraphicsPipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true, VALIDATION_ERROR_2080381b, VALIDATION_ERROR_2081e201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateComputePipelines(
+ layer_data* layer_data,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ UNUSED_PARAMETER(pipelineCache);
+
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCreateComputePipelines", "createInfoCount", "pCreateInfos", "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", createInfoCount, pCreateInfos, VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, true, true, VALIDATION_ERROR_1f212001);
+
+ if (pCreateInfos != NULL)
+ {
+ for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0301c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false, false, VALIDATION_ERROR_03009001);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", &(pCreateInfos[createInfoIndex].stage), VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, false, VALIDATION_ERROR_1062b00b);
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].stage.pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_1061c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.flags, VALIDATION_ERROR_10609005);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.stage", ParameterName::IndexVector{ createInfoIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].stage.stage, true, true, VALIDATION_ERROR_1062d801);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.module", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.module);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pName", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pName, VALIDATION_ERROR_1061c001);
+
+ if (pCreateInfos[createInfoIndex].stage.pSpecializationInfo != NULL)
+ {
+ skipCall |= validate_array(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->dataSize", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->pData", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pSpecializationInfo->dataSize, pCreateInfos[createInfoIndex].stage.pSpecializationInfo->pData, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_13612201);
+ }
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout);
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateComputePipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateComputePipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateComputePipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateComputePipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true, VALIDATION_ERROR_1f20381b, VALIDATION_ERROR_1f21e201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyPipeline(
+ layer_data* layer_data,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(pipeline);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipeline", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipeline", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipeline", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreatePipelineLayout(
+ layer_data* layer_data,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreatePipelineLayout", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, true, VALIDATION_ERROR_0fe2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreatePipelineLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0fe1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreatePipelineLayout", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0fe09005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreatePipelineLayout", "pCreateInfo->setLayoutCount", "pCreateInfo->pSetLayouts", pCreateInfo->setLayoutCount, pCreateInfo->pSetLayouts, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0fe22c01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreatePipelineLayout", "pCreateInfo->pushConstantRangeCount", "pCreateInfo->pPushConstantRanges", pCreateInfo->pushConstantRangeCount, pCreateInfo->pPushConstantRanges, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0fe1f801);
+
+ if (pCreateInfo->pPushConstantRanges != NULL)
+ {
+ for (uint32_t pushConstantRangeIndex = 0; pushConstantRangeIndex < pCreateInfo->pushConstantRangeCount; ++pushConstantRangeIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCreatePipelineLayout", ParameterName("pCreateInfo->pPushConstantRanges[%i].stageFlags", ParameterName::IndexVector{ pushConstantRangeIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfo->pPushConstantRanges[pushConstantRangeIndex].stageFlags, true, false, VALIDATION_ERROR_11a2dc03);
+ }
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreatePipelineLayout", "pPipelineLayout", pPipelineLayout, VALIDATION_ERROR_21c1e001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyPipelineLayout(
+ layer_data* layer_data,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(pipelineLayout);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyPipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateSampler(
+ layer_data* layer_data,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateSampler", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, true, VALIDATION_ERROR_1262b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkSamplerCreateInfo[] = { VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateSampler", "pCreateInfo->pNext", "VkSamplerReductionModeCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerCreateInfo), allowed_structs_VkSamplerCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_1261c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateSampler", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_12609005);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->magFilter", "VkFilter", AllVkFilterEnums, pCreateInfo->magFilter, VALIDATION_ERROR_1260c401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->minFilter", "VkFilter", AllVkFilterEnums, pCreateInfo->minFilter, VALIDATION_ERROR_1260ca01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->mipmapMode", "VkSamplerMipmapMode", AllVkSamplerMipmapModeEnums, pCreateInfo->mipmapMode, VALIDATION_ERROR_1260cc01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->addressModeU", "VkSamplerAddressMode", AllVkSamplerAddressModeEnums, pCreateInfo->addressModeU, VALIDATION_ERROR_12600201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->addressModeV", "VkSamplerAddressMode", AllVkSamplerAddressModeEnums, pCreateInfo->addressModeV, VALIDATION_ERROR_12600401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSampler", "pCreateInfo->addressModeW", "VkSamplerAddressMode", AllVkSamplerAddressModeEnums, pCreateInfo->addressModeW, VALIDATION_ERROR_12600601);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateSampler", "pCreateInfo->anisotropyEnable", pCreateInfo->anisotropyEnable);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateSampler", "pCreateInfo->compareEnable", pCreateInfo->compareEnable);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateSampler", "pCreateInfo->unnormalizedCoordinates", pCreateInfo->unnormalizedCoordinates);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSampler", "pSampler", pSampler, VALIDATION_ERROR_22222401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroySampler(
+ layer_data* layer_data,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(sampler);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateDescriptorSetLayout(
+ layer_data* layer_data,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDescriptorSetLayout", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, true, VALIDATION_ERROR_0502b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0501c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_05009001);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, pCreateInfo->pBindings, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0500fc01);
+
+ if (pCreateInfo->pBindings != NULL)
+ {
+ for (uint32_t bindingIndex = 0; bindingIndex < pCreateInfo->bindingCount; ++bindingIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateDescriptorSetLayout", ParameterName("pCreateInfo->pBindings[%i].descriptorType", ParameterName::IndexVector{ bindingIndex }), "VkDescriptorType", AllVkDescriptorTypeEnums, pCreateInfo->pBindings[bindingIndex].descriptorType, VALIDATION_ERROR_04e04e01);
+ }
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorSetLayout", "pSetLayout", pSetLayout, VALIDATION_ERROR_1f822a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyDescriptorSetLayout(
+ layer_data* layer_data,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(descriptorSetLayout);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateDescriptorPool(
+ layer_data* layer_data,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDescriptorPool", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, true, VALIDATION_ERROR_0482b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDescriptorPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0481c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateDescriptorPool", "pCreateInfo->flags", "VkDescriptorPoolCreateFlagBits", AllVkDescriptorPoolCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_04809001);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateDescriptorPool", "pCreateInfo->poolSizeCount", "pCreateInfo->pPoolSizes", pCreateInfo->poolSizeCount, pCreateInfo->pPoolSizes, true, true, VALIDATION_ERROR_0482881b, VALIDATION_ERROR_0481e401);
+
+ if (pCreateInfo->pPoolSizes != NULL)
+ {
+ for (uint32_t poolSizeIndex = 0; poolSizeIndex < pCreateInfo->poolSizeCount; ++poolSizeIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateDescriptorPool", ParameterName("pCreateInfo->pPoolSizes[%i].type", ParameterName::IndexVector{ poolSizeIndex }), "VkDescriptorType", AllVkDescriptorTypeEnums, pCreateInfo->pPoolSizes[poolSizeIndex].type, VALIDATION_ERROR_04a30401);
+ }
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorPool", "pDescriptorPool", pDescriptorPool, VALIDATION_ERROR_1f612e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyDescriptorPool(
+ layer_data* layer_data,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(descriptorPool);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkResetDescriptorPool(
+ layer_data* layer_data,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkResetDescriptorPool", "descriptorPool", descriptorPool);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkResetDescriptorPool", "flags", flags, VALIDATION_ERROR_32a09005);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkAllocateDescriptorSets(
+ layer_data* layer_data,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkAllocateDescriptorSets", "pAllocateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, true, VALIDATION_ERROR_04c2b00b);
+
+ if (pAllocateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkAllocateDescriptorSets", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_04c1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorPool", pAllocateInfo->descriptorPool);
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pAllocateInfo->pSetLayouts", pAllocateInfo->descriptorSetCount, pAllocateInfo->pSetLayouts, true, true);
+ }
+
+ if (pAllocateInfo != NULL) {
+ skipCall |= validate_array(layer_data->report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pDescriptorSets", pAllocateInfo->descriptorSetCount, pDescriptorSets, true, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_16a13001);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkFreeDescriptorSets(
+ layer_data* layer_data,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ UNUSED_PARAMETER(pDescriptorSets);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkFreeDescriptorSets", "descriptorPool", descriptorPool);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkUpdateDescriptorSets(
+ layer_data* layer_data,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkUpdateDescriptorSets", "descriptorWriteCount", "pDescriptorWrites", "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", descriptorWriteCount, pDescriptorWrites, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, false, true, VALIDATION_ERROR_33c13601);
+
+ if (pDescriptorWrites != NULL)
+ {
+ for (uint32_t descriptorWriteIndex = 0; descriptorWriteIndex < descriptorWriteCount; ++descriptorWriteIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].pNext", ParameterName::IndexVector{ descriptorWriteIndex }), NULL, pDescriptorWrites[descriptorWriteIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_15c1c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].descriptorType", ParameterName::IndexVector{ descriptorWriteIndex }), "VkDescriptorType", AllVkDescriptorTypeEnums, pDescriptorWrites[descriptorWriteIndex].descriptorType, VALIDATION_ERROR_15c04e01);
+ }
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkUpdateDescriptorSets", "descriptorCopyCount", "pDescriptorCopies", "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", descriptorCopyCount, pDescriptorCopies, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, false, true, VALIDATION_ERROR_33c12c01);
+
+ if (pDescriptorCopies != NULL)
+ {
+ for (uint32_t descriptorCopyIndex = 0; descriptorCopyIndex < descriptorCopyCount; ++descriptorCopyIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].pNext", ParameterName::IndexVector{ descriptorCopyIndex }), NULL, pDescriptorCopies[descriptorCopyIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0321c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].srcSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].srcSet);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].dstSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].dstSet);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateFramebuffer(
+ layer_data* layer_data,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateFramebuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, true, VALIDATION_ERROR_0942b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateFramebuffer", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0941c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateFramebuffer", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_09409005);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateFramebuffer", "pCreateInfo->renderPass", pCreateInfo->renderPass);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateFramebuffer", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_0940f201);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateFramebuffer", "pFramebuffer", pFramebuffer, VALIDATION_ERROR_20617801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyFramebuffer(
+ layer_data* layer_data,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(framebuffer);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateRenderPass(
+ layer_data* layer_data,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo", "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, true, VALIDATION_ERROR_1222b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkRenderPassCreateInfo[] = { VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo->pNext", "VkRenderPassMultiviewCreateInfoKHX", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkRenderPassCreateInfo), allowed_structs_VkRenderPassCreateInfo, GeneratedHeaderVersion, VALIDATION_ERROR_1221c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_12209005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_1220f201);
+
+ if (pCreateInfo->pAttachments != NULL)
+ {
+ for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfo->attachmentCount; ++attachmentIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, false, false, VALIDATION_ERROR_00809001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].format", ParameterName::IndexVector{ attachmentIndex }), "VkFormat", AllVkFormatEnums, pCreateInfo->pAttachments[attachmentIndex].format, VALIDATION_ERROR_00809201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].samples", ParameterName::IndexVector{ attachmentIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->pAttachments[attachmentIndex].samples, true, true, VALIDATION_ERROR_0082b401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].loadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", AllVkAttachmentLoadOpEnums, pCreateInfo->pAttachments[attachmentIndex].loadOp, VALIDATION_ERROR_0080c201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].storeOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentStoreOp", AllVkAttachmentStoreOpEnums, pCreateInfo->pAttachments[attachmentIndex].storeOp, VALIDATION_ERROR_0082e401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].stencilLoadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", AllVkAttachmentLoadOpEnums, pCreateInfo->pAttachments[attachmentIndex].stencilLoadOp, VALIDATION_ERROR_0082e001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].stencilStoreOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentStoreOp", AllVkAttachmentStoreOpEnums, pCreateInfo->pAttachments[attachmentIndex].stencilStoreOp, VALIDATION_ERROR_0082e201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].initialLayout", ParameterName::IndexVector{ attachmentIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pAttachments[attachmentIndex].initialLayout, VALIDATION_ERROR_0080b801);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].finalLayout", ParameterName::IndexVector{ attachmentIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pAttachments[attachmentIndex].finalLayout, VALIDATION_ERROR_00808e01);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo->subpassCount", "pCreateInfo->pSubpasses", pCreateInfo->subpassCount, pCreateInfo->pSubpasses, true, true, VALIDATION_ERROR_1222e61b, VALIDATION_ERROR_12224201);
+
+ if (pCreateInfo->pSubpasses != NULL)
+ {
+ for (uint32_t subpassIndex = 0; subpassIndex < pCreateInfo->subpassCount; ++subpassIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), "VkSubpassDescriptionFlagBits", AllVkSubpassDescriptionFlagBits, pCreateInfo->pSubpasses[subpassIndex].flags, false, false, VALIDATION_ERROR_14009001);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pipelineBindPoint", ParameterName::IndexVector{ subpassIndex }), "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pSubpasses[subpassIndex].pipelineBindPoint, VALIDATION_ERROR_14027e01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].inputAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pInputAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].inputAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pInputAttachments, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_14019a01);
+
+ if (pCreateInfo->pSubpasses[subpassIndex].pInputAttachments != NULL)
+ {
+ for (uint32_t inputAttachmentIndex = 0; inputAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].inputAttachmentCount; ++inputAttachmentIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pInputAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, inputAttachmentIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pSubpasses[subpassIndex].pInputAttachments[inputAttachmentIndex].layout, VALIDATION_ERROR_00a0be01);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].colorAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pColorAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pColorAttachments, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_14011001);
+
+ if (pCreateInfo->pSubpasses[subpassIndex].pColorAttachments != NULL)
+ {
+ for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pColorAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, colorAttachmentIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pSubpasses[subpassIndex].pColorAttachments[colorAttachmentIndex].layout, VALIDATION_ERROR_00a0be01);
+ }
+ }
+
+ if (pCreateInfo->pSubpasses[subpassIndex].pResolveAttachments != NULL)
+ {
+ for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pResolveAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, colorAttachmentIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pSubpasses[subpassIndex].pResolveAttachments[colorAttachmentIndex].layout, VALIDATION_ERROR_00a0be01);
+ }
+ }
+
+ if (pCreateInfo->pSubpasses[subpassIndex].pDepthStencilAttachment != NULL)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pDepthStencilAttachment->layout", ParameterName::IndexVector{ subpassIndex }), "VkImageLayout", AllVkImageLayoutEnums, pCreateInfo->pSubpasses[subpassIndex].pDepthStencilAttachment->layout, VALIDATION_ERROR_00a0be01);
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].preserveAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pPreserveAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].preserveAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pPreserveAttachments, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_1401f001);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateRenderPass", "pCreateInfo->dependencyCount", "pCreateInfo->pDependencies", pCreateInfo->dependencyCount, pCreateInfo->pDependencies, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_12212601);
+
+ if (pCreateInfo->pDependencies != NULL)
+ {
+ for (uint32_t dependencyIndex = 0; dependencyIndex < pCreateInfo->dependencyCount; ++dependencyIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, true, false, VALIDATION_ERROR_13e2d403);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, true, false, VALIDATION_ERROR_13e07803);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, false, false, VALIDATION_ERROR_13e2c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, false, false, VALIDATION_ERROR_13e06801);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, false, false, VALIDATION_ERROR_13e03e01);
+ }
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateRenderPass", "pRenderPass", pRenderPass, VALIDATION_ERROR_22021601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyRenderPass(
+ layer_data* layer_data,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(renderPass);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetRenderAreaGranularity(
+ layer_data* layer_data,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetRenderAreaGranularity", "renderPass", renderPass);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetRenderAreaGranularity", "pGranularity", pGranularity, VALIDATION_ERROR_30017a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateCommandPool(
+ layer_data* layer_data,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateCommandPool", "pCreateInfo", "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, true, VALIDATION_ERROR_02c2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateCommandPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_02c1c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateCommandPool", "pCreateInfo->flags", "VkCommandPoolCreateFlagBits", AllVkCommandPoolCreateFlagBits, pCreateInfo->flags, false, false, VALIDATION_ERROR_02c09001);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateCommandPool", "pCommandPool", pCommandPool, VALIDATION_ERROR_1f011601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyCommandPool(
+ layer_data* layer_data,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(commandPool);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkResetCommandPool(
+ layer_data* layer_data,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkResetCommandPool", "commandPool", commandPool);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkResetCommandPool", "flags", "VkCommandPoolResetFlagBits", AllVkCommandPoolResetFlagBits, flags, false, false, VALIDATION_ERROR_32809001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkAllocateCommandBuffers(
+ layer_data* layer_data,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkAllocateCommandBuffers", "pAllocateInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, true, VALIDATION_ERROR_0262b00b);
+
+ if (pAllocateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkAllocateCommandBuffers", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0261c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandPool", pAllocateInfo->commandPool);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkAllocateCommandBuffers", "pAllocateInfo->level", "VkCommandBufferLevel", AllVkCommandBufferLevelEnums, pAllocateInfo->level, VALIDATION_ERROR_0260c001);
+ }
+
+ if (pAllocateInfo != NULL) {
+ skipCall |= validate_array(layer_data->report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandBufferCount", "pCommandBuffers", pAllocateInfo->commandBufferCount, pCommandBuffers, true, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_16811401);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkFreeCommandBuffers(
+ layer_data* layer_data,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ UNUSED_PARAMETER(pCommandBuffers);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkFreeCommandBuffers", "commandPool", commandPool);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkBeginCommandBuffer(
+ layer_data* layer_data,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkBeginCommandBuffer", "pBeginInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", pBeginInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, true, VALIDATION_ERROR_0282b00b);
+
+ if (pBeginInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkCommandBufferBeginInfo[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkBeginCommandBuffer", "pBeginInfo->pNext", "VkDeviceGroupCommandBufferBeginInfoKHX", pBeginInfo->pNext, ARRAY_SIZE(allowed_structs_VkCommandBufferBeginInfo), allowed_structs_VkCommandBufferBeginInfo, GeneratedHeaderVersion, VALIDATION_ERROR_0281c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkBeginCommandBuffer", "pBeginInfo->flags", "VkCommandBufferUsageFlagBits", AllVkCommandBufferUsageFlagBits, pBeginInfo->flags, false, false, VALIDATION_ERROR_02809001);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkResetCommandBuffer(
+ layer_data* layer_data,
+ VkCommandBufferResetFlags flags)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkResetCommandBuffer", "flags", "VkCommandBufferResetFlagBits", AllVkCommandBufferResetFlagBits, flags, false, false, VALIDATION_ERROR_32609001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBindPipeline(
+ layer_data* layer_data,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBindPipeline", "pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pipelineBindPoint, VALIDATION_ERROR_18027e01);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBindPipeline", "pipeline", pipeline);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetScissor(
+ layer_data* layer_data,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors)
+{
+ UNUSED_PARAMETER(firstScissor);
+
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdSetScissor", "scissorCount", "pScissors", scissorCount, pScissors, true, true, VALIDATION_ERROR_1d82b61b, VALIDATION_ERROR_1d822601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetBlendConstants(
+ layer_data* layer_data,
+ const float blendConstants[4])
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdSetBlendConstants", "blendConstants", blendConstants, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetStencilCompareMask(
+ layer_data* layer_data,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
+{
+ UNUSED_PARAMETER(compareMask);
+
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdSetStencilCompareMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, VALIDATION_ERROR_1da08403);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetStencilWriteMask(
+ layer_data* layer_data,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
+{
+ UNUSED_PARAMETER(writeMask);
+
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdSetStencilWriteMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, VALIDATION_ERROR_1de08403);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetStencilReference(
+ layer_data* layer_data,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
+{
+ UNUSED_PARAMETER(reference);
+
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdSetStencilReference", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, VALIDATION_ERROR_1dc08403);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBindDescriptorSets(
+ layer_data* layer_data,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ UNUSED_PARAMETER(firstSet);
+
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBindDescriptorSets", "pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pipelineBindPoint, VALIDATION_ERROR_17c27e01);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBindDescriptorSets", "layout", layout);
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkCmdBindDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount, pDescriptorSets, true, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdBindDescriptorSets", "dynamicOffsetCount", "pDynamicOffsets", dynamicOffsetCount, pDynamicOffsets, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_17c15401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBindIndexBuffer(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ UNUSED_PARAMETER(offset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBindIndexBuffer", "buffer", buffer);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBindIndexBuffer", "indexType", "VkIndexType", AllVkIndexTypeEnums, indexType, VALIDATION_ERROR_17e0b201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBindVertexBuffers(
+ layer_data* layer_data,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ UNUSED_PARAMETER(firstBinding);
+
+ bool skipCall = false;
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkCmdBindVertexBuffers", "bindingCount", "pBuffers", bindingCount, pBuffers, true, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdBindVertexBuffers", "bindingCount", "pOffsets", bindingCount, pOffsets, true, true, VALIDATION_ERROR_1820181b, VALIDATION_ERROR_1821d201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDrawIndirect(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ UNUSED_PARAMETER(offset);
+ UNUSED_PARAMETER(drawCount);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndirect", "buffer", buffer);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDrawIndexedIndirect(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ UNUSED_PARAMETER(offset);
+ UNUSED_PARAMETER(drawCount);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndexedIndirect", "buffer", buffer);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDispatchIndirect(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ UNUSED_PARAMETER(offset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDispatchIndirect", "buffer", buffer);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdCopyBuffer(
+ layer_data* layer_data,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyBuffer", "srcBuffer", srcBuffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyBuffer", "dstBuffer", dstBuffer);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdCopyBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_18c2ac1b, VALIDATION_ERROR_18c21001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdCopyImage(
+ layer_data* layer_data,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyImage", "srcImage", srcImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdCopyImage", "srcImageLayout", "VkImageLayout", AllVkImageLayoutEnums, srcImageLayout, VALIDATION_ERROR_1902d001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyImage", "dstImage", dstImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdCopyImage", "dstImageLayout", "VkImageLayout", AllVkImageLayoutEnums, dstImageLayout, VALIDATION_ERROR_19007401);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdCopyImage", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_1902ac1b, VALIDATION_ERROR_19021001);
+
+ if (pRegions != NULL)
+ {
+ for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBlitImage(
+ layer_data* layer_data,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBlitImage", "srcImage", srcImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBlitImage", "srcImageLayout", "VkImageLayout", AllVkImageLayoutEnums, srcImageLayout, VALIDATION_ERROR_1842d001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBlitImage", "dstImage", dstImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBlitImage", "dstImageLayout", "VkImageLayout", AllVkImageLayoutEnums, dstImageLayout, VALIDATION_ERROR_18407401);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdBlitImage", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_1842ac1b, VALIDATION_ERROR_18421001);
+
+ if (pRegions != NULL)
+ {
+ for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+ }
+ }
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBlitImage", "filter", "VkFilter", AllVkFilterEnums, filter, VALIDATION_ERROR_18408c01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdCopyBufferToImage(
+ layer_data* layer_data,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyBufferToImage", "srcBuffer", srcBuffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyBufferToImage", "dstImage", dstImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdCopyBufferToImage", "dstImageLayout", "VkImageLayout", AllVkImageLayoutEnums, dstImageLayout, VALIDATION_ERROR_18e07401);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdCopyBufferToImage", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_18e2ac1b, VALIDATION_ERROR_18e21001);
+
+ if (pRegions != NULL)
+ {
+ for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdCopyBufferToImage", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdCopyImageToBuffer(
+ layer_data* layer_data,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyImageToBuffer", "srcImage", srcImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdCopyImageToBuffer", "srcImageLayout", "VkImageLayout", AllVkImageLayoutEnums, srcImageLayout, VALIDATION_ERROR_1922d001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyImageToBuffer", "dstBuffer", dstBuffer);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdCopyImageToBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_1922ac1b, VALIDATION_ERROR_19221001);
+
+ if (pRegions != NULL)
+ {
+ for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdCopyImageToBuffer", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdUpdateBuffer(
+ layer_data* layer_data,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ UNUSED_PARAMETER(dstOffset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdUpdateBuffer", "dstBuffer", dstBuffer);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdUpdateBuffer", "dataSize", "pData", dataSize, pData, true, true, VALIDATION_ERROR_1e403c1b, VALIDATION_ERROR_1e412201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdFillBuffer(
+ layer_data* layer_data,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ UNUSED_PARAMETER(dstOffset);
+ UNUSED_PARAMETER(size);
+ UNUSED_PARAMETER(data);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdFillBuffer", "dstBuffer", dstBuffer);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdClearColorImage(
+ layer_data* layer_data,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdClearColorImage", "image", image);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdClearColorImage", "imageLayout", "VkImageLayout", AllVkImageLayoutEnums, imageLayout, VALIDATION_ERROR_1880a601);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdClearColorImage", "pColor", pColor, VALIDATION_ERROR_18810e01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdClearColorImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true, VALIDATION_ERROR_1882a41b, VALIDATION_ERROR_18820601);
+
+ if (pRanges != NULL)
+ {
+ for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdClearColorImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true, false, VALIDATION_ERROR_0a800c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdClearDepthStencilImage(
+ layer_data* layer_data,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdClearDepthStencilImage", "image", image);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdClearDepthStencilImage", "imageLayout", "VkImageLayout", AllVkImageLayoutEnums, imageLayout, VALIDATION_ERROR_18a0a601);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdClearDepthStencilImage", "pDepthStencil", pDepthStencil, VALIDATION_ERROR_18a12801);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdClearDepthStencilImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true, VALIDATION_ERROR_18a2a41b, VALIDATION_ERROR_18a20601);
+
+ if (pRanges != NULL)
+ {
+ for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdClearDepthStencilImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true, false, VALIDATION_ERROR_0a800c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdClearAttachments(
+ layer_data* layer_data,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdClearAttachments", "attachmentCount", "pAttachments", attachmentCount, pAttachments, true, true, VALIDATION_ERROR_18600e1b, VALIDATION_ERROR_1860f201);
+
+ if (pAttachments != NULL)
+ {
+ for (uint32_t attachmentIndex = 0; attachmentIndex < attachmentCount; ++attachmentIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdClearAttachments", ParameterName("pAttachments[%i].aspectMask", ParameterName::IndexVector{ attachmentIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pAttachments[attachmentIndex].aspectMask, true, false, VALIDATION_ERROR_01c00c03);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdClearAttachments", "rectCount", "pRects", rectCount, pRects, true, true, VALIDATION_ERROR_1862aa1b, VALIDATION_ERROR_18620e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdResolveImage(
+ layer_data* layer_data,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdResolveImage", "srcImage", srcImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdResolveImage", "srcImageLayout", "VkImageLayout", AllVkImageLayoutEnums, srcImageLayout, VALIDATION_ERROR_1c82d001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdResolveImage", "dstImage", dstImage);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdResolveImage", "dstImageLayout", "VkImageLayout", AllVkImageLayoutEnums, dstImageLayout, VALIDATION_ERROR_1c807401);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdResolveImage", "regionCount", "pRegions", regionCount, pRegions, true, true, VALIDATION_ERROR_1c82ac1b, VALIDATION_ERROR_1c821001);
+
+ if (pRegions != NULL)
+ {
+ for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
+ {
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, VALIDATION_ERROR_0a600c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetEvent(
+ layer_data* layer_data,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdSetEvent", "event", event);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdSetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true, false, VALIDATION_ERROR_1d42de03);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdResetEvent(
+ layer_data* layer_data,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdResetEvent", "event", event);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdResetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true, false, VALIDATION_ERROR_1c42de03);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdWaitEvents(
+ layer_data* layer_data,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkCmdWaitEvents", "eventCount", "pEvents", eventCount, pEvents, true, true);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true, false, VALIDATION_ERROR_1e62d403);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true, false, VALIDATION_ERROR_1e607803);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdWaitEvents", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1e61ac01);
+
+ if (pMemoryBarriers != NULL)
+ {
+ for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0c81c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0c82c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_0c806801);
+ }
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdWaitEvents", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1e610401);
+
+ if (pBufferMemoryBarriers != NULL)
+ {
+ for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0181c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0182c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_01806801);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
+ }
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdWaitEvents", "imageMemoryBarrierCount", "pImageMemoryBarriers", "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", imageMemoryBarrierCount, pImageMemoryBarriers, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1e618a01);
+
+ if (pImageMemoryBarriers != NULL)
+ {
+ for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0a01c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0a02c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_0a006801);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout, VALIDATION_ERROR_0a00dc01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].newLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].newLayout, VALIDATION_ERROR_0a00d401);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true, false, VALIDATION_ERROR_0a800c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdPipelineBarrier(
+ layer_data* layer_data,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true, false, VALIDATION_ERROR_1b82d403);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true, false, VALIDATION_ERROR_1b807803);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", "dependencyFlags", "VkDependencyFlagBits", AllVkDependencyFlagBits, dependencyFlags, false, false, VALIDATION_ERROR_1b803e01);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdPipelineBarrier", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1b81ac01);
+
+ if (pMemoryBarriers != NULL)
+ {
+ for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0c81c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0c82c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_0c806801);
+ }
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdPipelineBarrier", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1b810401);
+
+ if (pBufferMemoryBarriers != NULL)
+ {
+ for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0181c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0182c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_01806801);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
+ }
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkCmdPipelineBarrier", "imageMemoryBarrierCount", "pImageMemoryBarriers", "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", imageMemoryBarrierCount, pImageMemoryBarriers, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, false, true, VALIDATION_ERROR_1b818a01);
+
+ if (pImageMemoryBarriers != NULL)
+ {
+ for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0a01c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false, false, VALIDATION_ERROR_0a02c401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false, false, VALIDATION_ERROR_0a006801);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout, VALIDATION_ERROR_0a00dc01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].newLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].newLayout, VALIDATION_ERROR_0a00d401);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true, false, VALIDATION_ERROR_0a800c03);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBeginQuery(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ UNUSED_PARAMETER(query);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBeginQuery", "queryPool", queryPool);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdBeginQuery", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, false, false, VALIDATION_ERROR_17809001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdEndQuery(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ UNUSED_PARAMETER(query);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdEndQuery", "queryPool", queryPool);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdResetQueryPool(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ UNUSED_PARAMETER(firstQuery);
+ UNUSED_PARAMETER(queryCount);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdResetQueryPool", "queryPool", queryPool);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdWriteTimestamp(
+ layer_data* layer_data,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ UNUSED_PARAMETER(query);
+
+ bool skipCall = false;
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdWriteTimestamp", "pipelineStage", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pipelineStage, true, true, VALIDATION_ERROR_1e828401);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdWriteTimestamp", "queryPool", queryPool);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdCopyQueryPoolResults(
+ layer_data* layer_data,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ UNUSED_PARAMETER(firstQuery);
+ UNUSED_PARAMETER(queryCount);
+ UNUSED_PARAMETER(dstOffset);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyQueryPoolResults", "queryPool", queryPool);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdCopyQueryPoolResults", "dstBuffer", dstBuffer);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdCopyQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false, false, VALIDATION_ERROR_19409001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdPushConstants(
+ layer_data* layer_data,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ UNUSED_PARAMETER(offset);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPushConstants", "layout", layout);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCmdPushConstants", "stageFlags", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, stageFlags, true, false, VALIDATION_ERROR_1bc2dc03);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdPushConstants", "size", "pValues", size, pValues, true, true, VALIDATION_ERROR_1bc2c21b, VALIDATION_ERROR_1bc26201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdBeginRenderPass(
+ layer_data* layer_data,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCmdBeginRenderPass", "pRenderPassBegin", "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", pRenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, true, VALIDATION_ERROR_1202b00b);
+
+ if (pRenderPassBegin != NULL)
+ {
+ const VkStructureType allowed_structs_VkRenderPassBeginInfo[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->pNext", "VkDeviceGroupRenderPassBeginInfoKHX", pRenderPassBegin->pNext, ARRAY_SIZE(allowed_structs_VkRenderPassBeginInfo), allowed_structs_VkRenderPassBeginInfo, GeneratedHeaderVersion, VALIDATION_ERROR_1201c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->renderPass", pRenderPassBegin->renderPass);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->framebuffer", pRenderPassBegin->framebuffer);
+ }
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdBeginRenderPass", "contents", "VkSubpassContents", AllVkSubpassContentsEnums, contents, VALIDATION_ERROR_17a03201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdNextSubpass(
+ layer_data* layer_data,
+ VkSubpassContents contents)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdNextSubpass", "contents", "VkSubpassContents", AllVkSubpassContentsEnums, contents, VALIDATION_ERROR_1b603201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdExecuteCommands(
+ layer_data* layer_data,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkCmdExecuteCommands", "commandBufferCount", "pCommandBuffers", commandBufferCount, pCommandBuffers, true, true);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkDestroySurfaceKHR(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(surface);
+
+ bool skipCall = false;
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(
+ instance_layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "surface", surface);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "pSupported", pSupported, VALIDATION_ERROR_2ee24601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "surface", surface);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "pSurfaceCapabilities", pSurfaceCapabilities, VALIDATION_ERROR_2e624a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "surface", surface);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "pSurfaceFormatCount", "pSurfaceFormats", pSurfaceFormatCount, pSurfaceFormats, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2ea24e01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "surface", surface);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "pPresentModeCount", "pPresentModes", pPresentModeCount, pPresentModes, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2ec1ea01);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkCreateSwapchainKHR(
+ layer_data* layer_data,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkCreateSwapchainKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkCreateSwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, true, VALIDATION_ERROR_1462b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkSwapchainCreateInfoKHR[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX, VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->pNext", "VkDeviceGroupSwapchainCreateInfoKHX, VkSwapchainCounterCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSwapchainCreateInfoKHR), allowed_structs_VkSwapchainCreateInfoKHR, GeneratedHeaderVersion, VALIDATION_ERROR_1461c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->flags", "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfo->flags, false, false, VALIDATION_ERROR_14609001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->surface", pCreateInfo->surface);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->imageFormat", "VkFormat", AllVkFormatEnums, pCreateInfo->imageFormat, VALIDATION_ERROR_1460a401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->imageColorSpace", "VkColorSpaceKHR", AllVkColorSpaceKHREnums, pCreateInfo->imageColorSpace, VALIDATION_ERROR_1460a201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->imageUsage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->imageUsage, true, false, VALIDATION_ERROR_1460ae03);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->imageSharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->imageSharingMode, VALIDATION_ERROR_1460a801);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->preTransform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->preTransform, true, true, VALIDATION_ERROR_14629401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->compositeAlpha", "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfo->compositeAlpha, true, true, VALIDATION_ERROR_14602e01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->presentMode", "VkPresentModeKHR", AllVkPresentModeKHREnums, pCreateInfo->presentMode, VALIDATION_ERROR_14629601);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateSwapchainKHR", "pCreateInfo->clipped", pCreateInfo->clipped);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSwapchainKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSwapchainKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSwapchainKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSwapchainKHR", "pSwapchain", pSwapchain, VALIDATION_ERROR_22a25201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroySwapchainKHR(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(swapchain);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkDestroySwapchainKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkDestroySwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySwapchainKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySwapchainKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroySwapchainKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetSwapchainImagesKHR(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainImagesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainImagesKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSwapchainImagesKHR", "swapchain", swapchain);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetSwapchainImagesKHR", "pSwapchainImageCount", "pSwapchainImages", pSwapchainImageCount, pSwapchainImages, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_30825601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkAcquireNextImageKHR(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ UNUSED_PARAMETER(timeout);
+ UNUSED_PARAMETER(semaphore);
+ UNUSED_PARAMETER(fence);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkAcquireNextImageKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkAcquireNextImageKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkAcquireNextImageKHR", "swapchain", swapchain);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAcquireNextImageKHR", "pImageIndex", pImageIndex, VALIDATION_ERROR_16418601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkQueuePresentKHR(
+ layer_data* layer_data,
+ const VkPresentInfoKHR* pPresentInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkQueuePresentKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkQueuePresentKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo", "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", pPresentInfo, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, true, VALIDATION_ERROR_1122b00b);
+
+ if (pPresentInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkPresentInfoKHR[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX, VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo->pNext", "VkDeviceGroupPresentInfoKHX, VkDisplayPresentInfoKHR, VkPresentRegionsKHR, VkPresentTimesInfoGOOGLE", pPresentInfo->pNext, ARRAY_SIZE(allowed_structs_VkPresentInfoKHR), allowed_structs_VkPresentInfoKHR, GeneratedHeaderVersion, VALIDATION_ERROR_1121c40d);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo->waitSemaphoreCount", "pPresentInfo->pWaitSemaphores", pPresentInfo->waitSemaphoreCount, pPresentInfo->pWaitSemaphores, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_11227601);
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pSwapchains", pPresentInfo->swapchainCount, pPresentInfo->pSwapchains, true, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pImageIndices", pPresentInfo->swapchainCount, pPresentInfo->pImageIndices, true, true, VALIDATION_ERROR_1122f21b, VALIDATION_ERROR_11218801);
+
+ skipCall |= validate_array(layer_data->report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pResults", pPresentInfo->swapchainCount, pPresentInfo->pResults, true, false, VALIDATION_ERROR_1122f21b, VALIDATION_ERROR_11221e01);
+ }
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ instance_layer_data* layer_data,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceDisplayPropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2b81f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ instance_layer_data* layer_data,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2b61f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDisplayPlaneSupportedDisplaysKHR(
+ instance_layer_data* layer_data,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays)
+{
+ UNUSED_PARAMETER(planeIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetDisplayPlaneSupportedDisplaysKHR", "pDisplayCount", "pDisplays", pDisplayCount, pDisplays, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_29c15201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDisplayModePropertiesKHR(
+ instance_layer_data* layer_data,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetDisplayModePropertiesKHR", "display", display);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetDisplayModePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2981f401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateDisplayModeKHR(
+ instance_layer_data* layer_data,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateDisplayModeKHR", "display", display);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDisplayModeKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, true, VALIDATION_ERROR_0722b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDisplayModeKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0721c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateDisplayModeKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_07209005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayModeKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayModeKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayModeKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayModeKHR", "pMode", pMode, VALIDATION_ERROR_1fe1bc01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDisplayPlaneCapabilitiesKHR(
+ instance_layer_data* layer_data,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+ UNUSED_PARAMETER(planeIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetDisplayPlaneCapabilitiesKHR", "mode", mode);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetDisplayPlaneCapabilitiesKHR", "pCapabilities", pCapabilities, VALIDATION_ERROR_29a10a01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateDisplayPlaneSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_0782b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0781c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_07809005);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->displayMode", pCreateInfo->displayMode);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->transform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->transform, true, true, VALIDATION_ERROR_07830201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->alphaMode", "VkDisplayPlaneAlphaFlagBitsKHR", AllVkDisplayPlaneAlphaFlagBitsKHR, pCreateInfo->alphaMode, true, true, VALIDATION_ERROR_07800a01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDisplayPlaneSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_20024801);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkCreateSharedSwapchainsKHR(
+ layer_data* layer_data,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_display) skipCall |= OutputExtensionError(layer_data, "vkCreateSharedSwapchainsKHR", VK_KHR_DISPLAY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkCreateSharedSwapchainsKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_display_swapchain) skipCall |= OutputExtensionError(layer_data, "vkCreateSharedSwapchainsKHR", VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pCreateInfos", swapchainCount, pCreateInfos, true, true, VALIDATION_ERROR_2282f21b, VALIDATION_ERROR_22812001);
+
+ if (pCreateInfos != NULL)
+ {
+ for (uint32_t swapchainIndex = 0; swapchainIndex < swapchainCount; ++swapchainIndex)
+ {
+ const VkStructureType allowed_structs_VkSwapchainCreateInfoKHR[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX, VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ swapchainIndex }), "VkDeviceGroupSwapchainCreateInfoKHX, VkSwapchainCounterCreateInfoEXT", pCreateInfos[swapchainIndex].pNext, ARRAY_SIZE(allowed_structs_VkSwapchainCreateInfoKHR), allowed_structs_VkSwapchainCreateInfoKHR, GeneratedHeaderVersion, VALIDATION_ERROR_1461c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ swapchainIndex }), "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfos[swapchainIndex].flags, false, false, VALIDATION_ERROR_14609001);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].surface", ParameterName::IndexVector{ swapchainIndex }), pCreateInfos[swapchainIndex].surface);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageFormat", ParameterName::IndexVector{ swapchainIndex }), "VkFormat", AllVkFormatEnums, pCreateInfos[swapchainIndex].imageFormat, VALIDATION_ERROR_1460a401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageColorSpace", ParameterName::IndexVector{ swapchainIndex }), "VkColorSpaceKHR", AllVkColorSpaceKHREnums, pCreateInfos[swapchainIndex].imageColorSpace, VALIDATION_ERROR_1460a201);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageUsage", ParameterName::IndexVector{ swapchainIndex }), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfos[swapchainIndex].imageUsage, true, false, VALIDATION_ERROR_1460ae03);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageSharingMode", ParameterName::IndexVector{ swapchainIndex }), "VkSharingMode", AllVkSharingModeEnums, pCreateInfos[swapchainIndex].imageSharingMode, VALIDATION_ERROR_1460a801);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].preTransform", ParameterName::IndexVector{ swapchainIndex }), "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfos[swapchainIndex].preTransform, true, true, VALIDATION_ERROR_14629401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].compositeAlpha", ParameterName::IndexVector{ swapchainIndex }), "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfos[swapchainIndex].compositeAlpha, true, true, VALIDATION_ERROR_14602e01);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].presentMode", ParameterName::IndexVector{ swapchainIndex }), "VkPresentModeKHR", AllVkPresentModeKHREnums, pCreateInfos[swapchainIndex].presentMode, VALIDATION_ERROR_14629601);
+
+ skipCall |= validate_bool32(layer_data->report_data, "vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].clipped", ParameterName::IndexVector{ swapchainIndex }), pCreateInfos[swapchainIndex].clipped);
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSharedSwapchainsKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSharedSwapchainsKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateSharedSwapchainsKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pSwapchains", swapchainCount, pSwapchains, true, true, VALIDATION_ERROR_2282f21b, VALIDATION_ERROR_22825801);
+
+ return skipCall;
+}
+
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+static bool parameter_validation_vkCreateXlibSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_1602b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_1601c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_16009005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXlibSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_23424801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ instance_layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+ UNUSED_PARAMETER(visualID);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceXlibPresentationSupportKHR", "dpy", dpy, VALIDATION_ERROR_2f606601);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+
+static bool parameter_validation_vkCreateXcbSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_15e2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_15e1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_15e09005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateXcbSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_23224801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ instance_layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+ UNUSED_PARAMETER(visual_id);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceXcbPresentationSupportKHR", "connection", connection, VALIDATION_ERROR_2f403001);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+
+static bool parameter_validation_vkCreateWaylandSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_1542b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_1541c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_15409005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWaylandSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_22e24801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ instance_layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ struct wl_display* display)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "display", display, VALIDATION_ERROR_2f006001);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+
+static bool parameter_validation_vkCreateMirSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateMirSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_0ca2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0ca1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0ca09005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMirSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMirSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMirSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMirSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_21624801);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ instance_layer_data* layer_data,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection)
+{
+ UNUSED_PARAMETER(queueFamilyIndex);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceMirPresentationSupportKHR", "connection", connection, VALIDATION_ERROR_2d203001);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+static bool parameter_validation_vkCreateAndroidSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_0042b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0041c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_00409005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateAndroidSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_1ea24801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkCreateWin32SurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_15a2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_15a1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_15a09005);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateWin32SurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_23024801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+
+static bool parameter_validation_vkCreateMagmaSurfaceKHR(
+ instance_layer_data* layer_data,
+ const VkMagmaSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_MAGMA_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_MAGMA_SURFACE_CREATE_INFO_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMagmaSurfaceKHR", "pSurface", pSurface, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceFeatures2KHR(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceFeatures2KHR* pFeatures)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceFeatures2KHR", "pFeatures", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR", pFeatures, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, true, VALIDATION_ERROR_0e42b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceProperties2KHR(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceProperties2KHR* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceProperties2KHR", "pProperties", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR", pProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, true, VALIDATION_ERROR_3402b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(
+ instance_layer_data* layer_data,
+ VkFormat format,
+ VkFormatProperties2KHR* pFormatProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceFormatProperties2KHR", "format", "VkFormat", AllVkFormatEnums, format, VALIDATION_ERROR_2c609201);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceFormatProperties2KHR", "pFormatProperties", "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR", pFormatProperties, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, true, VALIDATION_ERROR_3422b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
+ VkImageFormatProperties2KHR* pImageFormatProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR", pImageFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, true, VALIDATION_ERROR_0e62b00b);
+
+ if (pImageFormatInfo != NULL)
+ {
+ const VkStructureType allowed_structs_VkPhysicalDeviceImageFormatInfo2KHR[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->pNext", "VkPhysicalDeviceExternalImageFormatInfoKHR", pImageFormatInfo->pNext, ARRAY_SIZE(allowed_structs_VkPhysicalDeviceImageFormatInfo2KHR), allowed_structs_VkPhysicalDeviceImageFormatInfo2KHR, GeneratedHeaderVersion, VALIDATION_ERROR_0e61c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->format", "VkFormat", AllVkFormatEnums, pImageFormatInfo->format, VALIDATION_ERROR_0e609201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->type", "VkImageType", AllVkImageTypeEnums, pImageFormatInfo->type, VALIDATION_ERROR_0e630401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pImageFormatInfo->tiling, VALIDATION_ERROR_0e62fa01);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageFormatInfo->usage, true, false, VALIDATION_ERROR_0e630603);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageFormatInfo->flags, false, false, VALIDATION_ERROR_0e609001);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, true, VALIDATION_ERROR_3442b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ instance_layer_data* layer_data,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2KHR* pQueueFamilyProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkGetPhysicalDeviceQueueFamilyProperties2KHR", "pQueueFamilyPropertyCount", "pQueueFamilyProperties", "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR", pQueueFamilyPropertyCount, pQueueFamilyProperties, VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, true, false, false, VALIDATION_ERROR_2dc20001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(
+ instance_layer_data* layer_data,
+ VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceMemoryProperties2KHR", "pMemoryProperties", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR", pMemoryProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, true, VALIDATION_ERROR_3462b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2KHR* pProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR", pFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, true, VALIDATION_ERROR_0ec2b00b);
+
+ if (pFormatInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->pNext", NULL, pFormatInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0ec1c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->format", "VkFormat", AllVkFormatEnums, pFormatInfo->format, VALIDATION_ERROR_0ec09201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->type", "VkImageType", AllVkImageTypeEnums, pFormatInfo->type, VALIDATION_ERROR_0ec30401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pFormatInfo->samples, true, true, VALIDATION_ERROR_0ec2b401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pFormatInfo->usage, true, false, VALIDATION_ERROR_0ec30603);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pFormatInfo->tiling, VALIDATION_ERROR_0ec2fa01);
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pPropertyCount", "pProperties", "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR", pPropertyCount, pProperties, VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, true, false, false, VALIDATION_ERROR_2e01f401);
+
+ return skipCall;
+}
+
+
+
+
+
+static bool parameter_validation_vkTrimCommandPoolKHR(
+ layer_data* layer_data,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_maintenance1) skipCall |= OutputExtensionError(layer_data, "vkTrimCommandPoolKHR", VK_KHR_MAINTENANCE1_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkTrimCommandPoolKHR", "commandPool", commandPool);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkTrimCommandPoolKHR", "flags", flags, VALIDATION_ERROR_33409005);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
+ VkExternalBufferPropertiesKHR* pExternalBufferProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR", pExternalBufferInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, true, VALIDATION_ERROR_0dc2b00b);
+
+ if (pExternalBufferInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->pNext", NULL, pExternalBufferInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0dc1c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pExternalBufferInfo->flags, false, false, VALIDATION_ERROR_0dc09001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pExternalBufferInfo->usage, true, false, VALIDATION_ERROR_0dc30603);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, pExternalBufferInfo->handleType, true, true, VALIDATION_ERROR_0dc09c01);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferProperties", "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR", pExternalBufferProperties, VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, true, VALIDATION_ERROR_34c2b00b);
+
+ return skipCall;
+}
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkGetMemoryWin32HandleKHR(
+ layer_data* layer_data,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_win32) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleKHR", VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo", "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR", pGetWin32HandleInfo, VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, true, VALIDATION_ERROR_3b42b00b);
+
+ if (pGetWin32HandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->pNext", NULL, pGetWin32HandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3b41c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->memory", pGetWin32HandleInfo->memory);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, pGetWin32HandleInfo->handleType, true, true, VALIDATION_ERROR_3b409c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetMemoryWin32HandleKHR", "pHandle", pHandle, VALIDATION_ERROR_2ae17c01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetMemoryWin32HandlePropertiesKHR(
+ layer_data* layer_data,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+ UNUSED_PARAMETER(handle);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_win32) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryWin32HandlePropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, handleType, true, true, VALIDATION_ERROR_2b209c01);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryWin32HandlePropertiesKHR", "pMemoryWin32HandleProperties", "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", pMemoryWin32HandleProperties, VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkGetMemoryFdKHR(
+ layer_data* layer_data,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_fd) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdKHR", VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryFdKHR", "pGetFdInfo", "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR", pGetFdInfo, VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, true, VALIDATION_ERROR_3b22b00b);
+
+ if (pGetFdInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetMemoryFdKHR", "pGetFdInfo->pNext", NULL, pGetFdInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3b21c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetMemoryFdKHR", "pGetFdInfo->memory", pGetFdInfo->memory);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryFdKHR", "pGetFdInfo->handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, pGetFdInfo->handleType, true, true, VALIDATION_ERROR_3b209c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetMemoryFdKHR", "pFd", pFd, VALIDATION_ERROR_2aa16c01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetMemoryFdPropertiesKHR(
+ layer_data* layer_data,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+ UNUSED_PARAMETER(fd);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdPropertiesKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdPropertiesKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_fd) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFdPropertiesKHR", VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryFdPropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, handleType, true, true, VALIDATION_ERROR_2ac09c01);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryFdPropertiesKHR", "pMemoryFdProperties", "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", pMemoryFdProperties, VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
+ VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR", pExternalSemaphoreInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, true, VALIDATION_ERROR_0e02b00b);
+
+ if (pExternalSemaphoreInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo->pNext", NULL, pExternalSemaphoreInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0e01c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pExternalSemaphoreInfo->handleType, true, true, VALIDATION_ERROR_0e009c01);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreProperties", "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR", pExternalSemaphoreProperties, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, true, VALIDATION_ERROR_3522b00b);
+
+ return skipCall;
+}
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkImportSemaphoreWin32HandleKHR(
+ layer_data* layer_data,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_win32) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo", "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", pImportSemaphoreWin32HandleInfo, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, true, VALIDATION_ERROR_0b62b00b);
+
+ if (pImportSemaphoreWin32HandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->pNext", NULL, pImportSemaphoreWin32HandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0b61c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->semaphore", pImportSemaphoreWin32HandleInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->flags", "VkSemaphoreImportFlagBitsKHR", AllVkSemaphoreImportFlagBitsKHR, pImportSemaphoreWin32HandleInfo->flags, false, false, VALIDATION_ERROR_0b609001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pImportSemaphoreWin32HandleInfo->handleType, false, true, VALIDATION_ERROR_0b609c01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetSemaphoreWin32HandleKHR(
+ layer_data* layer_data,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_win32) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreWin32HandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR", pGetWin32HandleInfo, VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, true, VALIDATION_ERROR_3b02b00b);
+
+ if (pGetWin32HandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->pNext", NULL, pGetWin32HandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3b01c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->semaphore", pGetWin32HandleInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pGetWin32HandleInfo->handleType, true, true, VALIDATION_ERROR_3b009c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetSemaphoreWin32HandleKHR", "pHandle", pHandle, VALIDATION_ERROR_30417c01);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkImportSemaphoreFdKHR(
+ layer_data* layer_data,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_fd) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo", "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR", pImportSemaphoreFdInfo, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, true, VALIDATION_ERROR_0b42b00b);
+
+ if (pImportSemaphoreFdInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->pNext", NULL, pImportSemaphoreFdInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0b41c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->semaphore", pImportSemaphoreFdInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->flags", "VkSemaphoreImportFlagBitsKHR", AllVkSemaphoreImportFlagBitsKHR, pImportSemaphoreFdInfo->flags, false, false, VALIDATION_ERROR_0b409001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pImportSemaphoreFdInfo->handleType, true, true, VALIDATION_ERROR_0b409c01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetSemaphoreFdKHR(
+ layer_data* layer_data,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_fd) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFdKHR", VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetSemaphoreFdKHR", "pGetFdInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR", pGetFdInfo, VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, true, VALIDATION_ERROR_3ae2b00b);
+
+ if (pGetFdInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetSemaphoreFdKHR", "pGetFdInfo->pNext", NULL, pGetFdInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3ae1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSemaphoreFdKHR", "pGetFdInfo->semaphore", pGetFdInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetSemaphoreFdKHR", "pGetFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pGetFdInfo->handleType, true, true, VALIDATION_ERROR_3ae09c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetSemaphoreFdKHR", "pFd", pFd, VALIDATION_ERROR_30216c01);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkCmdPushDescriptorSetKHR(
+ layer_data* layer_data,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ UNUSED_PARAMETER(set);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_physical_device_properties_2) skipCall |= OutputExtensionError(layer_data, "vkCmdPushDescriptorSetKHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_push_descriptor) skipCall |= OutputExtensionError(layer_data, "vkCmdPushDescriptorSetKHR", VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdPushDescriptorSetKHR", "pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pipelineBindPoint, VALIDATION_ERROR_1be27e01);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPushDescriptorSetKHR", "layout", layout);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdPushDescriptorSetKHR", "descriptorWriteCount", "pDescriptorWrites", descriptorWriteCount, pDescriptorWrites, true, true, VALIDATION_ERROR_1be0541b, VALIDATION_ERROR_1be13601);
+
+ if (pDescriptorWrites != NULL)
+ {
+ for (uint32_t descriptorWriteIndex = 0; descriptorWriteIndex < descriptorWriteCount; ++descriptorWriteIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdPushDescriptorSetKHR", ParameterName("pDescriptorWrites[%i].pNext", ParameterName::IndexVector{ descriptorWriteIndex }), NULL, pDescriptorWrites[descriptorWriteIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_15c1c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdPushDescriptorSetKHR", ParameterName("pDescriptorWrites[%i].descriptorType", ParameterName::IndexVector{ descriptorWriteIndex }), "VkDescriptorType", AllVkDescriptorTypeEnums, pDescriptorWrites[descriptorWriteIndex].descriptorType, VALIDATION_ERROR_15c04e01);
+ }
+ }
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+static bool parameter_validation_vkCreateDescriptorUpdateTemplateKHR(
+ layer_data* layer_data,
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_descriptor_update_template) skipCall |= OutputExtensionError(layer_data, "vkCreateDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, true, VALIDATION_ERROR_0522b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0521c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_05209005);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo->descriptorUpdateEntryCount", "pCreateInfo->pDescriptorUpdateEntries", pCreateInfo->descriptorUpdateEntryCount, pCreateInfo->pDescriptorUpdateEntries, true, true, VALIDATION_ERROR_0520501b, VALIDATION_ERROR_05213201);
+
+ if (pCreateInfo->pDescriptorUpdateEntries != NULL)
+ {
+ for (uint32_t descriptorUpdateEntryIndex = 0; descriptorUpdateEntryIndex < pCreateInfo->descriptorUpdateEntryCount; ++descriptorUpdateEntryIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", ParameterName("pCreateInfo->pDescriptorUpdateEntries[%i].descriptorType", ParameterName::IndexVector{ descriptorUpdateEntryIndex }), "VkDescriptorType", AllVkDescriptorTypeEnums, pCreateInfo->pDescriptorUpdateEntries[descriptorUpdateEntryIndex].descriptorType, VALIDATION_ERROR_05404e01);
+ }
+ }
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo->templateType", "VkDescriptorUpdateTemplateTypeKHR", AllVkDescriptorUpdateTemplateTypeKHREnums, pCreateInfo->templateType, VALIDATION_ERROR_0522f801);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pCreateInfo->pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pipelineBindPoint, VALIDATION_ERROR_05227e01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", "pDescriptorUpdateTemplate", pDescriptorUpdateTemplate, VALIDATION_ERROR_1fa13401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(
+ layer_data* layer_data,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ UNUSED_PARAMETER(descriptorUpdateTemplate);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_descriptor_update_template) skipCall |= OutputExtensionError(layer_data, "vkDestroyDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorUpdateTemplateKHR", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorUpdateTemplateKHR", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDescriptorUpdateTemplateKHR", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(
+ layer_data* layer_data,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const void* pData)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_descriptor_update_template) skipCall |= OutputExtensionError(layer_data, "vkUpdateDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUpdateDescriptorSetWithTemplateKHR", "descriptorSet", descriptorSet);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUpdateDescriptorSetWithTemplateKHR", "descriptorUpdateTemplate", descriptorUpdateTemplate);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkUpdateDescriptorSetWithTemplateKHR", "pData", pData, VALIDATION_ERROR_33a12201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(
+ layer_data* layer_data,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData)
+{
+ UNUSED_PARAMETER(set);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_descriptor_update_template) skipCall |= OutputExtensionError(layer_data, "vkCmdPushDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPushDescriptorSetWithTemplateKHR", "descriptorUpdateTemplate", descriptorUpdateTemplate);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdPushDescriptorSetWithTemplateKHR", "layout", layout);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdPushDescriptorSetWithTemplateKHR", "pData", pData, VALIDATION_ERROR_1c012201);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetSwapchainStatusKHR(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_surface_capabilities_2) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainStatusKHR", VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_get_physical_device_properties_2) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainStatusKHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainStatusKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_surface) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainStatusKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_shared_presentable_image) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainStatusKHR", VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSwapchainStatusKHR", "swapchain", swapchain);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
+ VkExternalFencePropertiesKHR* pExternalFenceProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR", pExternalFenceInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, true, VALIDATION_ERROR_3962b00b);
+
+ if (pExternalFenceInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo->pNext", NULL, pExternalFenceInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3961c40d);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo->handleType", "VkExternalFenceHandleTypeFlagBitsKHR", AllVkExternalFenceHandleTypeFlagBitsKHR, pExternalFenceInfo->handleType, true, true, VALIDATION_ERROR_39609c01);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceProperties", "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR", pExternalFenceProperties, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, true, VALIDATION_ERROR_3982b00b);
+
+ return skipCall;
+}
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkImportFenceWin32HandleKHR(
+ layer_data* layer_data,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_fence) skipCall |= OutputExtensionError(layer_data, "vkImportFenceWin32HandleKHR", VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_fence_win32) skipCall |= OutputExtensionError(layer_data, "vkImportFenceWin32HandleKHR", VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo", "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR", pImportFenceWin32HandleInfo, VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, true, VALIDATION_ERROR_3a42b00b);
+
+ if (pImportFenceWin32HandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->pNext", NULL, pImportFenceWin32HandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3a41c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->fence", pImportFenceWin32HandleInfo->fence);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->flags", "VkFenceImportFlagBitsKHR", AllVkFenceImportFlagBitsKHR, pImportFenceWin32HandleInfo->flags, false, false, VALIDATION_ERROR_3a409001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBitsKHR", AllVkExternalFenceHandleTypeFlagBitsKHR, pImportFenceWin32HandleInfo->handleType, false, true, VALIDATION_ERROR_3a409c01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetFenceWin32HandleKHR(
+ layer_data* layer_data,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_fence) skipCall |= OutputExtensionError(layer_data, "vkGetFenceWin32HandleKHR", VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_fence_win32) skipCall |= OutputExtensionError(layer_data, "vkGetFenceWin32HandleKHR", VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo", "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR", pGetWin32HandleInfo, VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, true, VALIDATION_ERROR_3a82b00b);
+
+ if (pGetWin32HandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->pNext", NULL, pGetWin32HandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3a81c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->fence", pGetWin32HandleInfo->fence);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBitsKHR", AllVkExternalFenceHandleTypeFlagBitsKHR, pGetWin32HandleInfo->handleType, true, true, VALIDATION_ERROR_3a809c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetFenceWin32HandleKHR", "pHandle", pHandle, VALIDATION_ERROR_3ac17c01);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkImportFenceFdKHR(
+ layer_data* layer_data,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_fence) skipCall |= OutputExtensionError(layer_data, "vkImportFenceFdKHR", VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_fence_fd) skipCall |= OutputExtensionError(layer_data, "vkImportFenceFdKHR", VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkImportFenceFdKHR", "pImportFenceFdInfo", "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR", pImportFenceFdInfo, VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, true, VALIDATION_ERROR_39c2b00b);
+
+ if (pImportFenceFdInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkImportFenceFdKHR", "pImportFenceFdInfo->pNext", NULL, pImportFenceFdInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_39c1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkImportFenceFdKHR", "pImportFenceFdInfo->fence", pImportFenceFdInfo->fence);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportFenceFdKHR", "pImportFenceFdInfo->flags", "VkFenceImportFlagBitsKHR", AllVkFenceImportFlagBitsKHR, pImportFenceFdInfo->flags, false, false, VALIDATION_ERROR_39c09001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportFenceFdKHR", "pImportFenceFdInfo->handleType", "VkExternalFenceHandleTypeFlagBitsKHR", AllVkExternalFenceHandleTypeFlagBitsKHR, pImportFenceFdInfo->handleType, true, true, VALIDATION_ERROR_39c09c01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetFenceFdKHR(
+ layer_data* layer_data,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_fence) skipCall |= OutputExtensionError(layer_data, "vkGetFenceFdKHR", VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_fence_fd) skipCall |= OutputExtensionError(layer_data, "vkGetFenceFdKHR", VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetFenceFdKHR", "pGetFdInfo", "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR", pGetFdInfo, VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, true, VALIDATION_ERROR_39e2b00b);
+
+ if (pGetFdInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetFenceFdKHR", "pGetFdInfo->pNext", NULL, pGetFdInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_39e1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetFenceFdKHR", "pGetFdInfo->fence", pGetFdInfo->fence);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetFenceFdKHR", "pGetFdInfo->handleType", "VkExternalFenceHandleTypeFlagBitsKHR", AllVkExternalFenceHandleTypeFlagBitsKHR, pGetFdInfo->handleType, true, true, VALIDATION_ERROR_39e09c01);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetFenceFdKHR", "pFd", pFd, VALIDATION_ERROR_3a216c01);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "pSurfaceInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", pSurfaceInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, true, VALIDATION_ERROR_0ee2b00b);
+
+ if (pSurfaceInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "pSurfaceInfo->pNext", NULL, pSurfaceInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0ee1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "pSurfaceInfo->surface", pSurfaceInfo->surface);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "pSurfaceCapabilities", "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR", pSurfaceCapabilities, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, true, VALIDATION_ERROR_3482b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ instance_layer_data* layer_data,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormats2KHR", "pSurfaceInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", pSurfaceInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, true, VALIDATION_ERROR_0ee2b00b);
+
+ if (pSurfaceInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormats2KHR", "pSurfaceInfo->pNext", NULL, pSurfaceInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0ee1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormats2KHR", "pSurfaceInfo->surface", pSurfaceInfo->surface);
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkGetPhysicalDeviceSurfaceFormats2KHR", "pSurfaceFormatCount", "pSurfaceFormats", "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", pSurfaceFormatCount, pSurfaceFormats, VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, true, false, false, VALIDATION_ERROR_2e824e01);
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+
+
+
+
+static bool parameter_validation_vkGetImageMemoryRequirements2KHR(
+ layer_data* layer_data,
+ const VkImageMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_memory_requirements_2) skipCall |= OutputExtensionError(layer_data, "vkGetImageMemoryRequirements2KHR", VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetImageMemoryRequirements2KHR", "pInfo", "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR", pInfo, VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, true, VALIDATION_ERROR_3bc2b00b);
+
+ if (pInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetImageMemoryRequirements2KHR", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3bc1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetImageMemoryRequirements2KHR", "pInfo->image", pInfo->image);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetImageMemoryRequirements2KHR", "pMemoryRequirements", "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR", pMemoryRequirements, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, true, VALIDATION_ERROR_3c02b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetBufferMemoryRequirements2KHR(
+ layer_data* layer_data,
+ const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_memory_requirements_2) skipCall |= OutputExtensionError(layer_data, "vkGetBufferMemoryRequirements2KHR", VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetBufferMemoryRequirements2KHR", "pInfo", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR", pInfo, VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, true, VALIDATION_ERROR_3ba2b00b);
+
+ if (pInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetBufferMemoryRequirements2KHR", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_3ba1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetBufferMemoryRequirements2KHR", "pInfo->buffer", pInfo->buffer);
+ }
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetBufferMemoryRequirements2KHR", "pMemoryRequirements", "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR", pMemoryRequirements, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, true, VALIDATION_ERROR_3c02b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetImageSparseMemoryRequirements2KHR(
+ layer_data* layer_data,
+ const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_memory_requirements_2) skipCall |= OutputExtensionError(layer_data, "vkGetImageSparseMemoryRequirements2KHR", VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetImageSparseMemoryRequirements2KHR", "pInfo", "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR", pInfo, VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ if (pInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetImageSparseMemoryRequirements2KHR", "pInfo->pNext", NULL, pInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetImageSparseMemoryRequirements2KHR", "pInfo->image", pInfo->image);
+ }
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkGetImageSparseMemoryRequirements2KHR", "pSparseMemoryRequirementCount", "pSparseMemoryRequirements", "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR", pSparseMemoryRequirementCount, pSparseMemoryRequirements, VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, true, false, false, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetMemoryFuchsiaHandleKHR(
+ layer_data* layer_data,
+ const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandleKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandleKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_fuchsia) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandleKHR", VK_KHR_EXTERNAL_MEMORY_FUCHSIA_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryFuchsiaHandleKHR", "pGetFuchsiaHandleInfo", "VK_STRUCTURE_TYPE_MEMORY_GET_FUCHSIA_HANDLE_INFO_KHR", pGetFuchsiaHandleInfo, VK_STRUCTURE_TYPE_MEMORY_GET_FUCHSIA_HANDLE_INFO_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ if (pGetFuchsiaHandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetMemoryFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->pNext", NULL, pGetFuchsiaHandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetMemoryFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->memory", pGetFuchsiaHandleInfo->memory);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, pGetFuchsiaHandleInfo->handleType, true, true, VALIDATION_ERROR_UNDEFINED);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetMemoryFuchsiaHandleKHR", "pFuchsiaHandle", pFuchsiaHandle, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetMemoryFuchsiaHandlePropertiesKHR(
+ layer_data* layer_data,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ uint32_t fuchsiaHandle,
+ VkMemoryFuchsiaHandlePropertiesKHR* pMemoryFuchsiaHandleProperties)
+{
+ UNUSED_PARAMETER(fuchsiaHandle);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_memory_fuchsia) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryFuchsiaHandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_FUCHSIA_EXTENSION_NAME);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryFuchsiaHandlePropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBitsKHR", AllVkExternalMemoryHandleTypeFlagBitsKHR, handleType, true, true, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetMemoryFuchsiaHandlePropertiesKHR", "pMemoryFuchsiaHandleProperties", "VK_STRUCTURE_TYPE_MEMORY_FUCHSIA_HANDLE_PROPERTIES_KHR", pMemoryFuchsiaHandleProperties, VK_STRUCTURE_TYPE_MEMORY_FUCHSIA_HANDLE_PROPERTIES_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkImportSemaphoreFuchsiaHandleKHR(
+ layer_data* layer_data,
+ const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_fuchsia) skipCall |= OutputExtensionError(layer_data, "vkImportSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_FUCHSIA_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkImportSemaphoreFuchsiaHandleKHR", "pImportSemaphoreFuchsiaHandleInfo", "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FUCHSIA_HANDLE_INFO_KHR", pImportSemaphoreFuchsiaHandleInfo, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FUCHSIA_HANDLE_INFO_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ if (pImportSemaphoreFuchsiaHandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkImportSemaphoreFuchsiaHandleKHR", "pImportSemaphoreFuchsiaHandleInfo->pNext", NULL, pImportSemaphoreFuchsiaHandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkImportSemaphoreFuchsiaHandleKHR", "pImportSemaphoreFuchsiaHandleInfo->semaphore", pImportSemaphoreFuchsiaHandleInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreFuchsiaHandleKHR", "pImportSemaphoreFuchsiaHandleInfo->flags", "VkSemaphoreImportFlagBitsKHR", AllVkSemaphoreImportFlagBitsKHR, pImportSemaphoreFuchsiaHandleInfo->flags, false, false, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkImportSemaphoreFuchsiaHandleKHR", "pImportSemaphoreFuchsiaHandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pImportSemaphoreFuchsiaHandleInfo->handleType, true, true, VALIDATION_ERROR_UNDEFINED);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetSemaphoreFuchsiaHandleKHR(
+ layer_data* layer_data,
+ const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_external_semaphore) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_external_semaphore_fuchsia) skipCall |= OutputExtensionError(layer_data, "vkGetSemaphoreFuchsiaHandleKHR", VK_KHR_EXTERNAL_SEMAPHORE_FUCHSIA_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetSemaphoreFuchsiaHandleKHR", "pGetFuchsiaHandleInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FUCHSIA_HANDLE_INFO_KHR", pGetFuchsiaHandleInfo, VK_STRUCTURE_TYPE_SEMAPHORE_GET_FUCHSIA_HANDLE_INFO_KHR, true, VALIDATION_ERROR_UNDEFINED);
+
+ if (pGetFuchsiaHandleInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkGetSemaphoreFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->pNext", NULL, pGetFuchsiaHandleInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSemaphoreFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->semaphore", pGetFuchsiaHandleInfo->semaphore);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetSemaphoreFuchsiaHandleKHR", "pGetFuchsiaHandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBitsKHR", AllVkExternalSemaphoreHandleTypeFlagBitsKHR, pGetFuchsiaHandleInfo->handleType, true, true, VALIDATION_ERROR_UNDEFINED);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetSemaphoreFuchsiaHandleKHR", "pFuchsiaHandle", pFuchsiaHandle, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkDestroyDebugReportCallbackEXT(
+ instance_layer_data* layer_data,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkDestroyDebugReportCallbackEXT", "callback", callback);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDebugReportCallbackEXT", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDebugReportCallbackEXT", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyDebugReportCallbackEXT", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static bool parameter_validation_vkDebugMarkerSetObjectTagEXT(
+ layer_data* layer_data,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_debug_report) skipCall |= OutputExtensionError(layer_data, "vkDebugMarkerSetObjectTagEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_debug_marker) skipCall |= OutputExtensionError(layer_data, "vkDebugMarkerSetObjectTagEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkDebugMarkerSetObjectTagEXT", "pTagInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", pTagInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, true, VALIDATION_ERROR_03a2b00b);
+
+ if (pTagInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkDebugMarkerSetObjectTagEXT", "pTagInfo->pNext", NULL, pTagInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_03a1c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkDebugMarkerSetObjectTagEXT", "pTagInfo->objectType", "VkDebugReportObjectTypeEXT", AllVkDebugReportObjectTypeEXTEnums, pTagInfo->objectType, VALIDATION_ERROR_03a0da01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkDebugMarkerSetObjectTagEXT", "pTagInfo->tagSize", "pTagInfo->pTag", pTagInfo->tagSize, pTagInfo->pTag, true, true, VALIDATION_ERROR_03a2f41b, VALIDATION_ERROR_03a25a01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDebugMarkerSetObjectNameEXT(
+ layer_data* layer_data,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_debug_report) skipCall |= OutputExtensionError(layer_data, "vkDebugMarkerSetObjectNameEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_debug_marker) skipCall |= OutputExtensionError(layer_data, "vkDebugMarkerSetObjectNameEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkDebugMarkerSetObjectNameEXT", "pNameInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", pNameInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, true, VALIDATION_ERROR_0382b00b);
+
+ if (pNameInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkDebugMarkerSetObjectNameEXT", "pNameInfo->pNext", NULL, pNameInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0381c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkDebugMarkerSetObjectNameEXT", "pNameInfo->objectType", "VkDebugReportObjectTypeEXT", AllVkDebugReportObjectTypeEXTEnums, pNameInfo->objectType, VALIDATION_ERROR_0380da01);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDebugMarkerSetObjectNameEXT", "pNameInfo->pObjectName", pNameInfo->pObjectName, VALIDATION_ERROR_0381ce01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDebugMarkerBeginEXT(
+ layer_data* layer_data,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_debug_report) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerBeginEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_debug_marker) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerBeginEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCmdDebugMarkerBeginEXT", "pMarkerInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", pMarkerInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, true, VALIDATION_ERROR_0362b00b);
+
+ if (pMarkerInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdDebugMarkerBeginEXT", "pMarkerInfo->pNext", NULL, pMarkerInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0361c40d);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdDebugMarkerBeginEXT", "pMarkerInfo->pMarkerName", pMarkerInfo->pMarkerName, VALIDATION_ERROR_0361a801);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDebugMarkerEndEXT(
+ layer_data* layer_data)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_debug_report) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerEndEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_debug_marker) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerEndEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDebugMarkerInsertEXT(
+ layer_data* layer_data,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_debug_report) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerInsertEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_debug_marker) skipCall |= OutputExtensionError(layer_data, "vkCmdDebugMarkerInsertEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCmdDebugMarkerInsertEXT", "pMarkerInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", pMarkerInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, true, VALIDATION_ERROR_0362b00b);
+
+ if (pMarkerInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdDebugMarkerInsertEXT", "pMarkerInfo->pNext", NULL, pMarkerInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0361c40d);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCmdDebugMarkerInsertEXT", "pMarkerInfo->pMarkerName", pMarkerInfo->pMarkerName, VALIDATION_ERROR_0361a801);
+ }
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+static bool parameter_validation_vkCmdDrawIndirectCountAMD(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ UNUSED_PARAMETER(offset);
+ UNUSED_PARAMETER(countBufferOffset);
+ UNUSED_PARAMETER(maxDrawCount);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_amd_draw_indirect_count) skipCall |= OutputExtensionError(layer_data, "vkCmdDrawIndirectCountAMD", VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndirectCountAMD", "buffer", buffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndirectCountAMD", "countBuffer", countBuffer);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDrawIndexedIndirectCountAMD(
+ layer_data* layer_data,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ UNUSED_PARAMETER(offset);
+ UNUSED_PARAMETER(countBufferOffset);
+ UNUSED_PARAMETER(maxDrawCount);
+ UNUSED_PARAMETER(stride);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_amd_draw_indirect_count) skipCall |= OutputExtensionError(layer_data, "vkCmdDrawIndexedIndirectCountAMD", VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndexedIndirectCountAMD", "buffer", buffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdDrawIndexedIndirectCountAMD", "countBuffer", countBuffer);
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static bool parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ instance_layer_data* layer_data,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "format", "VkFormat", AllVkFormatEnums, format, VALIDATION_ERROR_2bc09201);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "type", "VkImageType", AllVkImageTypeEnums, type, VALIDATION_ERROR_2bc30401);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, VALIDATION_ERROR_2bc2fa01);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, VALIDATION_ERROR_2bc30603);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false, false, VALIDATION_ERROR_2bc09001);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "externalHandleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, externalHandleType, false, false, VALIDATION_ERROR_2bc08201);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "pExternalImageFormatProperties", pExternalImageFormatProperties, VALIDATION_ERROR_2bc16601);
+
+ return skipCall;
+}
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkGetMemoryWin32HandleNV(
+ layer_data* layer_data,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nv_external_memory) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_nv_external_memory_capabilities) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_nv_external_memory_win32) skipCall |= OutputExtensionError(layer_data, "vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetMemoryWin32HandleNV", "memory", memory);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetMemoryWin32HandleNV", "handleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, handleType, true, false, VALIDATION_ERROR_2b009c03);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetMemoryWin32HandleNV", "pHandle", pHandle, VALIDATION_ERROR_2b017c01);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+static bool parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(
+ layer_data* layer_data,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures)
+{
+ UNUSED_PARAMETER(heapIndex);
+ UNUSED_PARAMETER(localDeviceIndex);
+ UNUSED_PARAMETER(remoteDeviceIndex);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPeerMemoryFeaturesKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPeerMemoryFeaturesKHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPeerMemoryFeaturesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetDeviceGroupPeerMemoryFeaturesKHX", "pPeerMemoryFeatures", pPeerMemoryFeatures, VALIDATION_ERROR_28c1d401);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkBindBufferMemory2KHX(
+ layer_data* layer_data,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfoKHX* pBindInfos)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkBindBufferMemory2KHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkBindBufferMemory2KHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkBindBufferMemory2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkBindBufferMemory2KHX", "bindInfoCount", "pBindInfos", "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX", bindInfoCount, pBindInfos, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX, true, true, VALIDATION_ERROR_1720fa01);
+
+ if (pBindInfos != NULL)
+ {
+ for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkBindBufferMemory2KHX", ParameterName("pBindInfos[%i].pNext", ParameterName::IndexVector{ bindInfoIndex }), NULL, pBindInfos[bindInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_00c1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindBufferMemory2KHX", ParameterName("pBindInfos[%i].buffer", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].buffer);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindBufferMemory2KHX", ParameterName("pBindInfos[%i].memory", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].memory);
+
+ skipCall |= validate_array(layer_data->report_data, "vkBindBufferMemory2KHX", ParameterName("pBindInfos[%i].deviceIndexCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfos[%i].pDeviceIndices", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].deviceIndexCount, pBindInfos[bindInfoIndex].pDeviceIndices, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_00c13e01);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkBindImageMemory2KHX(
+ layer_data* layer_data,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfoKHX* pBindInfos)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkBindImageMemory2KHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkBindImageMemory2KHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkBindImageMemory2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkBindImageMemory2KHX", "bindInfoCount", "pBindInfos", "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX", bindInfoCount, pBindInfos, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX, true, true, VALIDATION_ERROR_1760fa01);
+
+ if (pBindInfos != NULL)
+ {
+ for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex)
+ {
+ const VkStructureType allowed_structs_VkBindImageMemoryInfoKHX[] = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX };
+
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkBindImageMemory2KHX", ParameterName("pBindInfos[%i].pNext", ParameterName::IndexVector{ bindInfoIndex }), "VkBindImageMemorySwapchainInfoKHX", pBindInfos[bindInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkBindImageMemoryInfoKHX), allowed_structs_VkBindImageMemoryInfoKHX, GeneratedHeaderVersion, VALIDATION_ERROR_00e1c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindImageMemory2KHX", ParameterName("pBindInfos[%i].image", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].image);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkBindImageMemory2KHX", ParameterName("pBindInfos[%i].memory", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].memory);
+
+ skipCall |= validate_array(layer_data->report_data, "vkBindImageMemory2KHX", ParameterName("pBindInfos[%i].deviceIndexCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfos[%i].pDeviceIndices", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].deviceIndexCount, pBindInfos[bindInfoIndex].pDeviceIndices, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_00e13e01);
+
+ skipCall |= validate_array(layer_data->report_data, "vkBindImageMemory2KHX", ParameterName("pBindInfos[%i].SFRRectCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfos[%i].pSFRRects", ParameterName::IndexVector{ bindInfoIndex }), pBindInfos[bindInfoIndex].SFRRectCount, pBindInfos[bindInfoIndex].pSFRRects, false, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_00e22001);
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdSetDeviceMaskKHX(
+ layer_data* layer_data,
+ uint32_t deviceMask)
+{
+ UNUSED_PARAMETER(deviceMask);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkCmdSetDeviceMaskKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkCmdSetDeviceMaskKHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkCmdSetDeviceMaskKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(
+ layer_data* layer_data,
+ VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPresentCapabilitiesKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPresentCapabilitiesKHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupPresentCapabilitiesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetDeviceGroupPresentCapabilitiesKHX", "pDeviceGroupPresentCapabilities", "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX", pDeviceGroupPresentCapabilities, VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX, true, VALIDATION_ERROR_34a2b00b);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(
+ layer_data* layer_data,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupSurfacePresentModesKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupSurfacePresentModesKHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkGetDeviceGroupSurfacePresentModesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", "surface", surface);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", "pModes", pModes, VALIDATION_ERROR_2901be01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkAcquireNextImage2KHX(
+ layer_data* layer_data,
+ const VkAcquireNextImageInfoKHX* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkAcquireNextImage2KHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkAcquireNextImage2KHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkAcquireNextImage2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkAcquireNextImage2KHX", "pAcquireInfo", "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX", pAcquireInfo, VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX, true, VALIDATION_ERROR_0002b00b);
+
+ if (pAcquireInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkAcquireNextImage2KHX", "pAcquireInfo->pNext", NULL, pAcquireInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0001c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkAcquireNextImage2KHX", "pAcquireInfo->swapchain", pAcquireInfo->swapchain);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAcquireNextImage2KHX", "pImageIndex", pImageIndex, VALIDATION_ERROR_16218601);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdDispatchBaseKHX(
+ layer_data* layer_data,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ UNUSED_PARAMETER(baseGroupX);
+ UNUSED_PARAMETER(baseGroupY);
+ UNUSED_PARAMETER(baseGroupZ);
+ UNUSED_PARAMETER(groupCountX);
+ UNUSED_PARAMETER(groupCountY);
+ UNUSED_PARAMETER(groupCountZ);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khx_device_group_creation) skipCall |= OutputExtensionError(layer_data, "vkCmdDispatchBaseKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkCmdDispatchBaseKHX", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khx_device_group) skipCall |= OutputExtensionError(layer_data, "vkCmdDispatchBaseKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", "surface", surface);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", "pRectCount", "pRects", pRectCount, pRects, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2d420e01);
+
+ return skipCall;
+}
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_VI_NN
+
+static bool parameter_validation_vkCreateViSurfaceNN(
+ instance_layer_data* layer_data,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateViSurfaceNN", "pCreateInfo", "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN", pCreateInfo, VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, true, VALIDATION_ERROR_14e2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateViSurfaceNN", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_14e1c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateViSurfaceNN", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_14e09005);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateViSurfaceNN", "pCreateInfo->window", pCreateInfo->window, VALIDATION_ERROR_14e30e01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateViSurfaceNN", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateViSurfaceNN", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateViSurfaceNN", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateViSurfaceNN", "pSurface", pSurface, VALIDATION_ERROR_22c24801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_VI_NN
+
+
+
+
+
+static bool parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(
+ instance_layer_data* layer_data,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkEnumeratePhysicalDeviceGroupsKHX", "pPhysicalDeviceGroupCount", "pPhysicalDeviceGroupProperties", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX", pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX, true, false, false, VALIDATION_ERROR_27e1da01);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkCmdProcessCommandsNVX(
+ layer_data* layer_data,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkCmdProcessCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCmdProcessCommandsNVX", "pProcessCommandsInfo", "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX", pProcessCommandsInfo, VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX, true, VALIDATION_ERROR_0222b00b);
+
+ if (pProcessCommandsInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdProcessCommandsNVX", "pProcessCommandsInfo->pNext", NULL, pProcessCommandsInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0221c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdProcessCommandsNVX", "pProcessCommandsInfo->objectTable", pProcessCommandsInfo->objectTable);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdProcessCommandsNVX", "pProcessCommandsInfo->indirectCommandsLayout", pProcessCommandsInfo->indirectCommandsLayout);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdProcessCommandsNVX", "pProcessCommandsInfo->indirectCommandsTokenCount", "pProcessCommandsInfo->pIndirectCommandsTokens", pProcessCommandsInfo->indirectCommandsTokenCount, pProcessCommandsInfo->pIndirectCommandsTokens, true, true, VALIDATION_ERROR_0220b61b, VALIDATION_ERROR_02219401);
+
+ if (pProcessCommandsInfo->pIndirectCommandsTokens != NULL)
+ {
+ for (uint32_t indirectCommandsTokenIndex = 0; indirectCommandsTokenIndex < pProcessCommandsInfo->indirectCommandsTokenCount; ++indirectCommandsTokenIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCmdProcessCommandsNVX", ParameterName("pProcessCommandsInfo->pIndirectCommandsTokens[%i].tokenType", ParameterName::IndexVector{ indirectCommandsTokenIndex }), "VkIndirectCommandsTokenTypeNVX", AllVkIndirectCommandsTokenTypeNVXEnums, pProcessCommandsInfo->pIndirectCommandsTokens[indirectCommandsTokenIndex].tokenType, VALIDATION_ERROR_0bc2fe01);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdProcessCommandsNVX", ParameterName("pProcessCommandsInfo->pIndirectCommandsTokens[%i].buffer", ParameterName::IndexVector{ indirectCommandsTokenIndex }), pProcessCommandsInfo->pIndirectCommandsTokens[indirectCommandsTokenIndex].buffer);
+ }
+ }
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCmdReserveSpaceForCommandsNVX(
+ layer_data* layer_data,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkCmdReserveSpaceForCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCmdReserveSpaceForCommandsNVX", "pReserveSpaceInfo", "VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX", pReserveSpaceInfo, VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, true, VALIDATION_ERROR_0242b00b);
+
+ if (pReserveSpaceInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCmdReserveSpaceForCommandsNVX", "pReserveSpaceInfo->pNext", NULL, pReserveSpaceInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0241c40d);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdReserveSpaceForCommandsNVX", "pReserveSpaceInfo->objectTable", pReserveSpaceInfo->objectTable);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkCmdReserveSpaceForCommandsNVX", "pReserveSpaceInfo->indirectCommandsLayout", pReserveSpaceInfo->indirectCommandsLayout);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateIndirectCommandsLayoutNVX(
+ layer_data* layer_data,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkCreateIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pCreateInfo", "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX", pCreateInfo, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, true, VALIDATION_ERROR_0b82b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0b81c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pipelineBindPoint, VALIDATION_ERROR_0b827e01);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->flags", "VkIndirectCommandsLayoutUsageFlagBitsNVX", AllVkIndirectCommandsLayoutUsageFlagBitsNVX, pCreateInfo->flags, true, false, VALIDATION_ERROR_0b809003);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->tokenCount", "pCreateInfo->pTokens", pCreateInfo->tokenCount, pCreateInfo->pTokens, true, true, VALIDATION_ERROR_0b82fc1b, VALIDATION_ERROR_0b826001);
+
+ if (pCreateInfo->pTokens != NULL)
+ {
+ for (uint32_t tokenIndex = 0; tokenIndex < pCreateInfo->tokenCount; ++tokenIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", ParameterName("pCreateInfo->pTokens[%i].tokenType", ParameterName::IndexVector{ tokenIndex }), "VkIndirectCommandsTokenTypeNVX", AllVkIndirectCommandsTokenTypeNVXEnums, pCreateInfo->pTokens[tokenIndex].tokenType, VALIDATION_ERROR_0ba2fe01);
+ }
+ }
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIndirectCommandsLayoutNVX", "pIndirectCommandsLayout", pIndirectCommandsLayout, VALIDATION_ERROR_21019201);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyIndirectCommandsLayoutNVX(
+ layer_data* layer_data,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkDestroyIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkDestroyIndirectCommandsLayoutNVX", "indirectCommandsLayout", indirectCommandsLayout);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyIndirectCommandsLayoutNVX", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyIndirectCommandsLayoutNVX", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyIndirectCommandsLayoutNVX", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkCreateObjectTableNVX(
+ layer_data* layer_data,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkCreateObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateObjectTableNVX", "pCreateInfo", "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX", pCreateInfo, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, true, VALIDATION_ERROR_0cc2b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateObjectTableNVX", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0cc1c40d);
+
+ skipCall |= validate_ranged_enum_array(layer_data->report_data, "vkCreateObjectTableNVX", "pCreateInfo->objectCount", "pCreateInfo->pObjectEntryTypes", "VkObjectEntryTypeNVX", AllVkObjectEntryTypeNVXEnums, pCreateInfo->objectCount, pCreateInfo->pObjectEntryTypes, true, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCreateObjectTableNVX", "pCreateInfo->objectCount", "pCreateInfo->pObjectEntryCounts", pCreateInfo->objectCount, pCreateInfo->pObjectEntryCounts, true, true, VALIDATION_ERROR_0cc0d61b, VALIDATION_ERROR_0cc1c601);
+
+ skipCall |= validate_flags_array(layer_data->report_data, "vkCreateObjectTableNVX", "pCreateInfo->objectCount", "pCreateInfo->pObjectEntryUsageFlags", "VkObjectEntryUsageFlagBitsNVX", AllVkObjectEntryUsageFlagBitsNVX, pCreateInfo->objectCount, pCreateInfo->pObjectEntryUsageFlags, true, true);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateObjectTableNVX", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateObjectTableNVX", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateObjectTableNVX", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateObjectTableNVX", "pObjectTable", pObjectTable, VALIDATION_ERROR_2181d001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkDestroyObjectTableNVX(
+ layer_data* layer_data,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkDestroyObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkDestroyObjectTableNVX", "objectTable", objectTable);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyObjectTableNVX", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyObjectTableNVX", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkDestroyObjectTableNVX", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkRegisterObjectsNVX(
+ layer_data* layer_data,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkRegisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkRegisterObjectsNVX", "objectTable", objectTable);
+
+ skipCall |= validate_array(layer_data->report_data, "vkRegisterObjectsNVX", "objectCount", "ppObjectTableEntries", objectCount, ppObjectTableEntries, true, true, VALIDATION_ERROR_3220d61b, VALIDATION_ERROR_32229201);
+
+ if (ppObjectTableEntries != NULL)
+ {
+ for (uint32_t objectIndex = 0; objectIndex < objectCount; ++objectIndex)
+ {
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkRegisterObjectsNVX", ParameterName("ppObjectTableEntries[%i]->type", ParameterName::IndexVector{ objectIndex }), "VkObjectEntryTypeNVX", AllVkObjectEntryTypeNVXEnums, ppObjectTableEntries[objectIndex]->type, VALIDATION_ERROR_0d030401);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkRegisterObjectsNVX", ParameterName("ppObjectTableEntries[%i]->flags", ParameterName::IndexVector{ objectIndex }), "VkObjectEntryUsageFlagBitsNVX", AllVkObjectEntryUsageFlagBitsNVX, ppObjectTableEntries[objectIndex]->flags, true, false, VALIDATION_ERROR_0d009003);
+ }
+ }
+
+ skipCall |= validate_array(layer_data->report_data, "vkRegisterObjectsNVX", "objectCount", "pObjectIndices", objectCount, pObjectIndices, true, true, VALIDATION_ERROR_3220d61b, VALIDATION_ERROR_3221cc01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkUnregisterObjectsNVX(
+ layer_data* layer_data,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nvx_device_generated_commands) skipCall |= OutputExtensionError(layer_data, "vkUnregisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkUnregisterObjectsNVX", "objectTable", objectTable);
+
+ skipCall |= validate_ranged_enum_array(layer_data->report_data, "vkUnregisterObjectsNVX", "objectCount", "pObjectEntryTypes", "VkObjectEntryTypeNVX", AllVkObjectEntryTypeNVXEnums, objectCount, pObjectEntryTypes, true, true);
+
+ skipCall |= validate_array(layer_data->report_data, "vkUnregisterObjectsNVX", "objectCount", "pObjectIndices", objectCount, pObjectIndices, true, true, VALIDATION_ERROR_3380d61b, VALIDATION_ERROR_3381cc01);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ instance_layer_data* layer_data,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", "pFeatures", "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX", pFeatures, VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX, true, VALIDATION_ERROR_05a2b00b);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", "pLimits", "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX", pLimits, VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX, true, VALIDATION_ERROR_05c2b00b);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkCmdSetViewportWScalingNV(
+ layer_data* layer_data,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings)
+{
+ UNUSED_PARAMETER(firstViewport);
+ UNUSED_PARAMETER(pViewportWScalings);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_nv_clip_space_w_scaling) skipCall |= OutputExtensionError(layer_data, "vkCmdSetViewportWScalingNV", VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkReleaseDisplayEXT(
+ instance_layer_data* layer_data,
+ VkDisplayKHR display)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkReleaseDisplayEXT", "display", display);
+
+ return skipCall;
+}
+
+
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+static bool parameter_validation_vkAcquireXlibDisplayEXT(
+ instance_layer_data* layer_data,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkAcquireXlibDisplayEXT", "dpy", dpy, VALIDATION_ERROR_16606601);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkAcquireXlibDisplayEXT", "display", display);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetRandROutputDisplayEXT(
+ instance_layer_data* layer_data,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay)
+{
+ UNUSED_PARAMETER(rrOutput);
+
+ bool skipCall = false;
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetRandROutputDisplayEXT", "dpy", dpy, VALIDATION_ERROR_2fc06601);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetRandROutputDisplayEXT", "pDisplay", pDisplay, VALIDATION_ERROR_2fc14801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+static bool parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ instance_layer_data* layer_data,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", "surface", surface);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", "pSurfaceCapabilities", "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT", pSurfaceCapabilities, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT, true, VALIDATION_ERROR_1422b00b);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkDisplayPowerControlEXT(
+ layer_data* layer_data,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkDisplayPowerControlEXT", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_surface_counter) skipCall |= OutputExtensionError(layer_data, "vkDisplayPowerControlEXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_display) skipCall |= OutputExtensionError(layer_data, "vkDisplayPowerControlEXT", VK_KHR_DISPLAY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_control) skipCall |= OutputExtensionError(layer_data, "vkDisplayPowerControlEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkDisplayPowerControlEXT", "display", display);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkDisplayPowerControlEXT", "pDisplayPowerInfo", "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT", pDisplayPowerInfo, VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, true, VALIDATION_ERROR_0742b00b);
+
+ if (pDisplayPowerInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkDisplayPowerControlEXT", "pDisplayPowerInfo->pNext", NULL, pDisplayPowerInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0741c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkDisplayPowerControlEXT", "pDisplayPowerInfo->powerState", "VkDisplayPowerStateEXT", AllVkDisplayPowerStateEXTEnums, pDisplayPowerInfo->powerState, VALIDATION_ERROR_07428a01);
+ }
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkRegisterDeviceEventEXT(
+ layer_data* layer_data,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkRegisterDeviceEventEXT", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_surface_counter) skipCall |= OutputExtensionError(layer_data, "vkRegisterDeviceEventEXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_display) skipCall |= OutputExtensionError(layer_data, "vkRegisterDeviceEventEXT", VK_KHR_DISPLAY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_control) skipCall |= OutputExtensionError(layer_data, "vkRegisterDeviceEventEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkRegisterDeviceEventEXT", "pDeviceEventInfo", "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT", pDeviceEventInfo, VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, true, VALIDATION_ERROR_0582b00b);
+
+ if (pDeviceEventInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkRegisterDeviceEventEXT", "pDeviceEventInfo->pNext", NULL, pDeviceEventInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0581c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkRegisterDeviceEventEXT", "pDeviceEventInfo->deviceEvent", "VkDeviceEventTypeEXT", AllVkDeviceEventTypeEXTEnums, pDeviceEventInfo->deviceEvent, VALIDATION_ERROR_05805801);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDeviceEventEXT", "pAllocator", pAllocator, VALIDATION_ERROR_31e0ec01);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDeviceEventEXT", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDeviceEventEXT", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDeviceEventEXT", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDeviceEventEXT", "pFence", pFence, VALIDATION_ERROR_31e17001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkRegisterDisplayEventEXT(
+ layer_data* layer_data,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkRegisterDisplayEventEXT", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_surface_counter) skipCall |= OutputExtensionError(layer_data, "vkRegisterDisplayEventEXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_display) skipCall |= OutputExtensionError(layer_data, "vkRegisterDisplayEventEXT", VK_KHR_DISPLAY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_control) skipCall |= OutputExtensionError(layer_data, "vkRegisterDisplayEventEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkRegisterDisplayEventEXT", "display", display);
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkRegisterDisplayEventEXT", "pDisplayEventInfo", "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT", pDisplayEventInfo, VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, true, VALIDATION_ERROR_0702b00b);
+
+ if (pDisplayEventInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkRegisterDisplayEventEXT", "pDisplayEventInfo->pNext", NULL, pDisplayEventInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0701c40d);
+
+ skipCall |= validate_ranged_enum(layer_data->report_data, "vkRegisterDisplayEventEXT", "pDisplayEventInfo->displayEvent", "VkDisplayEventTypeEXT", AllVkDisplayEventTypeEXTEnums, pDisplayEventInfo->displayEvent, VALIDATION_ERROR_07006201);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDisplayEventEXT", "pAllocator", pAllocator, VALIDATION_ERROR_3200ec01);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDisplayEventEXT", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDisplayEventEXT", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDisplayEventEXT", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkRegisterDisplayEventEXT", "pFence", pFence, VALIDATION_ERROR_32017001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetSwapchainCounterEXT(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainCounterEXT", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_surface_counter) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainCounterEXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_khr_display) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainCounterEXT", VK_KHR_DISPLAY_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_display_control) skipCall |= OutputExtensionError(layer_data, "vkGetSwapchainCounterEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetSwapchainCounterEXT", "swapchain", swapchain);
+
+ skipCall |= validate_flags(layer_data->report_data, "vkGetSwapchainCounterEXT", "counter", "VkSurfaceCounterFlagBitsEXT", AllVkSurfaceCounterFlagBitsEXT, counter, true, true, VALIDATION_ERROR_30603601);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetSwapchainCounterEXT", "pCounterValue", pCounterValue, VALIDATION_ERROR_30611c01);
+
+ return skipCall;
+}
+
+
+
+static bool parameter_validation_vkGetRefreshCycleDurationGOOGLE(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetRefreshCycleDurationGOOGLE", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_google_display_timing) skipCall |= OutputExtensionError(layer_data, "vkGetRefreshCycleDurationGOOGLE", VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetRefreshCycleDurationGOOGLE", "swapchain", swapchain);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkGetRefreshCycleDurationGOOGLE", "pDisplayTimingProperties", pDisplayTimingProperties, VALIDATION_ERROR_2fe15001);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkGetPastPresentationTimingGOOGLE(
+ layer_data* layer_data,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_swapchain) skipCall |= OutputExtensionError(layer_data, "vkGetPastPresentationTimingGOOGLE", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_google_display_timing) skipCall |= OutputExtensionError(layer_data, "vkGetPastPresentationTimingGOOGLE", VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkGetPastPresentationTimingGOOGLE", "swapchain", swapchain);
+
+ skipCall |= validate_array(layer_data->report_data, "vkGetPastPresentationTimingGOOGLE", "pPresentationTimingCount", "pPresentationTimings", pPresentationTimingCount, pPresentationTimings, true, false, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_2b41ee01);
+
+ return skipCall;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+static bool parameter_validation_vkCmdSetDiscardRectangleEXT(
+ layer_data* layer_data,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles)
+{
+ UNUSED_PARAMETER(firstDiscardRectangle);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_khr_get_physical_device_properties_2) skipCall |= OutputExtensionError(layer_data, "vkCmdSetDiscardRectangleEXT", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+ if (!layer_data->extensions.vk_ext_discard_rectangles) skipCall |= OutputExtensionError(layer_data, "vkCmdSetDiscardRectangleEXT", VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME);
+
+ skipCall |= validate_array(layer_data->report_data, "vkCmdSetDiscardRectangleEXT", "discardRectangleCount", "pDiscardRectangles", discardRectangleCount, pDiscardRectangles, true, true, VALIDATION_ERROR_1d205c1b, VALIDATION_ERROR_1d214601);
+
+ return skipCall;
+}
+
+
+
+
+
+static bool parameter_validation_vkSetHdrMetadataEXT(
+ layer_data* layer_data,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_ext_hdr_metadata) skipCall |= OutputExtensionError(layer_data, "vkSetHdrMetadataEXT", VK_EXT_HDR_METADATA_EXTENSION_NAME);
+
+ skipCall |= validate_handle_array(layer_data->report_data, "vkSetHdrMetadataEXT", "swapchainCount", "pSwapchains", swapchainCount, pSwapchains, true, true);
+
+ skipCall |= validate_struct_type_array(layer_data->report_data, "vkSetHdrMetadataEXT", "swapchainCount", "pMetadata", "VK_STRUCTURE_TYPE_HDR_METADATA_EXT", swapchainCount, pMetadata, VK_STRUCTURE_TYPE_HDR_METADATA_EXT, true, true, VALIDATION_ERROR_3321ba01);
+
+ if (pMetadata != NULL)
+ {
+ for (uint32_t swapchainIndex = 0; swapchainIndex < swapchainCount; ++swapchainIndex)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkSetHdrMetadataEXT", ParameterName("pMetadata[%i].pNext", ParameterName::IndexVector{ swapchainIndex }), NULL, pMetadata[swapchainIndex].pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_UNDEFINED);
+ }
+ }
+
+ return skipCall;
+}
+
+
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+static bool parameter_validation_vkCreateIOSSurfaceMVK(
+ instance_layer_data* layer_data,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pCreateInfo", "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK", pCreateInfo, VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, true, VALIDATION_ERROR_0982b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0981c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_09809005);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pCreateInfo->pView", pCreateInfo->pView, VALIDATION_ERROR_09826a01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateIOSSurfaceMVK", "pSurface", pSurface, VALIDATION_ERROR_20a24801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+
+static bool parameter_validation_vkCreateMacOSSurfaceMVK(
+ instance_layer_data* layer_data,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ bool skipCall = false;
+
+ skipCall |= validate_struct_type(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pCreateInfo", "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK", pCreateInfo, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, true, VALIDATION_ERROR_0c02b00b);
+
+ if (pCreateInfo != NULL)
+ {
+ skipCall |= validate_struct_pnext(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion, VALIDATION_ERROR_0c01c40d);
+
+ skipCall |= validate_reserved_flags(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pCreateInfo->flags", pCreateInfo->flags, VALIDATION_ERROR_0c009005);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pCreateInfo->pView", pCreateInfo->pView, VALIDATION_ERROR_0c026a01);
+ }
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkCreateMacOSSurfaceMVK", "pSurface", pSurface, VALIDATION_ERROR_21424801);
+
+ return skipCall;
+}
+
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static bool parameter_validation_vkExportDeviceMemoryMAGMA(
+ layer_data* layer_data,
+ VkDeviceMemory memory,
+ uint32_t* pHandle)
+{
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_google_external_memory_magma) skipCall |= OutputExtensionError(layer_data, "vkExportDeviceMemoryMAGMA", VK_GOOGLE_EXTERNAL_MEMORY_MAGMA_EXTENSION_NAME);
+
+ skipCall |= validate_required_handle(layer_data->report_data, "vkExportDeviceMemoryMAGMA", "memory", memory);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkExportDeviceMemoryMAGMA", "pHandle", pHandle, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+static bool parameter_validation_vkImportDeviceMemoryMAGMA(
+ layer_data* layer_data,
+ uint32_t handle,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ UNUSED_PARAMETER(handle);
+
+ bool skipCall = false;
+
+ if (!layer_data->extensions.vk_google_external_memory_magma) skipCall |= OutputExtensionError(layer_data, "vkImportDeviceMemoryMAGMA", VK_GOOGLE_EXTERNAL_MEMORY_MAGMA_EXTENSION_NAME);
+
+ if (pAllocator != NULL)
+ {
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkImportDeviceMemoryMAGMA", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation), VALIDATION_ERROR_002004f0);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkImportDeviceMemoryMAGMA", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation), VALIDATION_ERROR_002004f2);
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkImportDeviceMemoryMAGMA", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree), VALIDATION_ERROR_002004f4);
+ }
+
+ skipCall |= validate_required_pointer(layer_data->report_data, "vkImportDeviceMemoryMAGMA", "pMemory", pMemory, VALIDATION_ERROR_UNDEFINED);
+
+ return skipCall;
+}
+
+
+
+
+
+
+// Declarations
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+VKAPI_ATTR void VKAPI_CALL DestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
+ VkDevice device,
+ const char* pName);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+VKAPI_ATTR void VKAPI_CALL DestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
+ VkQueue queue);
+VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
+ VkDevice device);
+VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+VKAPI_ATTR void VKAPI_CALL FreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData);
+VKAPI_ATTR void VKAPI_CALL UnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory);
+VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+VKAPI_ATTR void VKAPI_CALL DestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences);
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
+ VkDevice device,
+ VkFence fence);
+VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout);
+VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+VKAPI_ATTR void VKAPI_CALL DestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
+ VkDevice device,
+ VkEvent event);
+VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
+ VkDevice device,
+ VkEvent event);
+VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
+ VkDevice device,
+ VkEvent event);
+VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+VKAPI_ATTR void VKAPI_CALL DestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout);
+VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+VKAPI_ATTR void VKAPI_CALL DestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData);
+VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+VKAPI_ATTR void VKAPI_CALL DestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
+VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
+VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
+ VkCommandBuffer commandBuffer);
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth);
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants[4]);
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask);
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask);
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference);
+VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+VKAPI_ATTR void VKAPI_CALL CmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance);
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+VKAPI_ATTR void VKAPI_CALL CmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData);
+VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags);
+VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query);
+VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount);
+VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query);
+VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues);
+VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents);
+VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents);
+VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
+ VkCommandBuffer commandBuffer);
+VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex);
+VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays);
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode);
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains);
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID);
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id);
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ struct wl_display* display);
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection);
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+VKAPI_ATTR VkResult VKAPI_CALL CreateMagmaSurfaceKHR(
+ VkInstance instance,
+ const VkMagmaSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMagmaPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+#endif
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2KHR* pFeatures);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2KHR* pProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2KHR* pFormatProperties);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
+ VkImageFormatProperties2KHR* pImageFormatProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2KHR* pProperties);
+VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
+ VkExternalBufferPropertiesKHR* pExternalBufferProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
+ VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const void* pData);
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData);
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
+ VkExternalFencePropertiesKHR* pExternalFenceProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats);
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements);
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements);
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandleKHR(
+ VkDevice device,
+ const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle);
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ uint32_t fuchsiaHandle,
+ VkMemoryFuchsiaHandlePropertiesKHR* pMemoryFuchsiaHandleProperties);
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo);
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle);
+VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback);
+VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage);
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle);
+#endif
+VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfoKHX* pBindInfos);
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfoKHX* pBindInfos);
+VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHX(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes);
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHX* pAcquireInfo,
+ uint32_t* pImageIndex);
+VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects);
+#ifdef VK_USE_PLATFORM_VI_NN
+VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);
+VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable);
+VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices);
+VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices);
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings);
+VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display);
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display);
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue);
+VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings);
+VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles);
+VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata);
+#ifdef VK_USE_PLATFORM_IOS_MVK
+VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+VKAPI_ATTR VkResult VKAPI_CALL ExportDeviceMemoryMAGMA(
+ VkDevice device,
+ VkDeviceMemory memory,
+ uint32_t* pHandle);
+VKAPI_ATTR VkResult VKAPI_CALL ImportDeviceMemoryMAGMA(
+ VkDevice device,
+ uint32_t handle,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+// Map of all APIs to be intercepted by this layer
+static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
+ {"vkCreateInstance", (void*)CreateInstance},
+ {"vkDestroyInstance", (void*)DestroyInstance},
+ {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
+ {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
+ {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
+ {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
+ {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
+ {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
+ {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
+ {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
+ {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
+ {"vkCreateDevice", (void*)CreateDevice},
+ {"vkDestroyDevice", (void*)DestroyDevice},
+ {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
+ {"vkGetDeviceQueue", (void*)GetDeviceQueue},
+ {"vkQueueSubmit", (void*)QueueSubmit},
+ {"vkQueueWaitIdle", (void*)QueueWaitIdle},
+ {"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
+ {"vkAllocateMemory", (void*)AllocateMemory},
+ {"vkFreeMemory", (void*)FreeMemory},
+ {"vkMapMemory", (void*)MapMemory},
+ {"vkUnmapMemory", (void*)UnmapMemory},
+ {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
+ {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
+ {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
+ {"vkBindBufferMemory", (void*)BindBufferMemory},
+ {"vkBindImageMemory", (void*)BindImageMemory},
+ {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
+ {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
+ {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
+ {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
+ {"vkQueueBindSparse", (void*)QueueBindSparse},
+ {"vkCreateFence", (void*)CreateFence},
+ {"vkDestroyFence", (void*)DestroyFence},
+ {"vkResetFences", (void*)ResetFences},
+ {"vkGetFenceStatus", (void*)GetFenceStatus},
+ {"vkWaitForFences", (void*)WaitForFences},
+ {"vkCreateSemaphore", (void*)CreateSemaphore},
+ {"vkDestroySemaphore", (void*)DestroySemaphore},
+ {"vkCreateEvent", (void*)CreateEvent},
+ {"vkDestroyEvent", (void*)DestroyEvent},
+ {"vkGetEventStatus", (void*)GetEventStatus},
+ {"vkSetEvent", (void*)SetEvent},
+ {"vkResetEvent", (void*)ResetEvent},
+ {"vkCreateQueryPool", (void*)CreateQueryPool},
+ {"vkDestroyQueryPool", (void*)DestroyQueryPool},
+ {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
+ {"vkCreateBuffer", (void*)CreateBuffer},
+ {"vkDestroyBuffer", (void*)DestroyBuffer},
+ {"vkCreateBufferView", (void*)CreateBufferView},
+ {"vkDestroyBufferView", (void*)DestroyBufferView},
+ {"vkCreateImage", (void*)CreateImage},
+ {"vkDestroyImage", (void*)DestroyImage},
+ {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
+ {"vkCreateImageView", (void*)CreateImageView},
+ {"vkDestroyImageView", (void*)DestroyImageView},
+ {"vkCreateShaderModule", (void*)CreateShaderModule},
+ {"vkDestroyShaderModule", (void*)DestroyShaderModule},
+ {"vkCreatePipelineCache", (void*)CreatePipelineCache},
+ {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
+ {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
+ {"vkMergePipelineCaches", (void*)MergePipelineCaches},
+ {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
+ {"vkCreateComputePipelines", (void*)CreateComputePipelines},
+ {"vkDestroyPipeline", (void*)DestroyPipeline},
+ {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
+ {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
+ {"vkCreateSampler", (void*)CreateSampler},
+ {"vkDestroySampler", (void*)DestroySampler},
+ {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
+ {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
+ {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
+ {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
+ {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
+ {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
+ {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
+ {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
+ {"vkCreateFramebuffer", (void*)CreateFramebuffer},
+ {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
+ {"vkCreateRenderPass", (void*)CreateRenderPass},
+ {"vkDestroyRenderPass", (void*)DestroyRenderPass},
+ {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
+ {"vkCreateCommandPool", (void*)CreateCommandPool},
+ {"vkDestroyCommandPool", (void*)DestroyCommandPool},
+ {"vkResetCommandPool", (void*)ResetCommandPool},
+ {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
+ {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
+ {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
+ {"vkEndCommandBuffer", (void*)EndCommandBuffer},
+ {"vkResetCommandBuffer", (void*)ResetCommandBuffer},
+ {"vkCmdBindPipeline", (void*)CmdBindPipeline},
+ {"vkCmdSetViewport", (void*)CmdSetViewport},
+ {"vkCmdSetScissor", (void*)CmdSetScissor},
+ {"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
+ {"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
+ {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
+ {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
+ {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
+ {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
+ {"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
+ {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
+ {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
+ {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
+ {"vkCmdDraw", (void*)CmdDraw},
+ {"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
+ {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
+ {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
+ {"vkCmdDispatch", (void*)CmdDispatch},
+ {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
+ {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
+ {"vkCmdCopyImage", (void*)CmdCopyImage},
+ {"vkCmdBlitImage", (void*)CmdBlitImage},
+ {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
+ {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
+ {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
+ {"vkCmdFillBuffer", (void*)CmdFillBuffer},
+ {"vkCmdClearColorImage", (void*)CmdClearColorImage},
+ {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
+ {"vkCmdClearAttachments", (void*)CmdClearAttachments},
+ {"vkCmdResolveImage", (void*)CmdResolveImage},
+ {"vkCmdSetEvent", (void*)CmdSetEvent},
+ {"vkCmdResetEvent", (void*)CmdResetEvent},
+ {"vkCmdWaitEvents", (void*)CmdWaitEvents},
+ {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
+ {"vkCmdBeginQuery", (void*)CmdBeginQuery},
+ {"vkCmdEndQuery", (void*)CmdEndQuery},
+ {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
+ {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
+ {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
+ {"vkCmdPushConstants", (void*)CmdPushConstants},
+ {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
+ {"vkCmdNextSubpass", (void*)CmdNextSubpass},
+ {"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
+ {"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
+ {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
+ {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
+ {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
+ {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
+ {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
+ {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
+ {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
+ {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
+ {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
+ {"vkQueuePresentKHR", (void*)QueuePresentKHR},
+ {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR},
+ {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR},
+ {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
+ {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
+ {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
+ {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
+ {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
+ {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ {"vkCreateMirSurfaceKHR", (void*)CreateMirSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ {"vkGetPhysicalDeviceMirPresentationSupportKHR", (void*)GetPhysicalDeviceMirPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ {"vkCreateMagmaSurfaceKHR", (void*)CreateMagmaSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ {"vkGetPhysicalDeviceMagmaPresentationSupportKHR", (void*)GetPhysicalDeviceMagmaPresentationSupportKHR},
+#endif
+ {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR},
+ {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR},
+ {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR},
+ {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR},
+ {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR},
+ {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR},
+ {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR},
+ {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
+ {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
+#endif
+ {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
+ {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
+ {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
+#endif
+ {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
+ {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
+ {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
+ {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
+ {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
+ {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
+ {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
+ {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
+ {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
+#endif
+ {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
+ {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
+ {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
+ {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
+ {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
+ {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
+ {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
+ {"vkGetMemoryFuchsiaHandleKHR", (void*)GetMemoryFuchsiaHandleKHR},
+ {"vkGetMemoryFuchsiaHandlePropertiesKHR", (void*)GetMemoryFuchsiaHandlePropertiesKHR},
+ {"vkImportSemaphoreFuchsiaHandleKHR", (void*)ImportSemaphoreFuchsiaHandleKHR},
+ {"vkGetSemaphoreFuchsiaHandleKHR", (void*)GetSemaphoreFuchsiaHandleKHR},
+ {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
+ {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
+ {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
+ {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT},
+ {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT},
+ {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT},
+ {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT},
+ {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
+ {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
+ {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
+#endif
+ {"vkGetDeviceGroupPeerMemoryFeaturesKHX", (void*)GetDeviceGroupPeerMemoryFeaturesKHX},
+ {"vkBindBufferMemory2KHX", (void*)BindBufferMemory2KHX},
+ {"vkBindImageMemory2KHX", (void*)BindImageMemory2KHX},
+ {"vkCmdSetDeviceMaskKHX", (void*)CmdSetDeviceMaskKHX},
+ {"vkGetDeviceGroupPresentCapabilitiesKHX", (void*)GetDeviceGroupPresentCapabilitiesKHX},
+ {"vkGetDeviceGroupSurfacePresentModesKHX", (void*)GetDeviceGroupSurfacePresentModesKHX},
+ {"vkAcquireNextImage2KHX", (void*)AcquireNextImage2KHX},
+ {"vkCmdDispatchBaseKHX", (void*)CmdDispatchBaseKHX},
+ {"vkGetPhysicalDevicePresentRectanglesKHX", (void*)GetPhysicalDevicePresentRectanglesKHX},
+#ifdef VK_USE_PLATFORM_VI_NN
+ {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
+#endif
+ {"vkEnumeratePhysicalDeviceGroupsKHX", (void*)EnumeratePhysicalDeviceGroupsKHX},
+ {"vkCmdProcessCommandsNVX", (void*)CmdProcessCommandsNVX},
+ {"vkCmdReserveSpaceForCommandsNVX", (void*)CmdReserveSpaceForCommandsNVX},
+ {"vkCreateIndirectCommandsLayoutNVX", (void*)CreateIndirectCommandsLayoutNVX},
+ {"vkDestroyIndirectCommandsLayoutNVX", (void*)DestroyIndirectCommandsLayoutNVX},
+ {"vkCreateObjectTableNVX", (void*)CreateObjectTableNVX},
+ {"vkDestroyObjectTableNVX", (void*)DestroyObjectTableNVX},
+ {"vkRegisterObjectsNVX", (void*)RegisterObjectsNVX},
+ {"vkUnregisterObjectsNVX", (void*)UnregisterObjectsNVX},
+ {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", (void*)GetPhysicalDeviceGeneratedCommandsPropertiesNVX},
+ {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
+ {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
+#endif
+ {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
+ {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
+ {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
+ {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
+ {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
+ {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
+ {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
+ {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
+ {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
+#endif
+ {"vkExportDeviceMemoryMAGMA", (void*)ExportDeviceMemoryMAGMA},
+ {"vkImportDeviceMemoryMAGMA", (void*)ImportDeviceMemoryMAGMA},
+};
+
+
+} // namespace parameter_validation
+
+#endif
diff --git a/build-fuchsia/generated/include/thread_check.h b/build-fuchsia/generated/include/thread_check.h
new file mode 100644
index 0000000..8232ce1
--- /dev/null
+++ b/build-fuchsia/generated/include/thread_check.h
@@ -0,0 +1,5541 @@
+#ifndef __thread_check_h_
+#define __thread_check_h_ 1
+
+namespace threading {
+
+/*
+** Copyright (c) 2015-2017 The Khronos Group 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.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+
+// declare only
+VKAPI_ATTR void VKAPI_CALL DestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->EnumeratePhysicalDevices(instance,pPhysicalDeviceCount,pPhysicalDevices);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+// declare only
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+
+// declare only
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
+ VkDevice device,
+ const char* pName);
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+// declare only
+VKAPI_ATTR void VKAPI_CALL DestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ pTable->GetDeviceQueue(device,queueFamilyIndex,queueIndex,pQueue);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ dispatch_key key = get_dispatch_key(queue);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, queue);
+ for (uint32_t index=0;index<submitCount;index++) {
+ for(uint32_t index2=0;index2<pSubmits[index].waitSemaphoreCount;index2++)
+ startWriteObject(my_data, pSubmits[index].pWaitSemaphores[index2]);
+ for(uint32_t index2=0;index2<pSubmits[index].signalSemaphoreCount;index2++)
+ startWriteObject(my_data, pSubmits[index].pSignalSemaphores[index2]);
+ }
+ startWriteObject(my_data, fence);
+ // Host access to queue must be externally synchronized
+ // Host access to pSubmits[].pWaitSemaphores[],pSubmits[].pSignalSemaphores[] must be externally synchronized
+ // Host access to fence must be externally synchronized
+ }
+ result = pTable->QueueSubmit(queue,submitCount,pSubmits,fence);
+ if (threadChecks) {
+ finishWriteObject(my_data, queue);
+ for (uint32_t index=0;index<submitCount;index++) {
+ for(uint32_t index2=0;index2<pSubmits[index].waitSemaphoreCount;index2++)
+ finishWriteObject(my_data, pSubmits[index].pWaitSemaphores[index2]);
+ for(uint32_t index2=0;index2<pSubmits[index].signalSemaphoreCount;index2++)
+ finishWriteObject(my_data, pSubmits[index].pSignalSemaphores[index2]);
+ }
+ finishWriteObject(my_data, fence);
+ // Host access to queue must be externally synchronized
+ // Host access to pSubmits[].pWaitSemaphores[],pSubmits[].pSignalSemaphores[] must be externally synchronized
+ // Host access to fence must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
+ VkQueue queue)
+{
+ dispatch_key key = get_dispatch_key(queue);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, queue);
+ }
+ result = pTable->QueueWaitIdle(queue);
+ if (threadChecks) {
+ finishReadObject(my_data, queue);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
+ VkDevice device)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ // all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses
+ }
+ result = pTable->DeviceWaitIdle(device);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ // all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->AllocateMemory(device,pAllocateInfo,pAllocator,pMemory);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL FreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ }
+ pTable->FreeMemory(device,memory,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ }
+ result = pTable->MapMemory(device,memory,offset,size,flags,ppData);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL UnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ }
+ pTable->UnmapMemory(device,memory);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, memory);
+ // Host access to memory must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->FlushMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->InvalidateMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, memory);
+ }
+ pTable->GetDeviceMemoryCommitment(device,memory,pCommittedMemoryInBytes);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, memory);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, buffer);
+ startReadObject(my_data, memory);
+ // Host access to buffer must be externally synchronized
+ }
+ result = pTable->BindBufferMemory(device,buffer,memory,memoryOffset);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, buffer);
+ finishReadObject(my_data, memory);
+ // Host access to buffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, image);
+ startReadObject(my_data, memory);
+ // Host access to image must be externally synchronized
+ }
+ result = pTable->BindImageMemory(device,image,memory,memoryOffset);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, image);
+ finishReadObject(my_data, memory);
+ // Host access to image must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, buffer);
+ }
+ pTable->GetBufferMemoryRequirements(device,buffer,pMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, buffer);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, image);
+ }
+ pTable->GetImageMemoryRequirements(device,image,pMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, image);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, image);
+ }
+ pTable->GetImageSparseMemoryRequirements(device,image,pSparseMemoryRequirementCount,pSparseMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, image);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ dispatch_key key = get_dispatch_key(queue);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, queue);
+ for (uint32_t index=0;index<bindInfoCount;index++) {
+ for(uint32_t index2=0;index2<pBindInfo[index].waitSemaphoreCount;index2++)
+ startWriteObject(my_data, pBindInfo[index].pWaitSemaphores[index2]);
+ for(uint32_t index2=0;index2<pBindInfo[index].signalSemaphoreCount;index2++)
+ startWriteObject(my_data, pBindInfo[index].pSignalSemaphores[index2]);
+ for(uint32_t index2=0;index2<pBindInfo[index].bufferBindCount;index2++)
+ startWriteObject(my_data, pBindInfo[index].pBufferBinds[index2].buffer);
+ for(uint32_t index2=0;index2<pBindInfo[index].imageOpaqueBindCount;index2++)
+ startWriteObject(my_data, pBindInfo[index].pImageOpaqueBinds[index2].image);
+ for(uint32_t index2=0;index2<pBindInfo[index].imageBindCount;index2++)
+ startWriteObject(my_data, pBindInfo[index].pImageBinds[index2].image);
+ }
+ startWriteObject(my_data, fence);
+ // Host access to queue must be externally synchronized
+ // Host access to pBindInfo[].pWaitSemaphores[],pBindInfo[].pSignalSemaphores[],pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized
+ // Host access to fence must be externally synchronized
+ }
+ result = pTable->QueueBindSparse(queue,bindInfoCount,pBindInfo,fence);
+ if (threadChecks) {
+ finishWriteObject(my_data, queue);
+ for (uint32_t index=0;index<bindInfoCount;index++) {
+ for(uint32_t index2=0;index2<pBindInfo[index].waitSemaphoreCount;index2++)
+ finishWriteObject(my_data, pBindInfo[index].pWaitSemaphores[index2]);
+ for(uint32_t index2=0;index2<pBindInfo[index].signalSemaphoreCount;index2++)
+ finishWriteObject(my_data, pBindInfo[index].pSignalSemaphores[index2]);
+ for(uint32_t index2=0;index2<pBindInfo[index].bufferBindCount;index2++)
+ finishWriteObject(my_data, pBindInfo[index].pBufferBinds[index2].buffer);
+ for(uint32_t index2=0;index2<pBindInfo[index].imageOpaqueBindCount;index2++)
+ finishWriteObject(my_data, pBindInfo[index].pImageOpaqueBinds[index2].image);
+ for(uint32_t index2=0;index2<pBindInfo[index].imageBindCount;index2++)
+ finishWriteObject(my_data, pBindInfo[index].pImageBinds[index2].image);
+ }
+ finishWriteObject(my_data, fence);
+ // Host access to queue must be externally synchronized
+ // Host access to pBindInfo[].pWaitSemaphores[],pBindInfo[].pSignalSemaphores[],pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized
+ // Host access to fence must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateFence(device,pCreateInfo,pAllocator,pFence);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, fence);
+ // Host access to fence must be externally synchronized
+ }
+ pTable->DestroyFence(device,fence,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, fence);
+ // Host access to fence must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ for (uint32_t index=0;index<fenceCount;index++) {
+ startWriteObject(my_data, pFences[index]);
+ }
+ // Host access to each member of pFences must be externally synchronized
+ }
+ result = pTable->ResetFences(device,fenceCount,pFences);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ for (uint32_t index=0;index<fenceCount;index++) {
+ finishWriteObject(my_data, pFences[index]);
+ }
+ // Host access to each member of pFences must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
+ VkDevice device,
+ VkFence fence)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, fence);
+ }
+ result = pTable->GetFenceStatus(device,fence);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, fence);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ for (uint32_t index = 0; index < fenceCount; index++) {
+ startReadObject(my_data, pFences[index]);
+ }
+ }
+ result = pTable->WaitForFences(device,fenceCount,pFences,waitAll,timeout);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ for (uint32_t index = 0; index < fenceCount; index++) {
+ finishReadObject(my_data, pFences[index]);
+ }
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateSemaphore(device,pCreateInfo,pAllocator,pSemaphore);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, semaphore);
+ // Host access to semaphore must be externally synchronized
+ }
+ pTable->DestroySemaphore(device,semaphore,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, semaphore);
+ // Host access to semaphore must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateEvent(device,pCreateInfo,pAllocator,pEvent);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ }
+ pTable->DestroyEvent(device,event,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
+ VkDevice device,
+ VkEvent event)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, event);
+ }
+ result = pTable->GetEventStatus(device,event);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, event);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ }
+ result = pTable->SetEvent(device,event);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ }
+ result = pTable->ResetEvent(device,event);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, event);
+ // Host access to event must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateQueryPool(device,pCreateInfo,pAllocator,pQueryPool);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, queryPool);
+ // Host access to queryPool must be externally synchronized
+ }
+ pTable->DestroyQueryPool(device,queryPool,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, queryPool);
+ // Host access to queryPool must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, queryPool);
+ }
+ result = pTable->GetQueryPoolResults(device,queryPool,firstQuery,queryCount,dataSize,pData,stride,flags);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, queryPool);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateBuffer(device,pCreateInfo,pAllocator,pBuffer);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, buffer);
+ // Host access to buffer must be externally synchronized
+ }
+ pTable->DestroyBuffer(device,buffer,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, buffer);
+ // Host access to buffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateBufferView(device,pCreateInfo,pAllocator,pView);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, bufferView);
+ // Host access to bufferView must be externally synchronized
+ }
+ pTable->DestroyBufferView(device,bufferView,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, bufferView);
+ // Host access to bufferView must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateImage(device,pCreateInfo,pAllocator,pImage);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, image);
+ // Host access to image must be externally synchronized
+ }
+ pTable->DestroyImage(device,image,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, image);
+ // Host access to image must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, image);
+ }
+ pTable->GetImageSubresourceLayout(device,image,pSubresource,pLayout);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, image);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateImageView(device,pCreateInfo,pAllocator,pView);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, imageView);
+ // Host access to imageView must be externally synchronized
+ }
+ pTable->DestroyImageView(device,imageView,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, imageView);
+ // Host access to imageView must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateShaderModule(device,pCreateInfo,pAllocator,pShaderModule);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, shaderModule);
+ // Host access to shaderModule must be externally synchronized
+ }
+ pTable->DestroyShaderModule(device,shaderModule,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, shaderModule);
+ // Host access to shaderModule must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreatePipelineCache(device,pCreateInfo,pAllocator,pPipelineCache);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, pipelineCache);
+ // Host access to pipelineCache must be externally synchronized
+ }
+ pTable->DestroyPipelineCache(device,pipelineCache,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, pipelineCache);
+ // Host access to pipelineCache must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, pipelineCache);
+ }
+ result = pTable->GetPipelineCacheData(device,pipelineCache,pDataSize,pData);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, pipelineCache);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, dstCache);
+ for (uint32_t index = 0; index < srcCacheCount; index++) {
+ startReadObject(my_data, pSrcCaches[index]);
+ }
+ // Host access to dstCache must be externally synchronized
+ }
+ result = pTable->MergePipelineCaches(device,dstCache,srcCacheCount,pSrcCaches);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, dstCache);
+ for (uint32_t index = 0; index < srcCacheCount; index++) {
+ finishReadObject(my_data, pSrcCaches[index]);
+ }
+ // Host access to dstCache must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, pipelineCache);
+ }
+ result = pTable->CreateGraphicsPipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, pipelineCache);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, pipelineCache);
+ }
+ result = pTable->CreateComputePipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, pipelineCache);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, pipeline);
+ // Host access to pipeline must be externally synchronized
+ }
+ pTable->DestroyPipeline(device,pipeline,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, pipeline);
+ // Host access to pipeline must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreatePipelineLayout(device,pCreateInfo,pAllocator,pPipelineLayout);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, pipelineLayout);
+ // Host access to pipelineLayout must be externally synchronized
+ }
+ pTable->DestroyPipelineLayout(device,pipelineLayout,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, pipelineLayout);
+ // Host access to pipelineLayout must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateSampler(device,pCreateInfo,pAllocator,pSampler);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, sampler);
+ // Host access to sampler must be externally synchronized
+ }
+ pTable->DestroySampler(device,sampler,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, sampler);
+ // Host access to sampler must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateDescriptorSetLayout(device,pCreateInfo,pAllocator,pSetLayout);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorSetLayout);
+ // Host access to descriptorSetLayout must be externally synchronized
+ }
+ pTable->DestroyDescriptorSetLayout(device,descriptorSetLayout,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorSetLayout);
+ // Host access to descriptorSetLayout must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateDescriptorPool(device,pCreateInfo,pAllocator,pDescriptorPool);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorPool);
+ // Host access to descriptorPool must be externally synchronized
+ }
+ pTable->DestroyDescriptorPool(device,descriptorPool,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorPool);
+ // Host access to descriptorPool must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorPool);
+ // Host access to descriptorPool must be externally synchronized
+ // any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses
+ }
+ result = pTable->ResetDescriptorPool(device,descriptorPool,flags);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorPool);
+ // Host access to descriptorPool must be externally synchronized
+ // any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+
+VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorPool);
+ for (uint32_t index=0;index<descriptorSetCount;index++) {
+ startWriteObject(my_data, pDescriptorSets[index]);
+ }
+ // Host access to descriptorPool must be externally synchronized
+ // Host access to each member of pDescriptorSets must be externally synchronized
+ }
+ result = pTable->FreeDescriptorSets(device,descriptorPool,descriptorSetCount,pDescriptorSets);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorPool);
+ for (uint32_t index=0;index<descriptorSetCount;index++) {
+ finishWriteObject(my_data, pDescriptorSets[index]);
+ }
+ // Host access to descriptorPool must be externally synchronized
+ // Host access to each member of pDescriptorSets must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ for (uint32_t index=0;index<descriptorWriteCount;index++) {
+ startWriteObject(my_data, pDescriptorWrites[index].dstSet);
+ }
+ for (uint32_t index=0;index<descriptorCopyCount;index++) {
+ startWriteObject(my_data, pDescriptorCopies[index].dstSet);
+ }
+ // Host access to pDescriptorWrites[].dstSet must be externally synchronized
+ // Host access to pDescriptorCopies[].dstSet must be externally synchronized
+ }
+ pTable->UpdateDescriptorSets(device,descriptorWriteCount,pDescriptorWrites,descriptorCopyCount,pDescriptorCopies);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ for (uint32_t index=0;index<descriptorWriteCount;index++) {
+ finishWriteObject(my_data, pDescriptorWrites[index].dstSet);
+ }
+ for (uint32_t index=0;index<descriptorCopyCount;index++) {
+ finishWriteObject(my_data, pDescriptorCopies[index].dstSet);
+ }
+ // Host access to pDescriptorWrites[].dstSet must be externally synchronized
+ // Host access to pDescriptorCopies[].dstSet must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateFramebuffer(device,pCreateInfo,pAllocator,pFramebuffer);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, framebuffer);
+ // Host access to framebuffer must be externally synchronized
+ }
+ pTable->DestroyFramebuffer(device,framebuffer,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, framebuffer);
+ // Host access to framebuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateRenderPass(device,pCreateInfo,pAllocator,pRenderPass);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, renderPass);
+ // Host access to renderPass must be externally synchronized
+ }
+ pTable->DestroyRenderPass(device,renderPass,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, renderPass);
+ // Host access to renderPass must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, renderPass);
+ }
+ pTable->GetRenderAreaGranularity(device,renderPass,pGranularity);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, renderPass);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateCommandPool(device,pCreateInfo,pAllocator,pCommandPool);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ }
+ pTable->DestroyCommandPool(device,commandPool,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ }
+ result = pTable->ResetCommandPool(device,commandPool,flags);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+
+// declare only
+VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+
+VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ // the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
+ }
+ result = pTable->BeginCommandBuffer(commandBuffer,pBeginInfo);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ // the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
+ VkCommandBuffer commandBuffer)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ // the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
+ }
+ result = pTable->EndCommandBuffer(commandBuffer);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ // the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ result = pTable->ResetCommandBuffer(commandBuffer,flags);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, pipeline);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBindPipeline(commandBuffer,pipelineBindPoint,pipeline);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, pipeline);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetViewport(commandBuffer,firstViewport,viewportCount,pViewports);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetScissor(commandBuffer,firstScissor,scissorCount,pScissors);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetLineWidth(commandBuffer,lineWidth);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetDepthBias(commandBuffer,depthBiasConstantFactor,depthBiasClamp,depthBiasSlopeFactor);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants[4])
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetBlendConstants(commandBuffer,blendConstants);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetDepthBounds(commandBuffer,minDepthBounds,maxDepthBounds);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetStencilCompareMask(commandBuffer,faceMask,compareMask);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetStencilWriteMask(commandBuffer,faceMask,writeMask);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetStencilReference(commandBuffer,faceMask,reference);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, layout);
+ for (uint32_t index = 0; index < descriptorSetCount; index++) {
+ startReadObject(my_data, pDescriptorSets[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBindDescriptorSets(commandBuffer,pipelineBindPoint,layout,firstSet,descriptorSetCount,pDescriptorSets,dynamicOffsetCount,pDynamicOffsets);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, layout);
+ for (uint32_t index = 0; index < descriptorSetCount; index++) {
+ finishReadObject(my_data, pDescriptorSets[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBindIndexBuffer(commandBuffer,buffer,offset,indexType);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < bindingCount; index++) {
+ startReadObject(my_data, pBuffers[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBindVertexBuffers(commandBuffer,firstBinding,bindingCount,pBuffers,pOffsets);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < bindingCount; index++) {
+ finishReadObject(my_data, pBuffers[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDraw(commandBuffer,vertexCount,instanceCount,firstVertex,firstInstance);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDrawIndexed(commandBuffer,indexCount,instanceCount,firstIndex,vertexOffset,firstInstance);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDrawIndirect(commandBuffer,buffer,offset,drawCount,stride);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDrawIndexedIndirect(commandBuffer,buffer,offset,drawCount,stride);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDispatch(commandBuffer,groupCountX,groupCountY,groupCountZ);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDispatchIndirect(commandBuffer,buffer,offset);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcBuffer);
+ startReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdCopyBuffer(commandBuffer,srcBuffer,dstBuffer,regionCount,pRegions);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcBuffer);
+ finishReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcImage);
+ startReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdCopyImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcImage);
+ finishReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcImage);
+ startReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBlitImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions,filter);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcImage);
+ finishReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcBuffer);
+ startReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdCopyBufferToImage(commandBuffer,srcBuffer,dstImage,dstImageLayout,regionCount,pRegions);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcBuffer);
+ finishReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcImage);
+ startReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdCopyImageToBuffer(commandBuffer,srcImage,srcImageLayout,dstBuffer,regionCount,pRegions);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcImage);
+ finishReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdUpdateBuffer(commandBuffer,dstBuffer,dstOffset,dataSize,pData);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdFillBuffer(commandBuffer,dstBuffer,dstOffset,size,data);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, image);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdClearColorImage(commandBuffer,image,imageLayout,pColor,rangeCount,pRanges);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, image);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, image);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdClearDepthStencilImage(commandBuffer,image,imageLayout,pDepthStencil,rangeCount,pRanges);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, image);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdClearAttachments(commandBuffer,attachmentCount,pAttachments,rectCount,pRects);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, srcImage);
+ startReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdResolveImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, srcImage);
+ finishReadObject(my_data, dstImage);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, event);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetEvent(commandBuffer,event,stageMask);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, event);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, event);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdResetEvent(commandBuffer,event,stageMask);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, event);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < eventCount; index++) {
+ startReadObject(my_data, pEvents[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdWaitEvents(commandBuffer,eventCount,pEvents,srcStageMask,dstStageMask,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < eventCount; index++) {
+ finishReadObject(my_data, pEvents[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdPipelineBarrier(commandBuffer,srcStageMask,dstStageMask,dependencyFlags,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBeginQuery(commandBuffer,queryPool,query,flags);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdEndQuery(commandBuffer,queryPool,query);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdResetQueryPool(commandBuffer,queryPool,firstQuery,queryCount);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdWriteTimestamp(commandBuffer,pipelineStage,queryPool,query);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, queryPool);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, queryPool);
+ startReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdCopyQueryPoolResults(commandBuffer,queryPool,firstQuery,queryCount,dstBuffer,dstOffset,stride,flags);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, queryPool);
+ finishReadObject(my_data, dstBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdPushConstants(commandBuffer,layout,stageFlags,offset,size,pValues);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdBeginRenderPass(commandBuffer,pRenderPassBegin,contents);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdNextSubpass(commandBuffer,contents);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
+ VkCommandBuffer commandBuffer)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdEndRenderPass(commandBuffer);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < commandBufferCount; index++) {
+ startReadObject(my_data, pCommandBuffers[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdExecuteCommands(commandBuffer,commandBufferCount,pCommandBuffers);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ for (uint32_t index = 0; index < commandBufferCount; index++) {
+ finishReadObject(my_data, pCommandBuffers[index]);
+ }
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ startWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ }
+ pTable->DestroySurfaceKHR(instance,surface,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ finishWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, surface);
+ }
+ result = pTable->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice,queueFamilyIndex,surface,pSupported);
+ if (threadChecks) {
+ finishReadObject(my_data, surface);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, surface);
+ }
+ result = pTable->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice,surface,pSurfaceCapabilities);
+ if (threadChecks) {
+ finishReadObject(my_data, surface);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, surface);
+ }
+ result = pTable->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,surface,pSurfaceFormatCount,pSurfaceFormats);
+ if (threadChecks) {
+ finishReadObject(my_data, surface);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, surface);
+ }
+ result = pTable->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice,surface,pPresentModeCount,pPresentModes);
+ if (threadChecks) {
+ finishReadObject(my_data, surface);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, pCreateInfo->surface);
+ startWriteObject(my_data, pCreateInfo->oldSwapchain);
+ // Host access to pCreateInfo.surface,pCreateInfo.oldSwapchain must be externally synchronized
+ }
+ result = pTable->CreateSwapchainKHR(device,pCreateInfo,pAllocator,pSwapchain);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, pCreateInfo->surface);
+ finishWriteObject(my_data, pCreateInfo->oldSwapchain);
+ // Host access to pCreateInfo.surface,pCreateInfo.oldSwapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ }
+ pTable->DestroySwapchainKHR(device,swapchain,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, swapchain);
+ startWriteObject(my_data, semaphore);
+ startWriteObject(my_data, fence);
+ // Host access to swapchain must be externally synchronized
+ // Host access to semaphore must be externally synchronized
+ // Host access to fence must be externally synchronized
+ }
+ result = pTable->AcquireNextImageKHR(device,swapchain,timeout,semaphore,fence,pImageIndex);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, swapchain);
+ finishWriteObject(my_data, semaphore);
+ finishWriteObject(my_data, fence);
+ // Host access to swapchain must be externally synchronized
+ // Host access to semaphore must be externally synchronized
+ // Host access to fence must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+// TODO - not wrapping EXT function vkQueuePresentKHR
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ for (uint32_t index = 0; index < *pDisplayCount; index++) {
+ startReadObject(my_data, pDisplays[index]);
+ }
+ }
+ result = pTable->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice,planeIndex,pDisplayCount,pDisplays);
+ if (threadChecks) {
+ for (uint32_t index = 0; index < *pDisplayCount; index++) {
+ finishReadObject(my_data, pDisplays[index]);
+ }
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, display);
+ }
+ result = pTable->GetDisplayModePropertiesKHR(physicalDevice,display,pPropertyCount,pProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, display);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, display);
+ // Host access to display must be externally synchronized
+ }
+ result = pTable->CreateDisplayModeKHR(physicalDevice,display,pCreateInfo,pAllocator,pMode);
+ if (threadChecks) {
+ finishWriteObject(my_data, display);
+ // Host access to display must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, mode);
+ // Host access to mode must be externally synchronized
+ }
+ result = pTable->GetDisplayPlaneCapabilitiesKHR(physicalDevice,mode,planeIndex,pCapabilities);
+ if (threadChecks) {
+ finishWriteObject(my_data, mode);
+ // Host access to mode must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateDisplayPlaneSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ for (uint32_t index=0;index<swapchainCount;index++) {
+ startWriteObject(my_data, pCreateInfos[index].surface);
+ startWriteObject(my_data, pCreateInfos[index].oldSwapchain);
+ }
+ for (uint32_t index = 0; index < swapchainCount; index++) {
+ startReadObject(my_data, pSwapchains[index]);
+ }
+ // Host access to pCreateInfos[].surface,pCreateInfos[].oldSwapchain must be externally synchronized
+ }
+ result = pTable->CreateSharedSwapchainsKHR(device,swapchainCount,pCreateInfos,pAllocator,pSwapchains);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ for (uint32_t index=0;index<swapchainCount;index++) {
+ finishWriteObject(my_data, pCreateInfos[index].surface);
+ finishWriteObject(my_data, pCreateInfos[index].oldSwapchain);
+ }
+ for (uint32_t index = 0; index < swapchainCount; index++) {
+ finishReadObject(my_data, pSwapchains[index]);
+ }
+ // Host access to pCreateInfos[].surface,pCreateInfos[].oldSwapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateXlibSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateXcbSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_XCB_KHR */
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateWaylandSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateMirSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_MIR_KHR */
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateAndroidSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateWin32SurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMagmaSurfaceKHR(
+ VkInstance instance,
+ const VkMagmaSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateMagmaSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_MAGMA_KHR */
+
+
+
+
+
+VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ }
+ pTable->TrimCommandPoolKHR(device,commandPool,flags);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, commandPool);
+ // Host access to commandPool must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryWin32HandleKHR(device,pGetWin32HandleInfo,pHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryWin32HandlePropertiesKHR(device,handleType,handle,pMemoryWin32HandleProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryFdKHR(device,pGetFdInfo,pFd);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryFdPropertiesKHR(device,handleType,fd,pMemoryFdProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportSemaphoreWin32HandleKHR(device,pImportSemaphoreWin32HandleInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetSemaphoreWin32HandleKHR(device,pGetWin32HandleInfo,pHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportSemaphoreFdKHR(device,pImportSemaphoreFdInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetSemaphoreFdKHR(device,pGetFdInfo,pFd);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdPushDescriptorSetKHR(commandBuffer,pipelineBindPoint,layout,set,descriptorWriteCount,pDescriptorWrites);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateDescriptorUpdateTemplateKHR(device,pCreateInfo,pAllocator,pDescriptorUpdateTemplate);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorUpdateTemplate);
+ // Host access to descriptorUpdateTemplate must be externally synchronized
+ }
+ pTable->DestroyDescriptorUpdateTemplateKHR(device,descriptorUpdateTemplate,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorUpdateTemplate);
+ // Host access to descriptorUpdateTemplate must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const void* pData)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, descriptorSet);
+ startReadObject(my_data, descriptorUpdateTemplate);
+ // Host access to descriptorSet must be externally synchronized
+ }
+ pTable->UpdateDescriptorSetWithTemplateKHR(device,descriptorSet,descriptorUpdateTemplate,pData);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, descriptorSet);
+ finishReadObject(my_data, descriptorUpdateTemplate);
+ // Host access to descriptorSet must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, descriptorUpdateTemplate);
+ startReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdPushDescriptorSetWithTemplateKHR(commandBuffer,descriptorUpdateTemplate,layout,set,pData);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, descriptorUpdateTemplate);
+ finishReadObject(my_data, layout);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ }
+ result = pTable->GetSwapchainStatusKHR(device,swapchain);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportFenceWin32HandleKHR(device,pImportFenceWin32HandleInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetFenceWin32HandleKHR(device,pGetWin32HandleInfo,pHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportFenceFdKHR(device,pImportFenceFdInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetFenceFdKHR(device,pGetFdInfo,pFd);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+
+
+
+
+
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ pTable->GetImageMemoryRequirements2KHR(device,pInfo,pMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ pTable->GetBufferMemoryRequirements2KHR(device,pInfo,pMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ pTable->GetImageSparseMemoryRequirements2KHR(device,pInfo,pSparseMemoryRequirementCount,pSparseMemoryRequirements);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandleKHR(
+ VkDevice device,
+ const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryFuchsiaHandleKHR(device,pGetFuchsiaHandleInfo,pFuchsiaHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ uint32_t fuchsiaHandle,
+ VkMemoryFuchsiaHandlePropertiesKHR* pMemoryFuchsiaHandleProperties)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetMemoryFuchsiaHandlePropertiesKHR(device,handleType,fuchsiaHandle,pMemoryFuchsiaHandleProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportSemaphoreFuchsiaHandleKHR(device,pImportSemaphoreFuchsiaHandleInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetSemaphoreFuchsiaHandleKHR(device,pGetFuchsiaHandleInfo,pFuchsiaHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+// declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback);
+
+// declare only
+VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ pTable->DebugReportMessageEXT(instance,flags,objectType,object,location,messageCode,pLayerPrefix,pMessage);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+
+
+
+
+
+// TODO - not wrapping EXT function vkDebugMarkerSetObjectTagEXT
+// TODO - not wrapping EXT function vkDebugMarkerSetObjectNameEXT
+// TODO - not wrapping EXT function vkCmdDebugMarkerBeginEXT
+// TODO - not wrapping EXT function vkCmdDebugMarkerEndEXT
+// TODO - not wrapping EXT function vkCmdDebugMarkerInsertEXT
+
+
+
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ startReadObject(my_data, countBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDrawIndirectCountAMD(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ finishReadObject(my_data, countBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ startReadObject(my_data, buffer);
+ startReadObject(my_data, countBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDrawIndexedIndirectCountAMD(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ finishReadObject(my_data, buffer);
+ finishReadObject(my_data, countBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+
+
+
+
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, memory);
+ }
+ result = pTable->GetMemoryWin32HandleNV(device,memory,handleType,pHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, memory);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+
+VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ pTable->GetDeviceGroupPeerMemoryFeaturesKHX(device,heapIndex,localDeviceIndex,remoteDeviceIndex,pPeerMemoryFeatures);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfoKHX* pBindInfos)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->BindBufferMemory2KHX(device,bindInfoCount,pBindInfos);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfoKHX* pBindInfos)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->BindImageMemory2KHX(device,bindInfoCount,pBindInfos);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetDeviceMaskKHX(commandBuffer,deviceMask);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHX(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->GetDeviceGroupPresentCapabilitiesKHX(device,pDeviceGroupPresentCapabilities);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ }
+ result = pTable->GetDeviceGroupSurfacePresentModesKHX(device,surface,pModes);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHX* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->AcquireNextImage2KHX(device,pAcquireInfo,pImageIndex);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdDispatchBaseKHX(commandBuffer,baseGroupX,baseGroupY,baseGroupZ,groupCountX,groupCountY,groupCountZ);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ }
+ result = pTable->GetPhysicalDevicePresentRectanglesKHX(physicalDevice,surface,pRectCount,pRects);
+ if (threadChecks) {
+ finishWriteObject(my_data, surface);
+ // Host access to surface must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+#ifdef VK_USE_PLATFORM_VI_NN
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateViSurfaceNN(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_VI_NN */
+
+
+
+
+VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->EnumeratePhysicalDeviceGroupsKHX(instance,pPhysicalDeviceGroupCount,pPhysicalDeviceGroupProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdProcessCommandsNVX(commandBuffer,pProcessCommandsInfo);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdReserveSpaceForCommandsNVX(commandBuffer,pReserveSpaceInfo);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateIndirectCommandsLayoutNVX(device,pCreateInfo,pAllocator,pIndirectCommandsLayout);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, indirectCommandsLayout);
+ }
+ pTable->DestroyIndirectCommandsLayoutNVX(device,indirectCommandsLayout,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, indirectCommandsLayout);
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->CreateObjectTableNVX(device,pCreateInfo,pAllocator,pObjectTable);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ }
+ pTable->DestroyObjectTableNVX(device,objectTable,pAllocator);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ }
+ result = pTable->RegisterObjectsNVX(device,objectTable,objectCount,ppObjectTableEntries,pObjectIndices);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ }
+ result = pTable->UnregisterObjectsNVX(device,objectTable,objectCount,pObjectEntryTypes,pObjectIndices);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, objectTable);
+ // Host access to objectTable must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetViewportWScalingNV(commandBuffer,firstViewport,viewportCount,pViewportWScalings);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, display);
+ }
+ result = pTable->ReleaseDisplayEXT(physicalDevice,display);
+ if (threadChecks) {
+ finishReadObject(my_data, display);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, display);
+ }
+ result = pTable->AcquireXlibDisplayEXT(physicalDevice,dpy,display);
+ if (threadChecks) {
+ finishReadObject(my_data, display);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ dispatch_key key = get_dispatch_key(physicalDevice);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, surface);
+ }
+ result = pTable->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice,surface,pSurfaceCapabilities);
+ if (threadChecks) {
+ finishReadObject(my_data, surface);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, display);
+ }
+ result = pTable->DisplayPowerControlEXT(device,display,pDisplayPowerInfo);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, display);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->RegisterDeviceEventEXT(device,pDeviceEventInfo,pAllocator,pFence);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, display);
+ }
+ result = pTable->RegisterDisplayEventEXT(device,display,pDisplayEventInfo,pAllocator,pFence);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, display);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, swapchain);
+ }
+ result = pTable->GetSwapchainCounterEXT(device,swapchain,counter,pCounterValue);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, swapchain);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ }
+ result = pTable->GetRefreshCycleDurationGOOGLE(device,swapchain,pDisplayTimingProperties);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ }
+ result = pTable->GetPastPresentationTimingGOOGLE(device,swapchain,pPresentationTimingCount,pPresentationTimings);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishWriteObject(my_data, swapchain);
+ // Host access to swapchain must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+
+
+
+
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles)
+{
+ dispatch_key key = get_dispatch_key(commandBuffer);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ }
+ pTable->CmdSetDiscardRectangleEXT(commandBuffer,firstDiscardRectangle,discardRectangleCount,pDiscardRectangles);
+ if (threadChecks) {
+ finishWriteObject(my_data, commandBuffer);
+ // Host access to commandBuffer must be externally synchronized
+ } else {
+ finishMultiThread();
+ }
+}
+
+
+
+VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ for (uint32_t index = 0; index < swapchainCount; index++) {
+ startReadObject(my_data, pSwapchains[index]);
+ }
+ }
+ pTable->SetHdrMetadataEXT(device,swapchainCount,pSwapchains,pMetadata);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ for (uint32_t index = 0; index < swapchainCount; index++) {
+ finishReadObject(my_data, pSwapchains[index]);
+ }
+ } else {
+ finishMultiThread();
+ }
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateIOSSurfaceMVK(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_IOS_MVK */
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ dispatch_key key = get_dispatch_key(instance);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, instance);
+ }
+ result = pTable->CreateMacOSSurfaceMVK(instance,pCreateInfo,pAllocator,pSurface);
+ if (threadChecks) {
+ finishReadObject(my_data, instance);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+#endif /* VK_USE_PLATFORM_MACOS_MVK */
+
+
+
+
+
+
+
+
+
+
+VKAPI_ATTR VkResult VKAPI_CALL ExportDeviceMemoryMAGMA(
+ VkDevice device,
+ VkDeviceMemory memory,
+ uint32_t* pHandle)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ startReadObject(my_data, memory);
+ }
+ result = pTable->ExportDeviceMemoryMAGMA(device,memory,pHandle);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ finishReadObject(my_data, memory);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportDeviceMemoryMAGMA(
+ VkDevice device,
+ uint32_t handle,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ dispatch_key key = get_dispatch_key(device);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
+ VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
+ VkResult result;
+ bool threadChecks = startMultiThread();
+ if (threadChecks) {
+ startReadObject(my_data, device);
+ }
+ result = pTable->ImportDeviceMemoryMAGMA(device,handle,pAllocator,pMemory);
+ if (threadChecks) {
+ finishReadObject(my_data, device);
+ } else {
+ finishMultiThread();
+ }
+ return result;
+}
+
+
+// Map of all APIs to be intercepted by this layer
+static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
+ {"vkCreateInstance", (void*)CreateInstance},
+ {"vkDestroyInstance", (void*)DestroyInstance},
+ {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
+ {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
+ {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
+ {"vkCreateDevice", (void*)CreateDevice},
+ {"vkDestroyDevice", (void*)DestroyDevice},
+ {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
+ {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
+ {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
+ {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
+ {"vkGetDeviceQueue", (void*)GetDeviceQueue},
+ {"vkQueueSubmit", (void*)QueueSubmit},
+ {"vkQueueWaitIdle", (void*)QueueWaitIdle},
+ {"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
+ {"vkAllocateMemory", (void*)AllocateMemory},
+ {"vkFreeMemory", (void*)FreeMemory},
+ {"vkMapMemory", (void*)MapMemory},
+ {"vkUnmapMemory", (void*)UnmapMemory},
+ {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
+ {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
+ {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
+ {"vkBindBufferMemory", (void*)BindBufferMemory},
+ {"vkBindImageMemory", (void*)BindImageMemory},
+ {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
+ {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
+ {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
+ {"vkQueueBindSparse", (void*)QueueBindSparse},
+ {"vkCreateFence", (void*)CreateFence},
+ {"vkDestroyFence", (void*)DestroyFence},
+ {"vkResetFences", (void*)ResetFences},
+ {"vkGetFenceStatus", (void*)GetFenceStatus},
+ {"vkWaitForFences", (void*)WaitForFences},
+ {"vkCreateSemaphore", (void*)CreateSemaphore},
+ {"vkDestroySemaphore", (void*)DestroySemaphore},
+ {"vkCreateEvent", (void*)CreateEvent},
+ {"vkDestroyEvent", (void*)DestroyEvent},
+ {"vkGetEventStatus", (void*)GetEventStatus},
+ {"vkSetEvent", (void*)SetEvent},
+ {"vkResetEvent", (void*)ResetEvent},
+ {"vkCreateQueryPool", (void*)CreateQueryPool},
+ {"vkDestroyQueryPool", (void*)DestroyQueryPool},
+ {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
+ {"vkCreateBuffer", (void*)CreateBuffer},
+ {"vkDestroyBuffer", (void*)DestroyBuffer},
+ {"vkCreateBufferView", (void*)CreateBufferView},
+ {"vkDestroyBufferView", (void*)DestroyBufferView},
+ {"vkCreateImage", (void*)CreateImage},
+ {"vkDestroyImage", (void*)DestroyImage},
+ {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
+ {"vkCreateImageView", (void*)CreateImageView},
+ {"vkDestroyImageView", (void*)DestroyImageView},
+ {"vkCreateShaderModule", (void*)CreateShaderModule},
+ {"vkDestroyShaderModule", (void*)DestroyShaderModule},
+ {"vkCreatePipelineCache", (void*)CreatePipelineCache},
+ {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
+ {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
+ {"vkMergePipelineCaches", (void*)MergePipelineCaches},
+ {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
+ {"vkCreateComputePipelines", (void*)CreateComputePipelines},
+ {"vkDestroyPipeline", (void*)DestroyPipeline},
+ {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
+ {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
+ {"vkCreateSampler", (void*)CreateSampler},
+ {"vkDestroySampler", (void*)DestroySampler},
+ {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
+ {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
+ {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
+ {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
+ {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
+ {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
+ {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
+ {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
+ {"vkCreateFramebuffer", (void*)CreateFramebuffer},
+ {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
+ {"vkCreateRenderPass", (void*)CreateRenderPass},
+ {"vkDestroyRenderPass", (void*)DestroyRenderPass},
+ {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
+ {"vkCreateCommandPool", (void*)CreateCommandPool},
+ {"vkDestroyCommandPool", (void*)DestroyCommandPool},
+ {"vkResetCommandPool", (void*)ResetCommandPool},
+ {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
+ {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
+ {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
+ {"vkEndCommandBuffer", (void*)EndCommandBuffer},
+ {"vkResetCommandBuffer", (void*)ResetCommandBuffer},
+ {"vkCmdBindPipeline", (void*)CmdBindPipeline},
+ {"vkCmdSetViewport", (void*)CmdSetViewport},
+ {"vkCmdSetScissor", (void*)CmdSetScissor},
+ {"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
+ {"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
+ {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
+ {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
+ {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
+ {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
+ {"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
+ {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
+ {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
+ {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
+ {"vkCmdDraw", (void*)CmdDraw},
+ {"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
+ {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
+ {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
+ {"vkCmdDispatch", (void*)CmdDispatch},
+ {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
+ {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
+ {"vkCmdCopyImage", (void*)CmdCopyImage},
+ {"vkCmdBlitImage", (void*)CmdBlitImage},
+ {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
+ {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
+ {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
+ {"vkCmdFillBuffer", (void*)CmdFillBuffer},
+ {"vkCmdClearColorImage", (void*)CmdClearColorImage},
+ {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
+ {"vkCmdClearAttachments", (void*)CmdClearAttachments},
+ {"vkCmdResolveImage", (void*)CmdResolveImage},
+ {"vkCmdSetEvent", (void*)CmdSetEvent},
+ {"vkCmdResetEvent", (void*)CmdResetEvent},
+ {"vkCmdWaitEvents", (void*)CmdWaitEvents},
+ {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
+ {"vkCmdBeginQuery", (void*)CmdBeginQuery},
+ {"vkCmdEndQuery", (void*)CmdEndQuery},
+ {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
+ {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
+ {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
+ {"vkCmdPushConstants", (void*)CmdPushConstants},
+ {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
+ {"vkCmdNextSubpass", (void*)CmdNextSubpass},
+ {"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
+ {"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
+ {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
+ {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
+ {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
+ {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
+ {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
+ {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
+ {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
+ {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
+ {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
+ {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
+ {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
+ {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
+ {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
+ {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
+ {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ {"vkCreateMirSurfaceKHR", (void*)CreateMirSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ {"vkCreateMagmaSurfaceKHR", (void*)CreateMagmaSurfaceKHR},
+#endif
+ {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
+#endif
+ {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
+ {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
+#endif
+ {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
+ {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
+ {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
+ {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
+ {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
+ {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
+ {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
+ {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
+#endif
+ {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
+ {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
+ {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
+ {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
+ {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
+ {"vkGetMemoryFuchsiaHandleKHR", (void*)GetMemoryFuchsiaHandleKHR},
+ {"vkGetMemoryFuchsiaHandlePropertiesKHR", (void*)GetMemoryFuchsiaHandlePropertiesKHR},
+ {"vkImportSemaphoreFuchsiaHandleKHR", (void*)ImportSemaphoreFuchsiaHandleKHR},
+ {"vkGetSemaphoreFuchsiaHandleKHR", (void*)GetSemaphoreFuchsiaHandleKHR},
+ {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
+ {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
+ {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
+ {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
+ {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
+#endif
+ {"vkGetDeviceGroupPeerMemoryFeaturesKHX", (void*)GetDeviceGroupPeerMemoryFeaturesKHX},
+ {"vkBindBufferMemory2KHX", (void*)BindBufferMemory2KHX},
+ {"vkBindImageMemory2KHX", (void*)BindImageMemory2KHX},
+ {"vkCmdSetDeviceMaskKHX", (void*)CmdSetDeviceMaskKHX},
+ {"vkGetDeviceGroupPresentCapabilitiesKHX", (void*)GetDeviceGroupPresentCapabilitiesKHX},
+ {"vkGetDeviceGroupSurfacePresentModesKHX", (void*)GetDeviceGroupSurfacePresentModesKHX},
+ {"vkAcquireNextImage2KHX", (void*)AcquireNextImage2KHX},
+ {"vkCmdDispatchBaseKHX", (void*)CmdDispatchBaseKHX},
+ {"vkGetPhysicalDevicePresentRectanglesKHX", (void*)GetPhysicalDevicePresentRectanglesKHX},
+#ifdef VK_USE_PLATFORM_VI_NN
+ {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
+#endif
+ {"vkEnumeratePhysicalDeviceGroupsKHX", (void*)EnumeratePhysicalDeviceGroupsKHX},
+ {"vkCmdProcessCommandsNVX", (void*)CmdProcessCommandsNVX},
+ {"vkCmdReserveSpaceForCommandsNVX", (void*)CmdReserveSpaceForCommandsNVX},
+ {"vkCreateIndirectCommandsLayoutNVX", (void*)CreateIndirectCommandsLayoutNVX},
+ {"vkDestroyIndirectCommandsLayoutNVX", (void*)DestroyIndirectCommandsLayoutNVX},
+ {"vkCreateObjectTableNVX", (void*)CreateObjectTableNVX},
+ {"vkDestroyObjectTableNVX", (void*)DestroyObjectTableNVX},
+ {"vkRegisterObjectsNVX", (void*)RegisterObjectsNVX},
+ {"vkUnregisterObjectsNVX", (void*)UnregisterObjectsNVX},
+ {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
+ {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
+#endif
+ {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
+ {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
+ {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
+ {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
+ {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
+ {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
+ {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
+ {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
+ {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
+#endif
+ {"vkExportDeviceMemoryMAGMA", (void*)ExportDeviceMemoryMAGMA},
+ {"vkImportDeviceMemoryMAGMA", (void*)ImportDeviceMemoryMAGMA},
+};
+
+
+} // namespace threading
+
+#endif
diff --git a/build-fuchsia/generated/include/unique_objects_wrappers.h b/build-fuchsia/generated/include/unique_objects_wrappers.h
new file mode 100644
index 0000000..90af30d
--- /dev/null
+++ b/build-fuchsia/generated/include/unique_objects_wrappers.h
@@ -0,0 +1,4036 @@
+/*
+** Copyright (c) 2015-2017 The Khronos Group 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.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+namespace unique_objects {
+
+// Unique Objects pNext extension handling function
+void *CreateUnwrappedExtensionStructs(layer_data *dev_data, const void *pNext) {
+ void *cur_pnext = const_cast<void *>(pNext);
+ void *head_pnext = NULL;
+ void *prev_ext_struct = NULL;
+ void *cur_ext_struct = NULL;
+
+ while (cur_pnext != NULL) {
+ GenericHeader *header = reinterpret_cast<GenericHeader *>(cur_pnext);
+
+ switch (header->sType) {
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ safe_VkD3D12FenceSubmitInfoKHR *safe_struct = new safe_VkD3D12FenceSubmitInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX: {
+ safe_VkDeviceGroupSubmitInfoKHX *safe_struct = new safe_VkDeviceGroupSubmitInfoKHX;
+ safe_struct->initialize(reinterpret_cast<const VkDeviceGroupSubmitInfoKHX *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *safe_struct = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(cur_pnext));
+ if (safe_struct->pAcquireSyncs) {
+ for (uint32_t index0 = 0; index0 < safe_struct->acquireCount; ++index0) {
+ safe_struct->pAcquireSyncs[index0] = Unwrap(dev_data, safe_struct->pAcquireSyncs[index0]);
+ }
+ }
+ if (safe_struct->pReleaseSyncs) {
+ for (uint32_t index0 = 0; index0 < safe_struct->releaseCount; ++index0) {
+ safe_struct->pReleaseSyncs[index0] = Unwrap(dev_data, safe_struct->pReleaseSyncs[index0]);
+ }
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ safe_VkWin32KeyedMutexAcquireReleaseInfoNV *safe_struct = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(cur_pnext));
+ if (safe_struct->pAcquireSyncs) {
+ for (uint32_t index0 = 0; index0 < safe_struct->acquireCount; ++index0) {
+ safe_struct->pAcquireSyncs[index0] = Unwrap(dev_data, safe_struct->pAcquireSyncs[index0]);
+ }
+ }
+ if (safe_struct->pReleaseSyncs) {
+ for (uint32_t index0 = 0; index0 < safe_struct->releaseCount; ++index0) {
+ safe_struct->pReleaseSyncs[index0] = Unwrap(dev_data, safe_struct->pReleaseSyncs[index0]);
+ }
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ safe_VkDedicatedAllocationMemoryAllocateInfoNV *safe_struct = new safe_VkDedicatedAllocationMemoryAllocateInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(cur_pnext));
+ if (safe_struct->image) {
+ safe_struct->image = Unwrap(dev_data, safe_struct->image);
+ }
+ if (safe_struct->buffer) {
+ safe_struct->buffer = Unwrap(dev_data, safe_struct->buffer);
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: {
+ safe_VkExportMemoryAllocateInfoKHR *safe_struct = new safe_VkExportMemoryAllocateInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkExportMemoryAllocateInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ safe_VkExportMemoryAllocateInfoNV *safe_struct = new safe_VkExportMemoryAllocateInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ safe_VkExportMemoryWin32HandleInfoKHR *safe_struct = new safe_VkExportMemoryWin32HandleInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ safe_VkExportMemoryWin32HandleInfoNV *safe_struct = new safe_VkExportMemoryWin32HandleInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ safe_VkImportMemoryFdInfoKHR *safe_struct = new safe_VkImportMemoryFdInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkImportMemoryFdInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FUCHSIA_HANDLE_INFO_KHR: {
+ safe_VkImportMemoryFuchsiaHandleInfoKHR *safe_struct = new safe_VkImportMemoryFuchsiaHandleInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkImportMemoryFuchsiaHandleInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ safe_VkImportMemoryWin32HandleInfoKHR *safe_struct = new safe_VkImportMemoryWin32HandleInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ safe_VkImportMemoryWin32HandleInfoNV *safe_struct = new safe_VkImportMemoryWin32HandleInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX: {
+ safe_VkMemoryAllocateFlagsInfoKHX *safe_struct = new safe_VkMemoryAllocateFlagsInfoKHX;
+ safe_struct->initialize(reinterpret_cast<const VkMemoryAllocateFlagsInfoKHX *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: {
+ safe_VkMemoryDedicatedAllocateInfoKHR *safe_struct = new safe_VkMemoryDedicatedAllocateInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkMemoryDedicatedAllocateInfoKHR *>(cur_pnext));
+ if (safe_struct->image) {
+ safe_struct->image = Unwrap(dev_data, safe_struct->image);
+ }
+ if (safe_struct->buffer) {
+ safe_struct->buffer = Unwrap(dev_data, safe_struct->buffer);
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ safe_VkDedicatedAllocationImageCreateInfoNV *safe_struct = new safe_VkDedicatedAllocationImageCreateInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: {
+ safe_VkExternalMemoryImageCreateInfoKHR *safe_struct = new safe_VkExternalMemoryImageCreateInfoKHR;
+ safe_struct->initialize(reinterpret_cast<const VkExternalMemoryImageCreateInfoKHR *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ safe_VkExternalMemoryImageCreateInfoNV *safe_struct = new safe_VkExternalMemoryImageCreateInfoNV;
+ safe_struct->initialize(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(cur_pnext));
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX: {
+ safe_VkImageSwapchainCreateInfoKHX *safe_struct = new safe_VkImageSwapchainCreateInfoKHX;
+ safe_struct->initialize(reinterpret_cast<const VkImageSwapchainCreateInfoKHX *>(cur_pnext));
+ if (safe_struct->swapchain) {
+ safe_struct->swapchain = Unwrap(dev_data, safe_struct->swapchain);
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX: {
+ safe_VkBindImageMemorySwapchainInfoKHX *safe_struct = new safe_VkBindImageMemorySwapchainInfoKHX;
+ safe_struct->initialize(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHX *>(cur_pnext));
+ if (safe_struct->swapchain) {
+ safe_struct->swapchain = Unwrap(dev_data, safe_struct->swapchain);
+ }
+ cur_ext_struct = reinterpret_cast<void *>(safe_struct);
+ } break;
+
+ default:
+ break;
+ }
+
+ // Save pointer to the first structure in the pNext chain
+ head_pnext = (head_pnext ? head_pnext : cur_ext_struct);
+
+ // For any extension structure but the first, link the last struct's pNext to the current ext struct
+ if (prev_ext_struct) {
+ (reinterpret_cast<GenericHeader *>(prev_ext_struct))->pNext = cur_ext_struct;
+ }
+ prev_ext_struct = cur_ext_struct;
+
+ // Process the next structure in the chain
+ cur_pnext = const_cast<void *>(header->pNext);
+ }
+ return head_pnext;
+}
+
+// Free a pNext extension chain
+void FreeUnwrappedExtensionStructs(void *head) {
+ void * curr_ptr = head;
+ while (curr_ptr) {
+ GenericHeader *header = reinterpret_cast<GenericHeader *>(curr_ptr);
+ void *temp = curr_ptr;
+ curr_ptr = header->pNext;
+ free(temp);
+ }
+}
+
+
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+
+// Declare only
+VKAPI_ATTR void VKAPI_CALL DestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+
+// Declare only
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+
+// Declare only
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
+ VkDevice device,
+ const char* pName);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+// Declare only
+VKAPI_ATTR void VKAPI_CALL DestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
+ safe_VkSubmitInfo *local_pSubmits = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pSubmits) {
+ local_pSubmits = new safe_VkSubmitInfo[submitCount];
+ for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
+ local_pSubmits[index0].initialize(&pSubmits[index0]);
+ local_pSubmits[index0].pNext = CreateUnwrappedExtensionStructs(dev_data, local_pSubmits[index0].pNext);
+ if (local_pSubmits[index0].pWaitSemaphores) {
+ for (uint32_t index1 = 0; index1 < local_pSubmits[index0].waitSemaphoreCount; ++index1) {
+ local_pSubmits[index0].pWaitSemaphores[index1] = Unwrap(dev_data, local_pSubmits[index0].pWaitSemaphores[index1]);
+ }
+ }
+ if (local_pSubmits[index0].pSignalSemaphores) {
+ for (uint32_t index1 = 0; index1 < local_pSubmits[index0].signalSemaphoreCount; ++index1) {
+ local_pSubmits[index0].pSignalSemaphores[index1] = Unwrap(dev_data, local_pSubmits[index0].pSignalSemaphores[index1]);
+ }
+ }
+ }
+ }
+ fence = Unwrap(dev_data, fence);
+ }
+ VkResult result = dev_data->dispatch_table.QueueSubmit(queue, submitCount, (const VkSubmitInfo*)local_pSubmits, fence);
+ if (local_pSubmits) {
+ for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
+ FreeUnwrappedExtensionStructs(const_cast<void *>(local_pSubmits[index0].pNext));
+ }
+ delete[] local_pSubmits;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMemoryAllocateInfo *local_pAllocateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pAllocateInfo) {
+ local_pAllocateInfo = new safe_VkMemoryAllocateInfo(pAllocateInfo);
+ local_pAllocateInfo->pNext = CreateUnwrappedExtensionStructs(dev_data, local_pAllocateInfo->pNext);
+ }
+ }
+ VkResult result = dev_data->dispatch_table.AllocateMemory(device, (const VkMemoryAllocateInfo*)local_pAllocateInfo, pAllocator, pMemory);
+ if (local_pAllocateInfo) {
+ FreeUnwrappedExtensionStructs(const_cast<void *>(local_pAllocateInfo->pNext));
+ delete local_pAllocateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pMemory = WrapNew(dev_data, *pMemory);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL FreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t memory_id = reinterpret_cast<uint64_t &>(memory);
+ memory = (VkDeviceMemory)dev_data->unique_id_mapping[memory_id];
+ dev_data->unique_id_mapping.erase(memory_id);
+ lock.unlock();
+ dev_data->dispatch_table.FreeMemory(device, memory, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ memory = Unwrap(dev_data, memory);
+ }
+ VkResult result = dev_data->dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
+
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL UnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ memory = Unwrap(dev_data, memory);
+ }
+ dev_data->dispatch_table.UnmapMemory(device, memory);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMappedMemoryRange *local_pMemoryRanges = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pMemoryRanges) {
+ local_pMemoryRanges = new safe_VkMappedMemoryRange[memoryRangeCount];
+ for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
+ local_pMemoryRanges[index0].initialize(&pMemoryRanges[index0]);
+ if (pMemoryRanges[index0].memory) {
+ local_pMemoryRanges[index0].memory = Unwrap(dev_data, pMemoryRanges[index0].memory);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.FlushMappedMemoryRanges(device, memoryRangeCount, (const VkMappedMemoryRange*)local_pMemoryRanges);
+ if (local_pMemoryRanges) {
+ delete[] local_pMemoryRanges;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMappedMemoryRange *local_pMemoryRanges = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pMemoryRanges) {
+ local_pMemoryRanges = new safe_VkMappedMemoryRange[memoryRangeCount];
+ for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
+ local_pMemoryRanges[index0].initialize(&pMemoryRanges[index0]);
+ if (pMemoryRanges[index0].memory) {
+ local_pMemoryRanges[index0].memory = Unwrap(dev_data, pMemoryRanges[index0].memory);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, (const VkMappedMemoryRange*)local_pMemoryRanges);
+ if (local_pMemoryRanges) {
+ delete[] local_pMemoryRanges;
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ memory = Unwrap(dev_data, memory);
+ }
+ dev_data->dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ memory = Unwrap(dev_data, memory);
+ }
+ VkResult result = dev_data->dispatch_table.BindBufferMemory(device, buffer, memory, memoryOffset);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ memory = Unwrap(dev_data, memory);
+ }
+ VkResult result = dev_data->dispatch_table.BindImageMemory(device, image, memory, memoryOffset);
+
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ }
+ dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ }
+ dev_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ }
+ dev_data->dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
+ safe_VkBindSparseInfo *local_pBindInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBindInfo) {
+ local_pBindInfo = new safe_VkBindSparseInfo[bindInfoCount];
+ for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
+ local_pBindInfo[index0].initialize(&pBindInfo[index0]);
+ if (local_pBindInfo[index0].pWaitSemaphores) {
+ for (uint32_t index1 = 0; index1 < local_pBindInfo[index0].waitSemaphoreCount; ++index1) {
+ local_pBindInfo[index0].pWaitSemaphores[index1] = Unwrap(dev_data, local_pBindInfo[index0].pWaitSemaphores[index1]);
+ }
+ }
+ if (local_pBindInfo[index0].pBufferBinds) {
+ for (uint32_t index1 = 0; index1 < local_pBindInfo[index0].bufferBindCount; ++index1) {
+ if (pBindInfo[index0].pBufferBinds[index1].buffer) {
+ local_pBindInfo[index0].pBufferBinds[index1].buffer = Unwrap(dev_data, pBindInfo[index0].pBufferBinds[index1].buffer);
+ }
+ if (local_pBindInfo[index0].pBufferBinds[index1].pBinds) {
+ for (uint32_t index2 = 0; index2 < local_pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) {
+ if (pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory) {
+ local_pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory = Unwrap(dev_data, pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory);
+ }
+ }
+ }
+ }
+ }
+ if (local_pBindInfo[index0].pImageOpaqueBinds) {
+ for (uint32_t index1 = 0; index1 < local_pBindInfo[index0].imageOpaqueBindCount; ++index1) {
+ if (pBindInfo[index0].pImageOpaqueBinds[index1].image) {
+ local_pBindInfo[index0].pImageOpaqueBinds[index1].image = Unwrap(dev_data, pBindInfo[index0].pImageOpaqueBinds[index1].image);
+ }
+ if (local_pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) {
+ for (uint32_t index2 = 0; index2 < local_pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) {
+ if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory) {
+ local_pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory = Unwrap(dev_data, pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory);
+ }
+ }
+ }
+ }
+ }
+ if (local_pBindInfo[index0].pImageBinds) {
+ for (uint32_t index1 = 0; index1 < local_pBindInfo[index0].imageBindCount; ++index1) {
+ if (pBindInfo[index0].pImageBinds[index1].image) {
+ local_pBindInfo[index0].pImageBinds[index1].image = Unwrap(dev_data, pBindInfo[index0].pImageBinds[index1].image);
+ }
+ if (local_pBindInfo[index0].pImageBinds[index1].pBinds) {
+ for (uint32_t index2 = 0; index2 < local_pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) {
+ if (pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory) {
+ local_pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory = Unwrap(dev_data, pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory);
+ }
+ }
+ }
+ }
+ }
+ if (local_pBindInfo[index0].pSignalSemaphores) {
+ for (uint32_t index1 = 0; index1 < local_pBindInfo[index0].signalSemaphoreCount; ++index1) {
+ local_pBindInfo[index0].pSignalSemaphores[index1] = Unwrap(dev_data, local_pBindInfo[index0].pSignalSemaphores[index1]);
+ }
+ }
+ }
+ }
+ fence = Unwrap(dev_data, fence);
+ }
+ VkResult result = dev_data->dispatch_table.QueueBindSparse(queue, bindInfoCount, (const VkBindSparseInfo*)local_pBindInfo, fence);
+ if (local_pBindInfo) {
+ delete[] local_pBindInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pFence = WrapNew(dev_data, *pFence);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t fence_id = reinterpret_cast<uint64_t &>(fence);
+ fence = (VkFence)dev_data->unique_id_mapping[fence_id];
+ dev_data->unique_id_mapping.erase(fence_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyFence(device, fence, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkFence *local_pFences = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pFences) {
+ local_pFences = new VkFence[fenceCount];
+ for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
+ local_pFences[index0] = Unwrap(dev_data, pFences[index0]);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ResetFences(device, fenceCount, (const VkFence*)local_pFences);
+ if (local_pFences)
+ delete[] local_pFences;
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
+ VkDevice device,
+ VkFence fence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ fence = Unwrap(dev_data, fence);
+ }
+ VkResult result = dev_data->dispatch_table.GetFenceStatus(device, fence);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkFence *local_pFences = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pFences) {
+ local_pFences = new VkFence[fenceCount];
+ for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
+ local_pFences[index0] = Unwrap(dev_data, pFences[index0]);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.WaitForFences(device, fenceCount, (const VkFence*)local_pFences, waitAll, timeout);
+ if (local_pFences)
+ delete[] local_pFences;
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSemaphore = WrapNew(dev_data, *pSemaphore);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t semaphore_id = reinterpret_cast<uint64_t &>(semaphore);
+ semaphore = (VkSemaphore)dev_data->unique_id_mapping[semaphore_id];
+ dev_data->unique_id_mapping.erase(semaphore_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroySemaphore(device, semaphore, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pEvent = WrapNew(dev_data, *pEvent);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t event_id = reinterpret_cast<uint64_t &>(event);
+ event = (VkEvent)dev_data->unique_id_mapping[event_id];
+ dev_data->unique_id_mapping.erase(event_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyEvent(device, event, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
+ VkDevice device,
+ VkEvent event)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ event = Unwrap(dev_data, event);
+ }
+ VkResult result = dev_data->dispatch_table.GetEventStatus(device, event);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ event = Unwrap(dev_data, event);
+ }
+ VkResult result = dev_data->dispatch_table.SetEvent(device, event);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ event = Unwrap(dev_data, event);
+ }
+ VkResult result = dev_data->dispatch_table.ResetEvent(device, event);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pQueryPool = WrapNew(dev_data, *pQueryPool);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t queryPool_id = reinterpret_cast<uint64_t &>(queryPool);
+ queryPool = (VkQueryPool)dev_data->unique_id_mapping[queryPool_id];
+ dev_data->unique_id_mapping.erase(queryPool_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyQueryPool(device, queryPool, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ }
+ VkResult result = dev_data->dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pBuffer = WrapNew(dev_data, *pBuffer);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t buffer_id = reinterpret_cast<uint64_t &>(buffer);
+ buffer = (VkBuffer)dev_data->unique_id_mapping[buffer_id];
+ dev_data->unique_id_mapping.erase(buffer_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyBuffer(device, buffer, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkBufferViewCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkBufferViewCreateInfo(pCreateInfo);
+ if (pCreateInfo->buffer) {
+ local_pCreateInfo->buffer = Unwrap(dev_data, pCreateInfo->buffer);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateBufferView(device, (const VkBufferViewCreateInfo*)local_pCreateInfo, pAllocator, pView);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pView = WrapNew(dev_data, *pView);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t bufferView_id = reinterpret_cast<uint64_t &>(bufferView);
+ bufferView = (VkBufferView)dev_data->unique_id_mapping[bufferView_id];
+ dev_data->unique_id_mapping.erase(bufferView_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyBufferView(device, bufferView, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImageCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkImageCreateInfo(pCreateInfo);
+ local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(dev_data, local_pCreateInfo->pNext);
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateImage(device, (const VkImageCreateInfo*)local_pCreateInfo, pAllocator, pImage);
+ if (local_pCreateInfo) {
+ FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pImage = WrapNew(dev_data, *pImage);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t image_id = reinterpret_cast<uint64_t &>(image);
+ image = (VkImage)dev_data->unique_id_mapping[image_id];
+ dev_data->unique_id_mapping.erase(image_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyImage(device, image, pAllocator);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ }
+ dev_data->dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImageViewCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkImageViewCreateInfo(pCreateInfo);
+ if (pCreateInfo->image) {
+ local_pCreateInfo->image = Unwrap(dev_data, pCreateInfo->image);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateImageView(device, (const VkImageViewCreateInfo*)local_pCreateInfo, pAllocator, pView);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pView = WrapNew(dev_data, *pView);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t imageView_id = reinterpret_cast<uint64_t &>(imageView);
+ imageView = (VkImageView)dev_data->unique_id_mapping[imageView_id];
+ dev_data->unique_id_mapping.erase(imageView_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyImageView(device, imageView, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pShaderModule = WrapNew(dev_data, *pShaderModule);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t shaderModule_id = reinterpret_cast<uint64_t &>(shaderModule);
+ shaderModule = (VkShaderModule)dev_data->unique_id_mapping[shaderModule_id];
+ dev_data->unique_id_mapping.erase(shaderModule_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pPipelineCache = WrapNew(dev_data, *pPipelineCache);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t pipelineCache_id = reinterpret_cast<uint64_t &>(pipelineCache);
+ pipelineCache = (VkPipelineCache)dev_data->unique_id_mapping[pipelineCache_id];
+ dev_data->unique_id_mapping.erase(pipelineCache_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ pipelineCache = Unwrap(dev_data, pipelineCache);
+ }
+ VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkPipelineCache *local_pSrcCaches = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ dstCache = Unwrap(dev_data, dstCache);
+ if (pSrcCaches) {
+ local_pSrcCaches = new VkPipelineCache[srcCacheCount];
+ for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) {
+ local_pSrcCaches[index0] = Unwrap(dev_data, pSrcCaches[index0]);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, (const VkPipelineCache*)local_pSrcCaches);
+ if (local_pSrcCaches)
+ delete[] local_pSrcCaches;
+ return result;
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t pipeline_id = reinterpret_cast<uint64_t &>(pipeline);
+ pipeline = (VkPipeline)dev_data->unique_id_mapping[pipeline_id];
+ dev_data->unique_id_mapping.erase(pipeline_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyPipeline(device, pipeline, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkPipelineLayoutCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkPipelineLayoutCreateInfo(pCreateInfo);
+ if (local_pCreateInfo->pSetLayouts) {
+ for (uint32_t index1 = 0; index1 < local_pCreateInfo->setLayoutCount; ++index1) {
+ local_pCreateInfo->pSetLayouts[index1] = Unwrap(dev_data, local_pCreateInfo->pSetLayouts[index1]);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreatePipelineLayout(device, (const VkPipelineLayoutCreateInfo*)local_pCreateInfo, pAllocator, pPipelineLayout);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pPipelineLayout = WrapNew(dev_data, *pPipelineLayout);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t pipelineLayout_id = reinterpret_cast<uint64_t &>(pipelineLayout);
+ pipelineLayout = (VkPipelineLayout)dev_data->unique_id_mapping[pipelineLayout_id];
+ dev_data->unique_id_mapping.erase(pipelineLayout_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSampler = WrapNew(dev_data, *pSampler);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t sampler_id = reinterpret_cast<uint64_t &>(sampler);
+ sampler = (VkSampler)dev_data->unique_id_mapping[sampler_id];
+ dev_data->unique_id_mapping.erase(sampler_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroySampler(device, sampler, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkDescriptorSetLayoutCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
+ if (local_pCreateInfo->pBindings) {
+ for (uint32_t index1 = 0; index1 < local_pCreateInfo->bindingCount; ++index1) {
+ if (local_pCreateInfo->pBindings[index1].pImmutableSamplers) {
+ for (uint32_t index2 = 0; index2 < local_pCreateInfo->pBindings[index1].descriptorCount; ++index2) {
+ local_pCreateInfo->pBindings[index1].pImmutableSamplers[index2] = Unwrap(dev_data, local_pCreateInfo->pBindings[index1].pImmutableSamplers[index2]);
+ }
+ }
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateDescriptorSetLayout(device, (const VkDescriptorSetLayoutCreateInfo*)local_pCreateInfo, pAllocator, pSetLayout);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSetLayout = WrapNew(dev_data, *pSetLayout);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t descriptorSetLayout_id = reinterpret_cast<uint64_t &>(descriptorSetLayout);
+ descriptorSetLayout = (VkDescriptorSetLayout)dev_data->unique_id_mapping[descriptorSetLayout_id];
+ dev_data->unique_id_mapping.erase(descriptorSetLayout_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pDescriptorPool = WrapNew(dev_data, *pDescriptorPool);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t descriptorPool_id = reinterpret_cast<uint64_t &>(descriptorPool);
+ descriptorPool = (VkDescriptorPool)dev_data->unique_id_mapping[descriptorPool_id];
+ dev_data->unique_id_mapping.erase(descriptorPool_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ descriptorPool = Unwrap(dev_data, descriptorPool);
+ }
+ VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkDescriptorSetAllocateInfo *local_pAllocateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pAllocateInfo) {
+ local_pAllocateInfo = new safe_VkDescriptorSetAllocateInfo(pAllocateInfo);
+ if (pAllocateInfo->descriptorPool) {
+ local_pAllocateInfo->descriptorPool = Unwrap(dev_data, pAllocateInfo->descriptorPool);
+ }
+ if (local_pAllocateInfo->pSetLayouts) {
+ for (uint32_t index1 = 0; index1 < local_pAllocateInfo->descriptorSetCount; ++index1) {
+ local_pAllocateInfo->pSetLayouts[index1] = Unwrap(dev_data, local_pAllocateInfo->pSetLayouts[index1]);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.AllocateDescriptorSets(device, (const VkDescriptorSetAllocateInfo*)local_pAllocateInfo, pDescriptorSets);
+ if (local_pAllocateInfo) {
+ delete local_pAllocateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ for (uint32_t index0 = 0; index0 < pAllocateInfo->descriptorSetCount; index0++) {
+ pDescriptorSets[index0] = WrapNew(dev_data, pDescriptorSets[index0]);
+ }
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkDescriptorSet *local_pDescriptorSets = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ descriptorPool = Unwrap(dev_data, descriptorPool);
+ if (pDescriptorSets) {
+ local_pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+ for (uint32_t index0 = 0; index0 < descriptorSetCount; ++index0) {
+ local_pDescriptorSets[index0] = Unwrap(dev_data, pDescriptorSets[index0]);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, (const VkDescriptorSet*)local_pDescriptorSets);
+ if (local_pDescriptorSets)
+ delete[] local_pDescriptorSets;
+ if ((VK_SUCCESS == result) && (pDescriptorSets)) {
+ std::unique_lock<std::mutex> lock(global_lock);
+ for (uint32_t index0 = 0; index0 < descriptorSetCount; index0++) {
+ VkDescriptorSet handle = pDescriptorSets[index0];
+ uint64_t unique_id = reinterpret_cast<uint64_t &>(handle);
+ dev_data->unique_id_mapping.erase(unique_id);
+ }
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkWriteDescriptorSet *local_pDescriptorWrites = NULL;
+ safe_VkCopyDescriptorSet *local_pDescriptorCopies = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pDescriptorWrites) {
+ local_pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+ for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
+ local_pDescriptorWrites[index0].initialize(&pDescriptorWrites[index0]);
+ if (pDescriptorWrites[index0].dstSet) {
+ local_pDescriptorWrites[index0].dstSet = Unwrap(dev_data, pDescriptorWrites[index0].dstSet);
+ }
+ if (local_pDescriptorWrites[index0].pImageInfo) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ if (pDescriptorWrites[index0].pImageInfo[index1].sampler) {
+ local_pDescriptorWrites[index0].pImageInfo[index1].sampler = Unwrap(dev_data, pDescriptorWrites[index0].pImageInfo[index1].sampler);
+ }
+ if (pDescriptorWrites[index0].pImageInfo[index1].imageView) {
+ local_pDescriptorWrites[index0].pImageInfo[index1].imageView = Unwrap(dev_data, pDescriptorWrites[index0].pImageInfo[index1].imageView);
+ }
+ }
+ }
+ if (local_pDescriptorWrites[index0].pBufferInfo) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ if (pDescriptorWrites[index0].pBufferInfo[index1].buffer) {
+ local_pDescriptorWrites[index0].pBufferInfo[index1].buffer = Unwrap(dev_data, pDescriptorWrites[index0].pBufferInfo[index1].buffer);
+ }
+ }
+ }
+ if (local_pDescriptorWrites[index0].pTexelBufferView) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ local_pDescriptorWrites[index0].pTexelBufferView[index1] = Unwrap(dev_data, local_pDescriptorWrites[index0].pTexelBufferView[index1]);
+ }
+ }
+ }
+ }
+ if (pDescriptorCopies) {
+ local_pDescriptorCopies = new safe_VkCopyDescriptorSet[descriptorCopyCount];
+ for (uint32_t index0 = 0; index0 < descriptorCopyCount; ++index0) {
+ local_pDescriptorCopies[index0].initialize(&pDescriptorCopies[index0]);
+ if (pDescriptorCopies[index0].srcSet) {
+ local_pDescriptorCopies[index0].srcSet = Unwrap(dev_data, pDescriptorCopies[index0].srcSet);
+ }
+ if (pDescriptorCopies[index0].dstSet) {
+ local_pDescriptorCopies[index0].dstSet = Unwrap(dev_data, pDescriptorCopies[index0].dstSet);
+ }
+ }
+ }
+ }
+ dev_data->dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, (const VkWriteDescriptorSet*)local_pDescriptorWrites, descriptorCopyCount, (const VkCopyDescriptorSet*)local_pDescriptorCopies);
+ if (local_pDescriptorWrites) {
+ delete[] local_pDescriptorWrites;
+ }
+ if (local_pDescriptorCopies) {
+ delete[] local_pDescriptorCopies;
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkFramebufferCreateInfo *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkFramebufferCreateInfo(pCreateInfo);
+ if (pCreateInfo->renderPass) {
+ local_pCreateInfo->renderPass = Unwrap(dev_data, pCreateInfo->renderPass);
+ }
+ if (local_pCreateInfo->pAttachments) {
+ for (uint32_t index1 = 0; index1 < local_pCreateInfo->attachmentCount; ++index1) {
+ local_pCreateInfo->pAttachments[index1] = Unwrap(dev_data, local_pCreateInfo->pAttachments[index1]);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateFramebuffer(device, (const VkFramebufferCreateInfo*)local_pCreateInfo, pAllocator, pFramebuffer);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pFramebuffer = WrapNew(dev_data, *pFramebuffer);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t framebuffer_id = reinterpret_cast<uint64_t &>(framebuffer);
+ framebuffer = (VkFramebuffer)dev_data->unique_id_mapping[framebuffer_id];
+ dev_data->unique_id_mapping.erase(framebuffer_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pRenderPass = WrapNew(dev_data, *pRenderPass);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t renderPass_id = reinterpret_cast<uint64_t &>(renderPass);
+ renderPass = (VkRenderPass)dev_data->unique_id_mapping[renderPass_id];
+ dev_data->unique_id_mapping.erase(renderPass_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ renderPass = Unwrap(dev_data, renderPass);
+ }
+ dev_data->dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pCommandPool = WrapNew(dev_data, *pCommandPool);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t commandPool_id = reinterpret_cast<uint64_t &>(commandPool);
+ commandPool = (VkCommandPool)dev_data->unique_id_mapping[commandPool_id];
+ dev_data->unique_id_mapping.erase(commandPool_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyCommandPool(device, commandPool, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ commandPool = Unwrap(dev_data, commandPool);
+ }
+ VkResult result = dev_data->dispatch_table.ResetCommandPool(device, commandPool, flags);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkCommandBufferAllocateInfo *local_pAllocateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pAllocateInfo) {
+ local_pAllocateInfo = new safe_VkCommandBufferAllocateInfo(pAllocateInfo);
+ if (pAllocateInfo->commandPool) {
+ local_pAllocateInfo->commandPool = Unwrap(dev_data, pAllocateInfo->commandPool);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, (const VkCommandBufferAllocateInfo*)local_pAllocateInfo, pCommandBuffers);
+ if (local_pAllocateInfo) {
+ delete local_pAllocateInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ commandPool = Unwrap(dev_data, commandPool);
+ }
+ dev_data->dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkCommandBufferBeginInfo *local_pBeginInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBeginInfo) {
+ local_pBeginInfo = new safe_VkCommandBufferBeginInfo(pBeginInfo);
+ if (local_pBeginInfo->pInheritanceInfo) {
+ if (pBeginInfo->pInheritanceInfo->renderPass) {
+ local_pBeginInfo->pInheritanceInfo->renderPass = Unwrap(dev_data, pBeginInfo->pInheritanceInfo->renderPass);
+ }
+ if (pBeginInfo->pInheritanceInfo->framebuffer) {
+ local_pBeginInfo->pInheritanceInfo->framebuffer = Unwrap(dev_data, pBeginInfo->pInheritanceInfo->framebuffer);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.BeginCommandBuffer(commandBuffer, (const VkCommandBufferBeginInfo*)local_pBeginInfo);
+ if (local_pBeginInfo) {
+ delete local_pBeginInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ pipeline = Unwrap(dev_data, pipeline);
+ }
+ dev_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ VkDescriptorSet *local_pDescriptorSets = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ layout = Unwrap(dev_data, layout);
+ if (pDescriptorSets) {
+ local_pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+ for (uint32_t index0 = 0; index0 < descriptorSetCount; ++index0) {
+ local_pDescriptorSets[index0] = Unwrap(dev_data, pDescriptorSets[index0]);
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, (const VkDescriptorSet*)local_pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ if (local_pDescriptorSets)
+ delete[] local_pDescriptorSets;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ }
+ dev_data->dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ VkBuffer *local_pBuffers = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBuffers) {
+ local_pBuffers = new VkBuffer[bindingCount];
+ for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
+ local_pBuffers[index0] = Unwrap(dev_data, pBuffers[index0]);
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, (const VkBuffer*)local_pBuffers, pOffsets);
+ if (local_pBuffers)
+ delete[] local_pBuffers;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ }
+ dev_data->dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ }
+ dev_data->dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ }
+ dev_data->dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcBuffer = Unwrap(dev_data, srcBuffer);
+ dstBuffer = Unwrap(dev_data, dstBuffer);
+ }
+ dev_data->dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcImage = Unwrap(dev_data, srcImage);
+ dstImage = Unwrap(dev_data, dstImage);
+ }
+ dev_data->dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcImage = Unwrap(dev_data, srcImage);
+ dstImage = Unwrap(dev_data, dstImage);
+ }
+ dev_data->dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcBuffer = Unwrap(dev_data, srcBuffer);
+ dstImage = Unwrap(dev_data, dstImage);
+ }
+ dev_data->dispatch_table.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcImage = Unwrap(dev_data, srcImage);
+ dstBuffer = Unwrap(dev_data, dstBuffer);
+ }
+ dev_data->dispatch_table.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ dstBuffer = Unwrap(dev_data, dstBuffer);
+ }
+ dev_data->dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ dstBuffer = Unwrap(dev_data, dstBuffer);
+ }
+ dev_data->dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ }
+ dev_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ image = Unwrap(dev_data, image);
+ }
+ dev_data->dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ srcImage = Unwrap(dev_data, srcImage);
+ dstImage = Unwrap(dev_data, dstImage);
+ }
+ dev_data->dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ event = Unwrap(dev_data, event);
+ }
+ dev_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ event = Unwrap(dev_data, event);
+ }
+ dev_data->dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ VkEvent *local_pEvents = NULL;
+ safe_VkBufferMemoryBarrier *local_pBufferMemoryBarriers = NULL;
+ safe_VkImageMemoryBarrier *local_pImageMemoryBarriers = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pEvents) {
+ local_pEvents = new VkEvent[eventCount];
+ for (uint32_t index0 = 0; index0 < eventCount; ++index0) {
+ local_pEvents[index0] = Unwrap(dev_data, pEvents[index0]);
+ }
+ }
+ if (pBufferMemoryBarriers) {
+ local_pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier[bufferMemoryBarrierCount];
+ for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
+ local_pBufferMemoryBarriers[index0].initialize(&pBufferMemoryBarriers[index0]);
+ if (pBufferMemoryBarriers[index0].buffer) {
+ local_pBufferMemoryBarriers[index0].buffer = Unwrap(dev_data, pBufferMemoryBarriers[index0].buffer);
+ }
+ }
+ }
+ if (pImageMemoryBarriers) {
+ local_pImageMemoryBarriers = new safe_VkImageMemoryBarrier[imageMemoryBarrierCount];
+ for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
+ local_pImageMemoryBarriers[index0].initialize(&pImageMemoryBarriers[index0]);
+ if (pImageMemoryBarriers[index0].image) {
+ local_pImageMemoryBarriers[index0].image = Unwrap(dev_data, pImageMemoryBarriers[index0].image);
+ }
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdWaitEvents(commandBuffer, eventCount, (const VkEvent*)local_pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, (const VkBufferMemoryBarrier*)local_pBufferMemoryBarriers, imageMemoryBarrierCount, (const VkImageMemoryBarrier*)local_pImageMemoryBarriers);
+ if (local_pEvents)
+ delete[] local_pEvents;
+ if (local_pBufferMemoryBarriers) {
+ delete[] local_pBufferMemoryBarriers;
+ }
+ if (local_pImageMemoryBarriers) {
+ delete[] local_pImageMemoryBarriers;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkBufferMemoryBarrier *local_pBufferMemoryBarriers = NULL;
+ safe_VkImageMemoryBarrier *local_pImageMemoryBarriers = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBufferMemoryBarriers) {
+ local_pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier[bufferMemoryBarrierCount];
+ for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
+ local_pBufferMemoryBarriers[index0].initialize(&pBufferMemoryBarriers[index0]);
+ if (pBufferMemoryBarriers[index0].buffer) {
+ local_pBufferMemoryBarriers[index0].buffer = Unwrap(dev_data, pBufferMemoryBarriers[index0].buffer);
+ }
+ }
+ }
+ if (pImageMemoryBarriers) {
+ local_pImageMemoryBarriers = new safe_VkImageMemoryBarrier[imageMemoryBarrierCount];
+ for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
+ local_pImageMemoryBarriers[index0].initialize(&pImageMemoryBarriers[index0]);
+ if (pImageMemoryBarriers[index0].image) {
+ local_pImageMemoryBarriers[index0].image = Unwrap(dev_data, pImageMemoryBarriers[index0].image);
+ }
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, (const VkBufferMemoryBarrier*)local_pBufferMemoryBarriers, imageMemoryBarrierCount, (const VkImageMemoryBarrier*)local_pImageMemoryBarriers);
+ if (local_pBufferMemoryBarriers) {
+ delete[] local_pBufferMemoryBarriers;
+ }
+ if (local_pImageMemoryBarriers) {
+ delete[] local_pImageMemoryBarriers;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ }
+ dev_data->dispatch_table.CmdBeginQuery(commandBuffer, queryPool, query, flags);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ }
+ dev_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, query);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ }
+ dev_data->dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ }
+ dev_data->dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ queryPool = Unwrap(dev_data, queryPool);
+ dstBuffer = Unwrap(dev_data, dstBuffer);
+ }
+ dev_data->dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ layout = Unwrap(dev_data, layout);
+ }
+ dev_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkRenderPassBeginInfo *local_pRenderPassBegin = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pRenderPassBegin) {
+ local_pRenderPassBegin = new safe_VkRenderPassBeginInfo(pRenderPassBegin);
+ if (pRenderPassBegin->renderPass) {
+ local_pRenderPassBegin->renderPass = Unwrap(dev_data, pRenderPassBegin->renderPass);
+ }
+ if (pRenderPassBegin->framebuffer) {
+ local_pRenderPassBegin->framebuffer = Unwrap(dev_data, pRenderPassBegin->framebuffer);
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdBeginRenderPass(commandBuffer, (const VkRenderPassBeginInfo*)local_pRenderPassBegin, contents);
+ if (local_pRenderPassBegin) {
+ delete local_pRenderPassBegin;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t surface_id = reinterpret_cast<uint64_t &>(surface);
+ surface = (VkSurfaceKHR)dev_data->unique_id_mapping[surface_id];
+ dev_data->unique_id_mapping.erase(surface_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroySurfaceKHR(instance, surface, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+
+ return result;
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+
+VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t swapchain_id = reinterpret_cast<uint64_t &>(swapchain);
+ swapchain = (VkSwapchainKHR)dev_data->unique_id_mapping[swapchain_id];
+ dev_data->unique_id_mapping.erase(swapchain_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
+
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ swapchain = Unwrap(dev_data, swapchain);
+ semaphore = Unwrap(dev_data, semaphore);
+ fence = Unwrap(dev_data, fence);
+ }
+ VkResult result = dev_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+
+ return result;
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pMode = WrapNew(dev_data, *pMode);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ safe_VkDisplaySurfaceCreateInfoKHR *local_pCreateInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pCreateInfo) {
+ local_pCreateInfo = new safe_VkDisplaySurfaceCreateInfoKHR(pCreateInfo);
+ if (pCreateInfo->displayMode) {
+ local_pCreateInfo->displayMode = Unwrap(dev_data, pCreateInfo->displayMode);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.CreateDisplayPlaneSurfaceKHR(instance, (const VkDisplaySurfaceCreateInfoKHR*)local_pCreateInfo, pAllocator, pSurface);
+ if (local_pCreateInfo) {
+ delete local_pCreateInfo;
+ }
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains);
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMagmaSurfaceKHR(
+ VkInstance instance,
+ const VkMagmaSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateMagmaSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ commandPool = Unwrap(dev_data, commandPool);
+ }
+ dev_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
+
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMemoryGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo = new safe_VkMemoryGetWin32HandleInfoKHR(pGetWin32HandleInfo);
+ if (pGetWin32HandleInfo->memory) {
+ local_pGetWin32HandleInfo->memory = Unwrap(dev_data, pGetWin32HandleInfo->memory);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetMemoryWin32HandleKHR(device, (const VkMemoryGetWin32HandleInfoKHR*)local_pGetWin32HandleInfo, pHandle);
+ if (local_pGetWin32HandleInfo) {
+ delete local_pGetWin32HandleInfo;
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMemoryGetFdInfoKHR *local_pGetFdInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetFdInfo) {
+ local_pGetFdInfo = new safe_VkMemoryGetFdInfoKHR(pGetFdInfo);
+ if (pGetFdInfo->memory) {
+ local_pGetFdInfo->memory = Unwrap(dev_data, pGetFdInfo->memory);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetMemoryFdKHR(device, (const VkMemoryGetFdInfoKHR*)local_pGetFdInfo, pFd);
+ if (local_pGetFdInfo) {
+ delete local_pGetFdInfo;
+ }
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImportSemaphoreWin32HandleInfoKHR *local_pImportSemaphoreWin32HandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pImportSemaphoreWin32HandleInfo) {
+ local_pImportSemaphoreWin32HandleInfo = new safe_VkImportSemaphoreWin32HandleInfoKHR(pImportSemaphoreWin32HandleInfo);
+ if (pImportSemaphoreWin32HandleInfo->semaphore) {
+ local_pImportSemaphoreWin32HandleInfo->semaphore = Unwrap(dev_data, pImportSemaphoreWin32HandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ImportSemaphoreWin32HandleKHR(device, (const VkImportSemaphoreWin32HandleInfoKHR*)local_pImportSemaphoreWin32HandleInfo);
+ if (local_pImportSemaphoreWin32HandleInfo) {
+ delete local_pImportSemaphoreWin32HandleInfo;
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkSemaphoreGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo = new safe_VkSemaphoreGetWin32HandleInfoKHR(pGetWin32HandleInfo);
+ if (pGetWin32HandleInfo->semaphore) {
+ local_pGetWin32HandleInfo->semaphore = Unwrap(dev_data, pGetWin32HandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetSemaphoreWin32HandleKHR(device, (const VkSemaphoreGetWin32HandleInfoKHR*)local_pGetWin32HandleInfo, pHandle);
+ if (local_pGetWin32HandleInfo) {
+ delete local_pGetWin32HandleInfo;
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImportSemaphoreFdInfoKHR *local_pImportSemaphoreFdInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pImportSemaphoreFdInfo) {
+ local_pImportSemaphoreFdInfo = new safe_VkImportSemaphoreFdInfoKHR(pImportSemaphoreFdInfo);
+ if (pImportSemaphoreFdInfo->semaphore) {
+ local_pImportSemaphoreFdInfo->semaphore = Unwrap(dev_data, pImportSemaphoreFdInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ImportSemaphoreFdKHR(device, (const VkImportSemaphoreFdInfoKHR*)local_pImportSemaphoreFdInfo);
+ if (local_pImportSemaphoreFdInfo) {
+ delete local_pImportSemaphoreFdInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkSemaphoreGetFdInfoKHR *local_pGetFdInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetFdInfo) {
+ local_pGetFdInfo = new safe_VkSemaphoreGetFdInfoKHR(pGetFdInfo);
+ if (pGetFdInfo->semaphore) {
+ local_pGetFdInfo->semaphore = Unwrap(dev_data, pGetFdInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetSemaphoreFdKHR(device, (const VkSemaphoreGetFdInfoKHR*)local_pGetFdInfo, pFd);
+ if (local_pGetFdInfo) {
+ delete local_pGetFdInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkWriteDescriptorSet *local_pDescriptorWrites = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ layout = Unwrap(dev_data, layout);
+ if (pDescriptorWrites) {
+ local_pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+ for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
+ local_pDescriptorWrites[index0].initialize(&pDescriptorWrites[index0]);
+ if (pDescriptorWrites[index0].dstSet) {
+ local_pDescriptorWrites[index0].dstSet = Unwrap(dev_data, pDescriptorWrites[index0].dstSet);
+ }
+ if (local_pDescriptorWrites[index0].pImageInfo) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ if (pDescriptorWrites[index0].pImageInfo[index1].sampler) {
+ local_pDescriptorWrites[index0].pImageInfo[index1].sampler = Unwrap(dev_data, pDescriptorWrites[index0].pImageInfo[index1].sampler);
+ }
+ if (pDescriptorWrites[index0].pImageInfo[index1].imageView) {
+ local_pDescriptorWrites[index0].pImageInfo[index1].imageView = Unwrap(dev_data, pDescriptorWrites[index0].pImageInfo[index1].imageView);
+ }
+ }
+ }
+ if (local_pDescriptorWrites[index0].pBufferInfo) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ if (pDescriptorWrites[index0].pBufferInfo[index1].buffer) {
+ local_pDescriptorWrites[index0].pBufferInfo[index1].buffer = Unwrap(dev_data, pDescriptorWrites[index0].pBufferInfo[index1].buffer);
+ }
+ }
+ }
+ if (local_pDescriptorWrites[index0].pTexelBufferView) {
+ for (uint32_t index1 = 0; index1 < local_pDescriptorWrites[index0].descriptorCount; ++index1) {
+ local_pDescriptorWrites[index0].pTexelBufferView[index1] = Unwrap(dev_data, local_pDescriptorWrites[index0].pTexelBufferView[index1]);
+ }
+ }
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, (const VkWriteDescriptorSet*)local_pDescriptorWrites);
+ if (local_pDescriptorWrites) {
+ delete[] local_pDescriptorWrites;
+ }
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
+
+// Declare only
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+
+// Declare only
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const void* pData);
+
+// Declare only
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ swapchain = Unwrap(dev_data, swapchain);
+ }
+ VkResult result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain);
+
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImportFenceWin32HandleInfoKHR *local_pImportFenceWin32HandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pImportFenceWin32HandleInfo) {
+ local_pImportFenceWin32HandleInfo = new safe_VkImportFenceWin32HandleInfoKHR(pImportFenceWin32HandleInfo);
+ if (pImportFenceWin32HandleInfo->fence) {
+ local_pImportFenceWin32HandleInfo->fence = Unwrap(dev_data, pImportFenceWin32HandleInfo->fence);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ImportFenceWin32HandleKHR(device, (const VkImportFenceWin32HandleInfoKHR*)local_pImportFenceWin32HandleInfo);
+ if (local_pImportFenceWin32HandleInfo) {
+ delete local_pImportFenceWin32HandleInfo;
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkFenceGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo = new safe_VkFenceGetWin32HandleInfoKHR(pGetWin32HandleInfo);
+ if (pGetWin32HandleInfo->fence) {
+ local_pGetWin32HandleInfo->fence = Unwrap(dev_data, pGetWin32HandleInfo->fence);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetFenceWin32HandleKHR(device, (const VkFenceGetWin32HandleInfoKHR*)local_pGetWin32HandleInfo, pHandle);
+ if (local_pGetWin32HandleInfo) {
+ delete local_pGetWin32HandleInfo;
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImportFenceFdInfoKHR *local_pImportFenceFdInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pImportFenceFdInfo) {
+ local_pImportFenceFdInfo = new safe_VkImportFenceFdInfoKHR(pImportFenceFdInfo);
+ if (pImportFenceFdInfo->fence) {
+ local_pImportFenceFdInfo->fence = Unwrap(dev_data, pImportFenceFdInfo->fence);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ImportFenceFdKHR(device, (const VkImportFenceFdInfoKHR*)local_pImportFenceFdInfo);
+ if (local_pImportFenceFdInfo) {
+ delete local_pImportFenceFdInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkFenceGetFdInfoKHR *local_pGetFdInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetFdInfo) {
+ local_pGetFdInfo = new safe_VkFenceGetFdInfoKHR(pGetFdInfo);
+ if (pGetFdInfo->fence) {
+ local_pGetFdInfo->fence = Unwrap(dev_data, pGetFdInfo->fence);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetFenceFdKHR(device, (const VkFenceGetFdInfoKHR*)local_pGetFdInfo, pFd);
+ if (local_pGetFdInfo) {
+ delete local_pGetFdInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
+ if (pSurfaceInfo->surface) {
+ local_pSurfaceInfo->surface = Unwrap(dev_data, pSurfaceInfo->surface);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, (const VkPhysicalDeviceSurfaceInfo2KHR*)local_pSurfaceInfo, pSurfaceCapabilities);
+ if (local_pSurfaceInfo) {
+ delete local_pSurfaceInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
+ if (pSurfaceInfo->surface) {
+ local_pSurfaceInfo->surface = Unwrap(dev_data, pSurfaceInfo->surface);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, (const VkPhysicalDeviceSurfaceInfo2KHR*)local_pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+ if (local_pSurfaceInfo) {
+ delete local_pSurfaceInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImageMemoryRequirementsInfo2KHR *local_pInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pInfo) {
+ local_pInfo = new safe_VkImageMemoryRequirementsInfo2KHR(pInfo);
+ if (pInfo->image) {
+ local_pInfo->image = Unwrap(dev_data, pInfo->image);
+ }
+ }
+ }
+ dev_data->dispatch_table.GetImageMemoryRequirements2KHR(device, (const VkImageMemoryRequirementsInfo2KHR*)local_pInfo, pMemoryRequirements);
+ if (local_pInfo) {
+ delete local_pInfo;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkBufferMemoryRequirementsInfo2KHR *local_pInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pInfo) {
+ local_pInfo = new safe_VkBufferMemoryRequirementsInfo2KHR(pInfo);
+ if (pInfo->buffer) {
+ local_pInfo->buffer = Unwrap(dev_data, pInfo->buffer);
+ }
+ }
+ }
+ dev_data->dispatch_table.GetBufferMemoryRequirements2KHR(device, (const VkBufferMemoryRequirementsInfo2KHR*)local_pInfo, pMemoryRequirements);
+ if (local_pInfo) {
+ delete local_pInfo;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImageSparseMemoryRequirementsInfo2KHR *local_pInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pInfo) {
+ local_pInfo = new safe_VkImageSparseMemoryRequirementsInfo2KHR(pInfo);
+ if (pInfo->image) {
+ local_pInfo->image = Unwrap(dev_data, pInfo->image);
+ }
+ }
+ }
+ dev_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, (const VkImageSparseMemoryRequirementsInfo2KHR*)local_pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+ if (local_pInfo) {
+ delete local_pInfo;
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandleKHR(
+ VkDevice device,
+ const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkMemoryGetFuchsiaHandleInfoKHR *local_pGetFuchsiaHandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetFuchsiaHandleInfo) {
+ local_pGetFuchsiaHandleInfo = new safe_VkMemoryGetFuchsiaHandleInfoKHR(pGetFuchsiaHandleInfo);
+ if (pGetFuchsiaHandleInfo->memory) {
+ local_pGetFuchsiaHandleInfo->memory = Unwrap(dev_data, pGetFuchsiaHandleInfo->memory);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetMemoryFuchsiaHandleKHR(device, (const VkMemoryGetFuchsiaHandleInfoKHR*)local_pGetFuchsiaHandleInfo, pFuchsiaHandle);
+ if (local_pGetFuchsiaHandleInfo) {
+ delete local_pGetFuchsiaHandleInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkImportSemaphoreFuchsiaHandleInfoKHR *local_pImportSemaphoreFuchsiaHandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pImportSemaphoreFuchsiaHandleInfo) {
+ local_pImportSemaphoreFuchsiaHandleInfo = new safe_VkImportSemaphoreFuchsiaHandleInfoKHR(pImportSemaphoreFuchsiaHandleInfo);
+ if (pImportSemaphoreFuchsiaHandleInfo->semaphore) {
+ local_pImportSemaphoreFuchsiaHandleInfo->semaphore = Unwrap(dev_data, pImportSemaphoreFuchsiaHandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.ImportSemaphoreFuchsiaHandleKHR(device, (const VkImportSemaphoreFuchsiaHandleInfoKHR*)local_pImportSemaphoreFuchsiaHandleInfo);
+ if (local_pImportSemaphoreFuchsiaHandleInfo) {
+ delete local_pImportSemaphoreFuchsiaHandleInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkSemaphoreGetFuchsiaHandleInfoKHR *local_pGetFuchsiaHandleInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pGetFuchsiaHandleInfo) {
+ local_pGetFuchsiaHandleInfo = new safe_VkSemaphoreGetFuchsiaHandleInfoKHR(pGetFuchsiaHandleInfo);
+ if (pGetFuchsiaHandleInfo->semaphore) {
+ local_pGetFuchsiaHandleInfo->semaphore = Unwrap(dev_data, pGetFuchsiaHandleInfo->semaphore);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.GetSemaphoreFuchsiaHandleKHR(device, (const VkSemaphoreGetFuchsiaHandleInfoKHR*)local_pGetFuchsiaHandleInfo, pFuchsiaHandle);
+ if (local_pGetFuchsiaHandleInfo) {
+ delete local_pGetFuchsiaHandleInfo;
+ }
+ return result;
+}
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+
+// Declare only
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ countBuffer = Unwrap(dev_data, countBuffer);
+ }
+ dev_data->dispatch_table.CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ buffer = Unwrap(dev_data, buffer);
+ countBuffer = Unwrap(dev_data, countBuffer);
+ }
+ dev_data->dispatch_table.CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ memory = Unwrap(dev_data, memory);
+ }
+ VkResult result = dev_data->dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfoKHX* pBindInfos)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkBindBufferMemoryInfoKHX *local_pBindInfos = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBindInfos) {
+ local_pBindInfos = new safe_VkBindBufferMemoryInfoKHX[bindInfoCount];
+ for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
+ local_pBindInfos[index0].initialize(&pBindInfos[index0]);
+ if (pBindInfos[index0].buffer) {
+ local_pBindInfos[index0].buffer = Unwrap(dev_data, pBindInfos[index0].buffer);
+ }
+ if (pBindInfos[index0].memory) {
+ local_pBindInfos[index0].memory = Unwrap(dev_data, pBindInfos[index0].memory);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, (const VkBindBufferMemoryInfoKHX*)local_pBindInfos);
+ if (local_pBindInfos) {
+ delete[] local_pBindInfos;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfoKHX* pBindInfos)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkBindImageMemoryInfoKHX *local_pBindInfos = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pBindInfos) {
+ local_pBindInfos = new safe_VkBindImageMemoryInfoKHX[bindInfoCount];
+ for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
+ local_pBindInfos[index0].initialize(&pBindInfos[index0]);
+ local_pBindInfos[index0].pNext = CreateUnwrappedExtensionStructs(dev_data, local_pBindInfos[index0].pNext);
+ if (pBindInfos[index0].image) {
+ local_pBindInfos[index0].image = Unwrap(dev_data, pBindInfos[index0].image);
+ }
+ if (pBindInfos[index0].memory) {
+ local_pBindInfos[index0].memory = Unwrap(dev_data, pBindInfos[index0].memory);
+ }
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, (const VkBindImageMemoryInfoKHX*)local_pBindInfos);
+ if (local_pBindInfos) {
+ for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
+ FreeUnwrappedExtensionStructs(const_cast<void *>(local_pBindInfos[index0].pNext));
+ }
+ delete[] local_pBindInfos;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHX* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ safe_VkAcquireNextImageInfoKHX *local_pAcquireInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pAcquireInfo) {
+ local_pAcquireInfo = new safe_VkAcquireNextImageInfoKHX(pAcquireInfo);
+ if (pAcquireInfo->swapchain) {
+ local_pAcquireInfo->swapchain = Unwrap(dev_data, pAcquireInfo->swapchain);
+ }
+ if (pAcquireInfo->semaphore) {
+ local_pAcquireInfo->semaphore = Unwrap(dev_data, pAcquireInfo->semaphore);
+ }
+ if (pAcquireInfo->fence) {
+ local_pAcquireInfo->fence = Unwrap(dev_data, pAcquireInfo->fence);
+ }
+ }
+ }
+ VkResult result = dev_data->dispatch_table.AcquireNextImage2KHX(device, (const VkAcquireNextImageInfoKHX*)local_pAcquireInfo, pImageIndex);
+ if (local_pAcquireInfo) {
+ delete local_pAcquireInfo;
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects);
+
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_VI_NN
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_VI_NN
+
+VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkCmdProcessCommandsInfoNVX *local_pProcessCommandsInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pProcessCommandsInfo) {
+ local_pProcessCommandsInfo = new safe_VkCmdProcessCommandsInfoNVX(pProcessCommandsInfo);
+ if (pProcessCommandsInfo->objectTable) {
+ local_pProcessCommandsInfo->objectTable = Unwrap(dev_data, pProcessCommandsInfo->objectTable);
+ }
+ if (pProcessCommandsInfo->indirectCommandsLayout) {
+ local_pProcessCommandsInfo->indirectCommandsLayout = Unwrap(dev_data, pProcessCommandsInfo->indirectCommandsLayout);
+ }
+ if (local_pProcessCommandsInfo->pIndirectCommandsTokens) {
+ for (uint32_t index1 = 0; index1 < local_pProcessCommandsInfo->indirectCommandsTokenCount; ++index1) {
+ if (pProcessCommandsInfo->pIndirectCommandsTokens[index1].buffer) {
+ local_pProcessCommandsInfo->pIndirectCommandsTokens[index1].buffer = Unwrap(dev_data, pProcessCommandsInfo->pIndirectCommandsTokens[index1].buffer);
+ }
+ }
+ }
+ if (pProcessCommandsInfo->sequencesCountBuffer) {
+ local_pProcessCommandsInfo->sequencesCountBuffer = Unwrap(dev_data, pProcessCommandsInfo->sequencesCountBuffer);
+ }
+ if (pProcessCommandsInfo->sequencesIndexBuffer) {
+ local_pProcessCommandsInfo->sequencesIndexBuffer = Unwrap(dev_data, pProcessCommandsInfo->sequencesIndexBuffer);
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, (const VkCmdProcessCommandsInfoNVX*)local_pProcessCommandsInfo);
+ if (local_pProcessCommandsInfo) {
+ delete local_pProcessCommandsInfo;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+ safe_VkCmdReserveSpaceForCommandsInfoNVX *local_pReserveSpaceInfo = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pReserveSpaceInfo) {
+ local_pReserveSpaceInfo = new safe_VkCmdReserveSpaceForCommandsInfoNVX(pReserveSpaceInfo);
+ if (pReserveSpaceInfo->objectTable) {
+ local_pReserveSpaceInfo->objectTable = Unwrap(dev_data, pReserveSpaceInfo->objectTable);
+ }
+ if (pReserveSpaceInfo->indirectCommandsLayout) {
+ local_pReserveSpaceInfo->indirectCommandsLayout = Unwrap(dev_data, pReserveSpaceInfo->indirectCommandsLayout);
+ }
+ }
+ }
+ dev_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, (const VkCmdReserveSpaceForCommandsInfoNVX*)local_pReserveSpaceInfo);
+ if (local_pReserveSpaceInfo) {
+ delete local_pReserveSpaceInfo;
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pIndirectCommandsLayout = WrapNew(dev_data, *pIndirectCommandsLayout);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t indirectCommandsLayout_id = reinterpret_cast<uint64_t &>(indirectCommandsLayout);
+ indirectCommandsLayout = (VkIndirectCommandsLayoutNVX)dev_data->unique_id_mapping[indirectCommandsLayout_id];
+ dev_data->unique_id_mapping.erase(indirectCommandsLayout_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pObjectTable = WrapNew(dev_data, *pObjectTable);
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ std::unique_lock<std::mutex> lock(global_lock);
+ uint64_t objectTable_id = reinterpret_cast<uint64_t &>(objectTable);
+ objectTable = (VkObjectTableNVX)dev_data->unique_id_mapping[objectTable_id];
+ dev_data->unique_id_mapping.erase(objectTable_id);
+ lock.unlock();
+ dev_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator);
+
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ objectTable = Unwrap(dev_data, objectTable);
+ }
+ VkResult result = dev_data->dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ objectTable = Unwrap(dev_data, objectTable);
+ }
+ VkResult result = dev_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ display = Unwrap(dev_data, display);
+ }
+ VkResult result = dev_data->dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
+
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ display = Unwrap(dev_data, display);
+ }
+ VkResult result = dev_data->dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
+
+ return result;
+}
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pDisplay = WrapNew(dev_data, *pDisplay);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ surface = Unwrap(dev_data, surface);
+ }
+ VkResult result = dev_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ display = Unwrap(dev_data, display);
+ }
+ VkResult result = dev_data->dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pFence = WrapNew(dev_data, *pFence);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pFence = WrapNew(dev_data, *pFence);
+ }
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ swapchain = Unwrap(dev_data, swapchain);
+ }
+ VkResult result = dev_data->dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ swapchain = Unwrap(dev_data, swapchain);
+ }
+ VkResult result = dev_data->dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ swapchain = Unwrap(dev_data, swapchain);
+ }
+ VkResult result = dev_data->dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkSwapchainKHR *local_pSwapchains = NULL;
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ if (pSwapchains) {
+ local_pSwapchains = new VkSwapchainKHR[swapchainCount];
+ for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
+ local_pSwapchains[index0] = Unwrap(dev_data, pSwapchains[index0]);
+ }
+ }
+ }
+ dev_data->dispatch_table.SetHdrMetadataEXT(device, swapchainCount, (const VkSwapchainKHR*)local_pSwapchains, pMetadata);
+ if (local_pSwapchains)
+ delete[] local_pSwapchains;
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
+ VkResult result = dev_data->dispatch_table.CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pSurface = WrapNew(dev_data, *pSurface);
+ }
+ return result;
+}
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+VKAPI_ATTR VkResult VKAPI_CALL ExportDeviceMemoryMAGMA(
+ VkDevice device,
+ VkDeviceMemory memory,
+ uint32_t* pHandle)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ {
+ std::lock_guard<std::mutex> lock(global_lock);
+ memory = Unwrap(dev_data, memory);
+ }
+ VkResult result = dev_data->dispatch_table.ExportDeviceMemoryMAGMA(device, memory, pHandle);
+
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportDeviceMemoryMAGMA(
+ VkDevice device,
+ uint32_t handle,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ VkResult result = dev_data->dispatch_table.ImportDeviceMemoryMAGMA(device, handle, pAllocator, pMemory);
+ if (VK_SUCCESS == result) {
+ std::lock_guard<std::mutex> lock(global_lock);
+ *pMemory = WrapNew(dev_data, *pMemory);
+ }
+ return result;
+}
+
+// Layer Device Extension Whitelist
+static const char *kUniqueObjectsSupportedDeviceExtensions =
+"VK_KHR_swapchain"
+"VK_KHR_display_swapchain"
+"VK_KHR_sampler_mirror_clamp_to_edge"
+"VK_KHR_shader_draw_parameters"
+"VK_KHR_maintenance1"
+"VK_KHR_external_memory"
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_KHR_external_memory_win32"
+#endif
+"VK_KHR_external_memory_fd"
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_KHR_win32_keyed_mutex"
+#endif
+"VK_KHR_external_semaphore"
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_KHR_external_semaphore_win32"
+#endif
+"VK_KHR_external_semaphore_fd"
+"VK_KHR_push_descriptor"
+"VK_KHR_16bit_storage"
+"VK_KHR_incremental_present"
+"VK_KHR_descriptor_update_template"
+"VK_KHR_shared_presentable_image"
+"VK_KHR_external_fence"
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_KHR_external_fence_win32"
+#endif
+"VK_KHR_external_fence_fd"
+"VK_KHR_variable_pointers"
+"VK_KHR_dedicated_allocation"
+"VK_KHR_storage_buffer_storage_class"
+"VK_KHR_relaxed_block_layout"
+"VK_KHR_get_memory_requirements2"
+"VK_KHR_external_memory_fuchsia"
+"VK_KHR_external_semaphore_fuchsia"
+"VK_NV_glsl_shader"
+"VK_EXT_depth_range_unrestricted"
+"VK_IMG_filter_cubic"
+"VK_AMD_rasterization_order"
+"VK_AMD_shader_trinary_minmax"
+"VK_AMD_shader_explicit_vertex_parameter"
+"VK_EXT_debug_marker"
+"VK_AMD_gcn_shader"
+"VK_NV_dedicated_allocation"
+"VK_AMD_draw_indirect_count"
+"VK_AMD_negative_viewport_height"
+"VK_AMD_gpu_shader_half_float"
+"VK_AMD_shader_ballot"
+"VK_AMD_texture_gather_bias_lod"
+"VK_KHX_multiview"
+"VK_IMG_format_pvrtc"
+"VK_NV_external_memory"
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_NV_external_memory_win32"
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_NV_win32_keyed_mutex"
+#endif
+"VK_KHX_device_group"
+"VK_EXT_shader_subgroup_ballot"
+"VK_EXT_shader_subgroup_vote"
+"VK_NVX_device_generated_commands"
+"VK_NV_clip_space_w_scaling"
+"VK_EXT_display_control"
+"VK_GOOGLE_display_timing"
+"VK_NV_sample_mask_override_coverage"
+"VK_NV_geometry_shader_passthrough"
+"VK_NV_viewport_array2"
+"VK_NVX_multiview_per_view_attributes"
+"VK_NV_viewport_swizzle"
+"VK_EXT_discard_rectangles"
+"VK_EXT_hdr_metadata"
+"VK_EXT_sampler_filter_minmax"
+"VK_AMD_gpu_shader_int16"
+"VK_EXT_blend_operation_advanced"
+"VK_NV_fragment_coverage_to_color"
+"VK_NV_framebuffer_mixed_samples"
+"VK_NV_fill_rectangle"
+"VK_EXT_post_depth_coverage"
+"VK_GOOGLE_external_memory_magma"
+;
+
+
+// Layer Instance Extension Whitelist
+static const char *kUniqueObjectsSupportedInstanceExtensions =
+"VK_KHR_surface"
+"VK_KHR_display"
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+"VK_KHR_xlib_surface"
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+"VK_KHR_xcb_surface"
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+"VK_KHR_wayland_surface"
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+"VK_KHR_mir_surface"
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+"VK_KHR_android_surface"
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+"VK_KHR_win32_surface"
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+"VK_KHR_magma_surface"
+#endif
+"VK_KHR_get_physical_device_properties2"
+"VK_KHR_external_memory_capabilities"
+"VK_KHR_external_semaphore_capabilities"
+"VK_KHR_external_fence_capabilities"
+"VK_KHR_get_surface_capabilities2"
+"VK_EXT_debug_report"
+"VK_NV_external_memory_capabilities"
+"VK_EXT_validation_flags"
+#ifdef VK_USE_PLATFORM_VI_NN
+"VK_NN_vi_surface"
+#endif
+"VK_KHX_device_group_creation"
+"VK_EXT_direct_mode_display"
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+"VK_EXT_acquire_xlib_display"
+#endif
+"VK_EXT_display_surface_counter"
+"VK_EXT_swapchain_colorspace"
+#ifdef VK_USE_PLATFORM_IOS_MVK
+"VK_MVK_ios_surface"
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+"VK_MVK_macos_surface"
+#endif
+"VK_GOOGLE_image_tiling_scanout"
+;
+
+
+// Map of all APIs to be intercepted by this layer
+static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
+ {"vkCreateInstance", (void *)CreateInstance},
+ {"vkDestroyInstance", (void *)DestroyInstance},
+ {"vkGetInstanceProcAddr", (void *)GetInstanceProcAddr},
+ {"vkGetDeviceProcAddr", (void *)GetDeviceProcAddr},
+ {"vkCreateDevice", (void *)CreateDevice},
+ {"vkDestroyDevice", (void *)DestroyDevice},
+ {"vkEnumerateInstanceExtensionProperties", (void *)EnumerateInstanceExtensionProperties},
+ {"vkEnumerateInstanceLayerProperties", (void *)EnumerateInstanceLayerProperties},
+ {"vkEnumerateDeviceLayerProperties", (void *)EnumerateDeviceLayerProperties},
+ {"vkQueueSubmit", (void*)QueueSubmit},
+ {"vkAllocateMemory", (void*)AllocateMemory},
+ {"vkFreeMemory", (void*)FreeMemory},
+ {"vkMapMemory", (void*)MapMemory},
+ {"vkUnmapMemory", (void*)UnmapMemory},
+ {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
+ {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
+ {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
+ {"vkBindBufferMemory", (void*)BindBufferMemory},
+ {"vkBindImageMemory", (void*)BindImageMemory},
+ {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
+ {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
+ {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
+ {"vkQueueBindSparse", (void*)QueueBindSparse},
+ {"vkCreateFence", (void*)CreateFence},
+ {"vkDestroyFence", (void*)DestroyFence},
+ {"vkResetFences", (void*)ResetFences},
+ {"vkGetFenceStatus", (void*)GetFenceStatus},
+ {"vkWaitForFences", (void*)WaitForFences},
+ {"vkCreateSemaphore", (void*)CreateSemaphore},
+ {"vkDestroySemaphore", (void*)DestroySemaphore},
+ {"vkCreateEvent", (void*)CreateEvent},
+ {"vkDestroyEvent", (void*)DestroyEvent},
+ {"vkGetEventStatus", (void*)GetEventStatus},
+ {"vkSetEvent", (void*)SetEvent},
+ {"vkResetEvent", (void*)ResetEvent},
+ {"vkCreateQueryPool", (void*)CreateQueryPool},
+ {"vkDestroyQueryPool", (void*)DestroyQueryPool},
+ {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
+ {"vkCreateBuffer", (void*)CreateBuffer},
+ {"vkDestroyBuffer", (void*)DestroyBuffer},
+ {"vkCreateBufferView", (void*)CreateBufferView},
+ {"vkDestroyBufferView", (void*)DestroyBufferView},
+ {"vkCreateImage", (void*)CreateImage},
+ {"vkDestroyImage", (void*)DestroyImage},
+ {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
+ {"vkCreateImageView", (void*)CreateImageView},
+ {"vkDestroyImageView", (void*)DestroyImageView},
+ {"vkCreateShaderModule", (void*)CreateShaderModule},
+ {"vkDestroyShaderModule", (void*)DestroyShaderModule},
+ {"vkCreatePipelineCache", (void*)CreatePipelineCache},
+ {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
+ {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
+ {"vkMergePipelineCaches", (void*)MergePipelineCaches},
+ {"vkCreateGraphicsPipelines", (void *)CreateGraphicsPipelines},
+ {"vkCreateComputePipelines", (void *)CreateComputePipelines},
+ {"vkDestroyPipeline", (void*)DestroyPipeline},
+ {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
+ {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
+ {"vkCreateSampler", (void*)CreateSampler},
+ {"vkDestroySampler", (void*)DestroySampler},
+ {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
+ {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
+ {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
+ {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
+ {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
+ {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
+ {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
+ {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
+ {"vkCreateFramebuffer", (void*)CreateFramebuffer},
+ {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
+ {"vkCreateRenderPass", (void*)CreateRenderPass},
+ {"vkDestroyRenderPass", (void*)DestroyRenderPass},
+ {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
+ {"vkCreateCommandPool", (void*)CreateCommandPool},
+ {"vkDestroyCommandPool", (void*)DestroyCommandPool},
+ {"vkResetCommandPool", (void*)ResetCommandPool},
+ {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
+ {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
+ {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
+ {"vkCmdBindPipeline", (void*)CmdBindPipeline},
+ {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
+ {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
+ {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
+ {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
+ {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
+ {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
+ {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
+ {"vkCmdCopyImage", (void*)CmdCopyImage},
+ {"vkCmdBlitImage", (void*)CmdBlitImage},
+ {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
+ {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
+ {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
+ {"vkCmdFillBuffer", (void*)CmdFillBuffer},
+ {"vkCmdClearColorImage", (void*)CmdClearColorImage},
+ {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
+ {"vkCmdResolveImage", (void*)CmdResolveImage},
+ {"vkCmdSetEvent", (void*)CmdSetEvent},
+ {"vkCmdResetEvent", (void*)CmdResetEvent},
+ {"vkCmdWaitEvents", (void*)CmdWaitEvents},
+ {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
+ {"vkCmdBeginQuery", (void*)CmdBeginQuery},
+ {"vkCmdEndQuery", (void*)CmdEndQuery},
+ {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
+ {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
+ {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
+ {"vkCmdPushConstants", (void*)CmdPushConstants},
+ {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
+ {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
+ {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
+ {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
+ {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
+ {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
+ {"vkCreateSwapchainKHR", (void *)CreateSwapchainKHR},
+ {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
+ {"vkGetSwapchainImagesKHR", (void *)GetSwapchainImagesKHR},
+ {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
+ {"vkQueuePresentKHR", (void *)QueuePresentKHR},
+ {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
+ {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
+ {"vkCreateSharedSwapchainsKHR", (void *)CreateSharedSwapchainsKHR},
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ {"vkCreateMirSurfaceKHR", (void*)CreateMirSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ {"vkCreateMagmaSurfaceKHR", (void*)CreateMagmaSurfaceKHR},
+#endif
+ {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
+#endif
+ {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
+#endif
+ {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
+ {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
+ {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
+ {"vkCreateDescriptorUpdateTemplateKHR", (void *)CreateDescriptorUpdateTemplateKHR},
+ {"vkDestroyDescriptorUpdateTemplateKHR", (void *)DestroyDescriptorUpdateTemplateKHR},
+ {"vkUpdateDescriptorSetWithTemplateKHR", (void *)UpdateDescriptorSetWithTemplateKHR},
+ {"vkCmdPushDescriptorSetWithTemplateKHR", (void *)CmdPushDescriptorSetWithTemplateKHR},
+ {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
+#endif
+ {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
+ {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
+ {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
+ {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
+ {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
+ {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
+ {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
+ {"vkGetMemoryFuchsiaHandleKHR", (void*)GetMemoryFuchsiaHandleKHR},
+ {"vkImportSemaphoreFuchsiaHandleKHR", (void*)ImportSemaphoreFuchsiaHandleKHR},
+ {"vkGetSemaphoreFuchsiaHandleKHR", (void*)GetSemaphoreFuchsiaHandleKHR},
+ {"vkDebugMarkerSetObjectTagEXT", (void *)DebugMarkerSetObjectTagEXT},
+ {"vkDebugMarkerSetObjectNameEXT", (void *)DebugMarkerSetObjectNameEXT},
+ {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
+ {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
+#endif
+ {"vkBindBufferMemory2KHX", (void*)BindBufferMemory2KHX},
+ {"vkBindImageMemory2KHX", (void*)BindImageMemory2KHX},
+ {"vkGetDeviceGroupSurfacePresentModesKHX", (void*)GetDeviceGroupSurfacePresentModesKHX},
+ {"vkAcquireNextImage2KHX", (void*)AcquireNextImage2KHX},
+ {"vkGetPhysicalDevicePresentRectanglesKHX", (void*)GetPhysicalDevicePresentRectanglesKHX},
+#ifdef VK_USE_PLATFORM_VI_NN
+ {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
+#endif
+ {"vkCmdProcessCommandsNVX", (void*)CmdProcessCommandsNVX},
+ {"vkCmdReserveSpaceForCommandsNVX", (void*)CmdReserveSpaceForCommandsNVX},
+ {"vkCreateIndirectCommandsLayoutNVX", (void*)CreateIndirectCommandsLayoutNVX},
+ {"vkDestroyIndirectCommandsLayoutNVX", (void*)DestroyIndirectCommandsLayoutNVX},
+ {"vkCreateObjectTableNVX", (void*)CreateObjectTableNVX},
+ {"vkDestroyObjectTableNVX", (void*)DestroyObjectTableNVX},
+ {"vkRegisterObjectsNVX", (void*)RegisterObjectsNVX},
+ {"vkUnregisterObjectsNVX", (void*)UnregisterObjectsNVX},
+ {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
+#endif
+ {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
+ {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
+ {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
+ {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
+ {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
+ {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
+ {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
+ {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
+#endif
+ {"vkExportDeviceMemoryMAGMA", (void*)ExportDeviceMemoryMAGMA},
+ {"vkImportDeviceMemoryMAGMA", (void*)ImportDeviceMemoryMAGMA},
+};
+
+
+} // namespace unique_objects
diff --git a/build-fuchsia/generated/include/vk_dispatch_table_helper.h b/build-fuchsia/generated/include/vk_dispatch_table_helper.h
new file mode 100644
index 0000000..fadd2bb
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_dispatch_table_helper.h
@@ -0,0 +1,345 @@
+#ifndef __vk_dispatch_table_helper_h_
+#define __vk_dispatch_table_helper_h_ 1
+
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See dispatch_helper_generator.py for modifications
+
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 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: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: Jon Ashburn <jon@lunarg.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ */
+
+#include <vulkan/vulkan.h>
+#include <vulkan/vk_layer.h>
+#include <string.h>
+
+static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDispatchTable *table, PFN_vkGetDeviceProcAddr gpa) {
+ memset(table, 0, sizeof(*table));
+ // Device function pointers
+ table->GetDeviceProcAddr = gpa;
+ table->DestroyDevice = (PFN_vkDestroyDevice) gpa(device, "vkDestroyDevice");
+ table->GetDeviceQueue = (PFN_vkGetDeviceQueue) gpa(device, "vkGetDeviceQueue");
+ table->QueueSubmit = (PFN_vkQueueSubmit) gpa(device, "vkQueueSubmit");
+ table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(device, "vkQueueWaitIdle");
+ table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(device, "vkDeviceWaitIdle");
+ table->AllocateMemory = (PFN_vkAllocateMemory) gpa(device, "vkAllocateMemory");
+ table->FreeMemory = (PFN_vkFreeMemory) gpa(device, "vkFreeMemory");
+ table->MapMemory = (PFN_vkMapMemory) gpa(device, "vkMapMemory");
+ table->UnmapMemory = (PFN_vkUnmapMemory) gpa(device, "vkUnmapMemory");
+ table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(device, "vkFlushMappedMemoryRanges");
+ table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(device, "vkInvalidateMappedMemoryRanges");
+ table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) gpa(device, "vkGetDeviceMemoryCommitment");
+ table->BindBufferMemory = (PFN_vkBindBufferMemory) gpa(device, "vkBindBufferMemory");
+ table->BindImageMemory = (PFN_vkBindImageMemory) gpa(device, "vkBindImageMemory");
+ table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) gpa(device, "vkGetBufferMemoryRequirements");
+ table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) gpa(device, "vkGetImageMemoryRequirements");
+ table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) gpa(device, "vkGetImageSparseMemoryRequirements");
+ table->QueueBindSparse = (PFN_vkQueueBindSparse) gpa(device, "vkQueueBindSparse");
+ table->CreateFence = (PFN_vkCreateFence) gpa(device, "vkCreateFence");
+ table->DestroyFence = (PFN_vkDestroyFence) gpa(device, "vkDestroyFence");
+ table->ResetFences = (PFN_vkResetFences) gpa(device, "vkResetFences");
+ table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(device, "vkGetFenceStatus");
+ table->WaitForFences = (PFN_vkWaitForFences) gpa(device, "vkWaitForFences");
+ table->CreateSemaphore = (PFN_vkCreateSemaphore) gpa(device, "vkCreateSemaphore");
+ table->DestroySemaphore = (PFN_vkDestroySemaphore) gpa(device, "vkDestroySemaphore");
+ table->CreateEvent = (PFN_vkCreateEvent) gpa(device, "vkCreateEvent");
+ table->DestroyEvent = (PFN_vkDestroyEvent) gpa(device, "vkDestroyEvent");
+ table->GetEventStatus = (PFN_vkGetEventStatus) gpa(device, "vkGetEventStatus");
+ table->SetEvent = (PFN_vkSetEvent) gpa(device, "vkSetEvent");
+ table->ResetEvent = (PFN_vkResetEvent) gpa(device, "vkResetEvent");
+ table->CreateQueryPool = (PFN_vkCreateQueryPool) gpa(device, "vkCreateQueryPool");
+ table->DestroyQueryPool = (PFN_vkDestroyQueryPool) gpa(device, "vkDestroyQueryPool");
+ table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults) gpa(device, "vkGetQueryPoolResults");
+ table->CreateBuffer = (PFN_vkCreateBuffer) gpa(device, "vkCreateBuffer");
+ table->DestroyBuffer = (PFN_vkDestroyBuffer) gpa(device, "vkDestroyBuffer");
+ table->CreateBufferView = (PFN_vkCreateBufferView) gpa(device, "vkCreateBufferView");
+ table->DestroyBufferView = (PFN_vkDestroyBufferView) gpa(device, "vkDestroyBufferView");
+ table->CreateImage = (PFN_vkCreateImage) gpa(device, "vkCreateImage");
+ table->DestroyImage = (PFN_vkDestroyImage) gpa(device, "vkDestroyImage");
+ table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) gpa(device, "vkGetImageSubresourceLayout");
+ table->CreateImageView = (PFN_vkCreateImageView) gpa(device, "vkCreateImageView");
+ table->DestroyImageView = (PFN_vkDestroyImageView) gpa(device, "vkDestroyImageView");
+ table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(device, "vkCreateShaderModule");
+ table->DestroyShaderModule = (PFN_vkDestroyShaderModule) gpa(device, "vkDestroyShaderModule");
+ table->CreatePipelineCache = (PFN_vkCreatePipelineCache) gpa(device, "vkCreatePipelineCache");
+ table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache) gpa(device, "vkDestroyPipelineCache");
+ table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData) gpa(device, "vkGetPipelineCacheData");
+ table->MergePipelineCaches = (PFN_vkMergePipelineCaches) gpa(device, "vkMergePipelineCaches");
+ table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) gpa(device, "vkCreateGraphicsPipelines");
+ table->CreateComputePipelines = (PFN_vkCreateComputePipelines) gpa(device, "vkCreateComputePipelines");
+ table->DestroyPipeline = (PFN_vkDestroyPipeline) gpa(device, "vkDestroyPipeline");
+ table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(device, "vkCreatePipelineLayout");
+ table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) gpa(device, "vkDestroyPipelineLayout");
+ table->CreateSampler = (PFN_vkCreateSampler) gpa(device, "vkCreateSampler");
+ table->DestroySampler = (PFN_vkDestroySampler) gpa(device, "vkDestroySampler");
+ table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(device, "vkCreateDescriptorSetLayout");
+ table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) gpa(device, "vkDestroyDescriptorSetLayout");
+ table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(device, "vkCreateDescriptorPool");
+ table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) gpa(device, "vkDestroyDescriptorPool");
+ table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(device, "vkResetDescriptorPool");
+ table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) gpa(device, "vkAllocateDescriptorSets");
+ table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets) gpa(device, "vkFreeDescriptorSets");
+ table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(device, "vkUpdateDescriptorSets");
+ table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(device, "vkCreateFramebuffer");
+ table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer) gpa(device, "vkDestroyFramebuffer");
+ table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(device, "vkCreateRenderPass");
+ table->DestroyRenderPass = (PFN_vkDestroyRenderPass) gpa(device, "vkDestroyRenderPass");
+ table->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) gpa(device, "vkGetRenderAreaGranularity");
+ table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(device, "vkCreateCommandPool");
+ table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(device, "vkDestroyCommandPool");
+ table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(device, "vkResetCommandPool");
+ table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) gpa(device, "vkAllocateCommandBuffers");
+ table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers) gpa(device, "vkFreeCommandBuffers");
+ table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(device, "vkBeginCommandBuffer");
+ table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(device, "vkEndCommandBuffer");
+ table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(device, "vkResetCommandBuffer");
+ table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(device, "vkCmdBindPipeline");
+ table->CmdSetViewport = (PFN_vkCmdSetViewport) gpa(device, "vkCmdSetViewport");
+ table->CmdSetScissor = (PFN_vkCmdSetScissor) gpa(device, "vkCmdSetScissor");
+ table->CmdSetLineWidth = (PFN_vkCmdSetLineWidth) gpa(device, "vkCmdSetLineWidth");
+ table->CmdSetDepthBias = (PFN_vkCmdSetDepthBias) gpa(device, "vkCmdSetDepthBias");
+ table->CmdSetBlendConstants = (PFN_vkCmdSetBlendConstants) gpa(device, "vkCmdSetBlendConstants");
+ table->CmdSetDepthBounds = (PFN_vkCmdSetDepthBounds) gpa(device, "vkCmdSetDepthBounds");
+ table->CmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask) gpa(device, "vkCmdSetStencilCompareMask");
+ table->CmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask) gpa(device, "vkCmdSetStencilWriteMask");
+ table->CmdSetStencilReference = (PFN_vkCmdSetStencilReference) gpa(device, "vkCmdSetStencilReference");
+ table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(device, "vkCmdBindDescriptorSets");
+ table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) gpa(device, "vkCmdBindIndexBuffer");
+ table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(device, "vkCmdBindVertexBuffers");
+ table->CmdDraw = (PFN_vkCmdDraw) gpa(device, "vkCmdDraw");
+ table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed) gpa(device, "vkCmdDrawIndexed");
+ table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect) gpa(device, "vkCmdDrawIndirect");
+ table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) gpa(device, "vkCmdDrawIndexedIndirect");
+ table->CmdDispatch = (PFN_vkCmdDispatch) gpa(device, "vkCmdDispatch");
+ table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) gpa(device, "vkCmdDispatchIndirect");
+ table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer) gpa(device, "vkCmdCopyBuffer");
+ table->CmdCopyImage = (PFN_vkCmdCopyImage) gpa(device, "vkCmdCopyImage");
+ table->CmdBlitImage = (PFN_vkCmdBlitImage) gpa(device, "vkCmdBlitImage");
+ table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) gpa(device, "vkCmdCopyBufferToImage");
+ table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) gpa(device, "vkCmdCopyImageToBuffer");
+ table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) gpa(device, "vkCmdUpdateBuffer");
+ table->CmdFillBuffer = (PFN_vkCmdFillBuffer) gpa(device, "vkCmdFillBuffer");
+ table->CmdClearColorImage = (PFN_vkCmdClearColorImage) gpa(device, "vkCmdClearColorImage");
+ table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage) gpa(device, "vkCmdClearDepthStencilImage");
+ table->CmdClearAttachments = (PFN_vkCmdClearAttachments) gpa(device, "vkCmdClearAttachments");
+ table->CmdResolveImage = (PFN_vkCmdResolveImage) gpa(device, "vkCmdResolveImage");
+ table->CmdSetEvent = (PFN_vkCmdSetEvent) gpa(device, "vkCmdSetEvent");
+ table->CmdResetEvent = (PFN_vkCmdResetEvent) gpa(device, "vkCmdResetEvent");
+ table->CmdWaitEvents = (PFN_vkCmdWaitEvents) gpa(device, "vkCmdWaitEvents");
+ table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) gpa(device, "vkCmdPipelineBarrier");
+ table->CmdBeginQuery = (PFN_vkCmdBeginQuery) gpa(device, "vkCmdBeginQuery");
+ table->CmdEndQuery = (PFN_vkCmdEndQuery) gpa(device, "vkCmdEndQuery");
+ table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool) gpa(device, "vkCmdResetQueryPool");
+ table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) gpa(device, "vkCmdWriteTimestamp");
+ table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) gpa(device, "vkCmdCopyQueryPoolResults");
+ table->CmdPushConstants = (PFN_vkCmdPushConstants) gpa(device, "vkCmdPushConstants");
+ table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(device, "vkCmdBeginRenderPass");
+ table->CmdNextSubpass = (PFN_vkCmdNextSubpass) gpa(device, "vkCmdNextSubpass");
+ table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(device, "vkCmdEndRenderPass");
+ table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands) gpa(device, "vkCmdExecuteCommands");
+ table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
+ table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
+ table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
+ table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
+ table->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
+ table->CreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR) gpa(device, "vkCreateSharedSwapchainsKHR");
+ table->TrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR) gpa(device, "vkTrimCommandPoolKHR");
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR) gpa(device, "vkGetMemoryWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR) gpa(device, "vkGetMemoryWin32HandlePropertiesKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryFdKHR = (PFN_vkGetMemoryFdKHR) gpa(device, "vkGetMemoryFdKHR");
+ table->GetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR) gpa(device, "vkGetMemoryFdPropertiesKHR");
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->ImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR) gpa(device, "vkImportSemaphoreWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR) gpa(device, "vkGetSemaphoreWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ table->ImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR) gpa(device, "vkImportSemaphoreFdKHR");
+ table->GetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR) gpa(device, "vkGetSemaphoreFdKHR");
+ table->CmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR) gpa(device, "vkCmdPushDescriptorSetKHR");
+ table->CreateDescriptorUpdateTemplateKHR = (PFN_vkCreateDescriptorUpdateTemplateKHR) gpa(device, "vkCreateDescriptorUpdateTemplateKHR");
+ table->DestroyDescriptorUpdateTemplateKHR = (PFN_vkDestroyDescriptorUpdateTemplateKHR) gpa(device, "vkDestroyDescriptorUpdateTemplateKHR");
+ table->UpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR) gpa(device, "vkUpdateDescriptorSetWithTemplateKHR");
+ table->CmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR) gpa(device, "vkCmdPushDescriptorSetWithTemplateKHR");
+ table->GetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR) gpa(device, "vkGetSwapchainStatusKHR");
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->ImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR) gpa(device, "vkImportFenceWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR) gpa(device, "vkGetFenceWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ table->ImportFenceFdKHR = (PFN_vkImportFenceFdKHR) gpa(device, "vkImportFenceFdKHR");
+ table->GetFenceFdKHR = (PFN_vkGetFenceFdKHR) gpa(device, "vkGetFenceFdKHR");
+ table->GetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR) gpa(device, "vkGetImageMemoryRequirements2KHR");
+ table->GetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR) gpa(device, "vkGetBufferMemoryRequirements2KHR");
+ table->GetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR) gpa(device, "vkGetImageSparseMemoryRequirements2KHR");
+ table->GetMemoryFuchsiaHandleKHR = (PFN_vkGetMemoryFuchsiaHandleKHR) gpa(device, "vkGetMemoryFuchsiaHandleKHR");
+ table->GetMemoryFuchsiaHandlePropertiesKHR = (PFN_vkGetMemoryFuchsiaHandlePropertiesKHR) gpa(device, "vkGetMemoryFuchsiaHandlePropertiesKHR");
+ table->ImportSemaphoreFuchsiaHandleKHR = (PFN_vkImportSemaphoreFuchsiaHandleKHR) gpa(device, "vkImportSemaphoreFuchsiaHandleKHR");
+ table->GetSemaphoreFuchsiaHandleKHR = (PFN_vkGetSemaphoreFuchsiaHandleKHR) gpa(device, "vkGetSemaphoreFuchsiaHandleKHR");
+ table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT) gpa(device, "vkDebugMarkerSetObjectTagEXT");
+ table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT) gpa(device, "vkDebugMarkerSetObjectNameEXT");
+ table->CmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT) gpa(device, "vkCmdDebugMarkerBeginEXT");
+ table->CmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT) gpa(device, "vkCmdDebugMarkerEndEXT");
+ table->CmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT) gpa(device, "vkCmdDebugMarkerInsertEXT");
+ table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD) gpa(device, "vkCmdDrawIndirectCountAMD");
+ table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD) gpa(device, "vkCmdDrawIndexedIndirectCountAMD");
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV) gpa(device, "vkGetMemoryWin32HandleNV");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ table->GetDeviceGroupPeerMemoryFeaturesKHX = (PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX) gpa(device, "vkGetDeviceGroupPeerMemoryFeaturesKHX");
+ table->BindBufferMemory2KHX = (PFN_vkBindBufferMemory2KHX) gpa(device, "vkBindBufferMemory2KHX");
+ table->BindImageMemory2KHX = (PFN_vkBindImageMemory2KHX) gpa(device, "vkBindImageMemory2KHX");
+ table->CmdSetDeviceMaskKHX = (PFN_vkCmdSetDeviceMaskKHX) gpa(device, "vkCmdSetDeviceMaskKHX");
+ table->GetDeviceGroupPresentCapabilitiesKHX = (PFN_vkGetDeviceGroupPresentCapabilitiesKHX) gpa(device, "vkGetDeviceGroupPresentCapabilitiesKHX");
+ table->GetDeviceGroupSurfacePresentModesKHX = (PFN_vkGetDeviceGroupSurfacePresentModesKHX) gpa(device, "vkGetDeviceGroupSurfacePresentModesKHX");
+ table->AcquireNextImage2KHX = (PFN_vkAcquireNextImage2KHX) gpa(device, "vkAcquireNextImage2KHX");
+ table->CmdDispatchBaseKHX = (PFN_vkCmdDispatchBaseKHX) gpa(device, "vkCmdDispatchBaseKHX");
+ table->CmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX) gpa(device, "vkCmdProcessCommandsNVX");
+ table->CmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX) gpa(device, "vkCmdReserveSpaceForCommandsNVX");
+ table->CreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX) gpa(device, "vkCreateIndirectCommandsLayoutNVX");
+ table->DestroyIndirectCommandsLayoutNVX = (PFN_vkDestroyIndirectCommandsLayoutNVX) gpa(device, "vkDestroyIndirectCommandsLayoutNVX");
+ table->CreateObjectTableNVX = (PFN_vkCreateObjectTableNVX) gpa(device, "vkCreateObjectTableNVX");
+ table->DestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX) gpa(device, "vkDestroyObjectTableNVX");
+ table->RegisterObjectsNVX = (PFN_vkRegisterObjectsNVX) gpa(device, "vkRegisterObjectsNVX");
+ table->UnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX) gpa(device, "vkUnregisterObjectsNVX");
+ table->CmdSetViewportWScalingNV = (PFN_vkCmdSetViewportWScalingNV) gpa(device, "vkCmdSetViewportWScalingNV");
+ table->DisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT) gpa(device, "vkDisplayPowerControlEXT");
+ table->RegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT) gpa(device, "vkRegisterDeviceEventEXT");
+ table->RegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT) gpa(device, "vkRegisterDisplayEventEXT");
+ table->GetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT) gpa(device, "vkGetSwapchainCounterEXT");
+ table->GetRefreshCycleDurationGOOGLE = (PFN_vkGetRefreshCycleDurationGOOGLE) gpa(device, "vkGetRefreshCycleDurationGOOGLE");
+ table->GetPastPresentationTimingGOOGLE = (PFN_vkGetPastPresentationTimingGOOGLE) gpa(device, "vkGetPastPresentationTimingGOOGLE");
+ table->CmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT) gpa(device, "vkCmdSetDiscardRectangleEXT");
+ table->SetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT) gpa(device, "vkSetHdrMetadataEXT");
+ table->ExportDeviceMemoryMAGMA = (PFN_vkExportDeviceMemoryMAGMA) gpa(device, "vkExportDeviceMemoryMAGMA");
+ table->ImportDeviceMemoryMAGMA = (PFN_vkImportDeviceMemoryMAGMA) gpa(device, "vkImportDeviceMemoryMAGMA");
+}
+
+
+static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa) {
+ memset(table, 0, sizeof(*table));
+ // Instance function pointers
+ table->DestroyInstance = (PFN_vkDestroyInstance) gpa(instance, "vkDestroyInstance");
+ table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) gpa(instance, "vkEnumeratePhysicalDevices");
+ table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) gpa(instance, "vkGetPhysicalDeviceFeatures");
+ table->GetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) gpa(instance, "vkGetPhysicalDeviceFormatProperties");
+ table->GetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) gpa(instance, "vkGetPhysicalDeviceImageFormatProperties");
+ table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) gpa(instance, "vkGetPhysicalDeviceProperties");
+ table->GetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties) gpa(instance, "vkGetPhysicalDeviceQueueFamilyProperties");
+ table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) gpa(instance, "vkGetPhysicalDeviceMemoryProperties");
+ table->GetInstanceProcAddr = gpa;
+ table->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties) gpa(instance, "vkEnumerateDeviceExtensionProperties");
+ table->EnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties) gpa(instance, "vkEnumerateDeviceLayerProperties");
+ table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) gpa(instance, "vkGetPhysicalDeviceSparseImageFormatProperties");
+ table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) gpa(instance, "vkDestroySurfaceKHR");
+ table->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
+ table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+ table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+ table->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR");
+ table->GetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR) gpa(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR");
+ table->GetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR) gpa(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
+ table->GetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR) gpa(instance, "vkGetDisplayPlaneSupportedDisplaysKHR");
+ table->GetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR) gpa(instance, "vkGetDisplayModePropertiesKHR");
+ table->CreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR) gpa(instance, "vkCreateDisplayModeKHR");
+ table->GetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR) gpa(instance, "vkGetDisplayPlaneCapabilitiesKHR");
+ table->CreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR) gpa(instance, "vkCreateDisplayPlaneSurfaceKHR");
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ table->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) gpa(instance, "vkCreateXlibSurfaceKHR");
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ table->GetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ table->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) gpa(instance, "vkCreateXcbSurfaceKHR");
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ table->GetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ table->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) gpa(instance, "vkCreateWaylandSurfaceKHR");
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ table->GetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ table->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) gpa(instance, "vkCreateMirSurfaceKHR");
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ table->GetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ table->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) gpa(instance, "vkCreateAndroidSurfaceKHR");
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) gpa(instance, "vkCreateWin32SurfaceKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ table->CreateMagmaSurfaceKHR = (PFN_vkCreateMagmaSurfaceKHR) gpa(instance, "vkCreateMagmaSurfaceKHR");
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ table->GetPhysicalDeviceMagmaPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMagmaPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceMagmaPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+ table->GetPhysicalDeviceFeatures2KHR = (PFN_vkGetPhysicalDeviceFeatures2KHR) gpa(instance, "vkGetPhysicalDeviceFeatures2KHR");
+ table->GetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR) gpa(instance, "vkGetPhysicalDeviceProperties2KHR");
+ table->GetPhysicalDeviceFormatProperties2KHR = (PFN_vkGetPhysicalDeviceFormatProperties2KHR) gpa(instance, "vkGetPhysicalDeviceFormatProperties2KHR");
+ table->GetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR) gpa(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR");
+ table->GetPhysicalDeviceQueueFamilyProperties2KHR = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR) gpa(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+ table->GetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2KHR) gpa(instance, "vkGetPhysicalDeviceMemoryProperties2KHR");
+ table->GetPhysicalDeviceSparseImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR) gpa(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+ table->GetPhysicalDeviceExternalBufferPropertiesKHR = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR) gpa(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
+ table->GetPhysicalDeviceExternalSemaphorePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR) gpa(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
+ table->GetPhysicalDeviceExternalFencePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR) gpa(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR");
+ table->GetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR) gpa(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+ table->GetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR) gpa(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR");
+ table->CreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT) gpa(instance, "vkCreateDebugReportCallbackEXT");
+ table->DestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT) gpa(instance, "vkDestroyDebugReportCallbackEXT");
+ table->DebugReportMessageEXT = (PFN_vkDebugReportMessageEXT) gpa(instance, "vkDebugReportMessageEXT");
+ table->GetPhysicalDeviceExternalImageFormatPropertiesNV = (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV) gpa(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+ table->GetPhysicalDevicePresentRectanglesKHX = (PFN_vkGetPhysicalDevicePresentRectanglesKHX) gpa(instance, "vkGetPhysicalDevicePresentRectanglesKHX");
+#ifdef VK_USE_PLATFORM_VI_NN
+ table->CreateViSurfaceNN = (PFN_vkCreateViSurfaceNN) gpa(instance, "vkCreateViSurfaceNN");
+#endif // VK_USE_PLATFORM_VI_NN
+ table->EnumeratePhysicalDeviceGroupsKHX = (PFN_vkEnumeratePhysicalDeviceGroupsKHX) gpa(instance, "vkEnumeratePhysicalDeviceGroupsKHX");
+ table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX = (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX) gpa(instance, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+ table->ReleaseDisplayEXT = (PFN_vkReleaseDisplayEXT) gpa(instance, "vkReleaseDisplayEXT");
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ table->AcquireXlibDisplayEXT = (PFN_vkAcquireXlibDisplayEXT) gpa(instance, "vkAcquireXlibDisplayEXT");
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ table->GetRandROutputDisplayEXT = (PFN_vkGetRandROutputDisplayEXT) gpa(instance, "vkGetRandROutputDisplayEXT");
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ table->GetPhysicalDeviceSurfaceCapabilities2EXT = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT) gpa(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ table->CreateIOSSurfaceMVK = (PFN_vkCreateIOSSurfaceMVK) gpa(instance, "vkCreateIOSSurfaceMVK");
+#endif // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ table->CreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK) gpa(instance, "vkCreateMacOSSurfaceMVK");
+#endif // VK_USE_PLATFORM_MACOS_MVK
+}
+
+#endif
diff --git a/build-fuchsia/generated/include/vk_enum_string_helper.h b/build-fuchsia/generated/include/vk_enum_string_helper.h
new file mode 100644
index 0000000..1b27286
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_enum_string_helper.h
@@ -0,0 +1,3035 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#pragma once
+#ifdef _WIN32
+#pragma warning( disable : 4065 )
+#endif
+
+#include <vulkan/vulkan.h>
+
+
+static inline const char* string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)
+{
+ switch ((VkPipelineCacheHeaderVersion)input_value)
+ {
+ case VK_PIPELINE_CACHE_HEADER_VERSION_ONE:
+ return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE";
+ default:
+ return "Unhandled VkPipelineCacheHeaderVersion";
+ }
+}
+
+static inline const char* string_VkResult(VkResult input_value)
+{
+ switch ((VkResult)input_value)
+ {
+ case VK_SUCCESS:
+ return "VK_SUCCESS";
+ case VK_NOT_READY:
+ return "VK_NOT_READY";
+ case VK_TIMEOUT:
+ return "VK_TIMEOUT";
+ case VK_EVENT_SET:
+ return "VK_EVENT_SET";
+ case VK_EVENT_RESET:
+ return "VK_EVENT_RESET";
+ case VK_INCOMPLETE:
+ return "VK_INCOMPLETE";
+ case VK_ERROR_OUT_OF_HOST_MEMORY:
+ return "VK_ERROR_OUT_OF_HOST_MEMORY";
+ case VK_ERROR_OUT_OF_DEVICE_MEMORY:
+ return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+ case VK_ERROR_INITIALIZATION_FAILED:
+ return "VK_ERROR_INITIALIZATION_FAILED";
+ case VK_ERROR_DEVICE_LOST:
+ return "VK_ERROR_DEVICE_LOST";
+ case VK_ERROR_MEMORY_MAP_FAILED:
+ return "VK_ERROR_MEMORY_MAP_FAILED";
+ case VK_ERROR_LAYER_NOT_PRESENT:
+ return "VK_ERROR_LAYER_NOT_PRESENT";
+ case VK_ERROR_EXTENSION_NOT_PRESENT:
+ return "VK_ERROR_EXTENSION_NOT_PRESENT";
+ case VK_ERROR_FEATURE_NOT_PRESENT:
+ return "VK_ERROR_FEATURE_NOT_PRESENT";
+ case VK_ERROR_INCOMPATIBLE_DRIVER:
+ return "VK_ERROR_INCOMPATIBLE_DRIVER";
+ case VK_ERROR_TOO_MANY_OBJECTS:
+ return "VK_ERROR_TOO_MANY_OBJECTS";
+ case VK_ERROR_FORMAT_NOT_SUPPORTED:
+ return "VK_ERROR_FORMAT_NOT_SUPPORTED";
+ case VK_ERROR_FRAGMENTED_POOL:
+ return "VK_ERROR_FRAGMENTED_POOL";
+ case VK_ERROR_SURFACE_LOST_KHR:
+ return "VK_ERROR_SURFACE_LOST_KHR";
+ case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
+ return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
+ case VK_SUBOPTIMAL_KHR:
+ return "VK_SUBOPTIMAL_KHR";
+ case VK_ERROR_OUT_OF_DATE_KHR:
+ return "VK_ERROR_OUT_OF_DATE_KHR";
+ case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
+ return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
+ case VK_ERROR_VALIDATION_FAILED_EXT:
+ return "VK_ERROR_VALIDATION_FAILED_EXT";
+ case VK_ERROR_INVALID_SHADER_NV:
+ return "VK_ERROR_INVALID_SHADER_NV";
+ case VK_ERROR_OUT_OF_POOL_MEMORY_KHR:
+ return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
+ case VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR:
+ return "VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR";
+ default:
+ return "Unhandled VkResult";
+ }
+}
+
+static inline const char* string_VkStructureType(VkStructureType input_value)
+{
+ switch ((VkStructureType)input_value)
+ {
+ case VK_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
+ case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SUBMIT_INFO:
+ return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
+ return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
+ case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
+ return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
+ case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
+ return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
+ return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
+ case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
+ return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
+ return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
+ return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
+ return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
+ return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
+ return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MAGMA_SURFACE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MAGMA_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+ return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+ return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX";
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX";
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX";
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX";
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX";
+ case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+ return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
+ case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
+ return "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX";
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+ return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX:
+ return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
+ case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX:
+ return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
+ case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX:
+ return "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX";
+ case VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX:
+ return "VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX";
+ case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX";
+ case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX:
+ return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX";
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT:
+ return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT";
+ case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT";
+ case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT";
+ case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+ return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX";
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT";
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
+ return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT";
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+ return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_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_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
+ return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
+ return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
+ return "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK";
+ case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
+ return "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK";
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT";
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR:
+ return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR";
+ case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR:
+ return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+ return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT";
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+ return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+ return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV";
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FUCHSIA_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FUCHSIA_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_FUCHSIA_HANDLE_PROPERTIES_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_FUCHSIA_HANDLE_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_GET_FUCHSIA_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_MEMORY_GET_FUCHSIA_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FUCHSIA_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FUCHSIA_HANDLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FUCHSIA_HANDLE_INFO_KHR:
+ return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FUCHSIA_HANDLE_INFO_KHR";
+ default:
+ return "Unhandled VkStructureType";
+ }
+}
+
+static inline const char* string_VkSystemAllocationScope(VkSystemAllocationScope input_value)
+{
+ switch ((VkSystemAllocationScope)input_value)
+ {
+ case VK_SYSTEM_ALLOCATION_SCOPE_COMMAND:
+ return "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND";
+ case VK_SYSTEM_ALLOCATION_SCOPE_OBJECT:
+ return "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT";
+ case VK_SYSTEM_ALLOCATION_SCOPE_CACHE:
+ return "VK_SYSTEM_ALLOCATION_SCOPE_CACHE";
+ case VK_SYSTEM_ALLOCATION_SCOPE_DEVICE:
+ return "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE";
+ case VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE:
+ return "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE";
+ default:
+ return "Unhandled VkSystemAllocationScope";
+ }
+}
+
+static inline const char* string_VkInternalAllocationType(VkInternalAllocationType input_value)
+{
+ switch ((VkInternalAllocationType)input_value)
+ {
+ case VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE:
+ return "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE";
+ default:
+ return "Unhandled VkInternalAllocationType";
+ }
+}
+
+static inline const char* string_VkFormat(VkFormat input_value)
+{
+ switch ((VkFormat)input_value)
+ {
+ case VK_FORMAT_UNDEFINED:
+ return "VK_FORMAT_UNDEFINED";
+ case VK_FORMAT_R4G4_UNORM_PACK8:
+ return "VK_FORMAT_R4G4_UNORM_PACK8";
+ case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
+ return "VK_FORMAT_R4G4B4A4_UNORM_PACK16";
+ case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+ return "VK_FORMAT_B4G4R4A4_UNORM_PACK16";
+ case VK_FORMAT_R5G6B5_UNORM_PACK16:
+ return "VK_FORMAT_R5G6B5_UNORM_PACK16";
+ case VK_FORMAT_B5G6R5_UNORM_PACK16:
+ return "VK_FORMAT_B5G6R5_UNORM_PACK16";
+ case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
+ return "VK_FORMAT_R5G5B5A1_UNORM_PACK16";
+ case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
+ return "VK_FORMAT_B5G5R5A1_UNORM_PACK16";
+ case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
+ return "VK_FORMAT_A1R5G5B5_UNORM_PACK16";
+ case VK_FORMAT_R8_UNORM:
+ return "VK_FORMAT_R8_UNORM";
+ case VK_FORMAT_R8_SNORM:
+ return "VK_FORMAT_R8_SNORM";
+ case VK_FORMAT_R8_USCALED:
+ return "VK_FORMAT_R8_USCALED";
+ case VK_FORMAT_R8_SSCALED:
+ return "VK_FORMAT_R8_SSCALED";
+ case VK_FORMAT_R8_UINT:
+ return "VK_FORMAT_R8_UINT";
+ case VK_FORMAT_R8_SINT:
+ return "VK_FORMAT_R8_SINT";
+ case VK_FORMAT_R8_SRGB:
+ return "VK_FORMAT_R8_SRGB";
+ case VK_FORMAT_R8G8_UNORM:
+ return "VK_FORMAT_R8G8_UNORM";
+ case VK_FORMAT_R8G8_SNORM:
+ return "VK_FORMAT_R8G8_SNORM";
+ case VK_FORMAT_R8G8_USCALED:
+ return "VK_FORMAT_R8G8_USCALED";
+ case VK_FORMAT_R8G8_SSCALED:
+ return "VK_FORMAT_R8G8_SSCALED";
+ case VK_FORMAT_R8G8_UINT:
+ return "VK_FORMAT_R8G8_UINT";
+ case VK_FORMAT_R8G8_SINT:
+ return "VK_FORMAT_R8G8_SINT";
+ case VK_FORMAT_R8G8_SRGB:
+ return "VK_FORMAT_R8G8_SRGB";
+ case VK_FORMAT_R8G8B8_UNORM:
+ return "VK_FORMAT_R8G8B8_UNORM";
+ case VK_FORMAT_R8G8B8_SNORM:
+ return "VK_FORMAT_R8G8B8_SNORM";
+ case VK_FORMAT_R8G8B8_USCALED:
+ return "VK_FORMAT_R8G8B8_USCALED";
+ case VK_FORMAT_R8G8B8_SSCALED:
+ return "VK_FORMAT_R8G8B8_SSCALED";
+ case VK_FORMAT_R8G8B8_UINT:
+ return "VK_FORMAT_R8G8B8_UINT";
+ case VK_FORMAT_R8G8B8_SINT:
+ return "VK_FORMAT_R8G8B8_SINT";
+ case VK_FORMAT_R8G8B8_SRGB:
+ return "VK_FORMAT_R8G8B8_SRGB";
+ case VK_FORMAT_B8G8R8_UNORM:
+ return "VK_FORMAT_B8G8R8_UNORM";
+ case VK_FORMAT_B8G8R8_SNORM:
+ return "VK_FORMAT_B8G8R8_SNORM";
+ case VK_FORMAT_B8G8R8_USCALED:
+ return "VK_FORMAT_B8G8R8_USCALED";
+ case VK_FORMAT_B8G8R8_SSCALED:
+ return "VK_FORMAT_B8G8R8_SSCALED";
+ case VK_FORMAT_B8G8R8_UINT:
+ return "VK_FORMAT_B8G8R8_UINT";
+ case VK_FORMAT_B8G8R8_SINT:
+ return "VK_FORMAT_B8G8R8_SINT";
+ case VK_FORMAT_B8G8R8_SRGB:
+ return "VK_FORMAT_B8G8R8_SRGB";
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ return "VK_FORMAT_R8G8B8A8_UNORM";
+ case VK_FORMAT_R8G8B8A8_SNORM:
+ return "VK_FORMAT_R8G8B8A8_SNORM";
+ case VK_FORMAT_R8G8B8A8_USCALED:
+ return "VK_FORMAT_R8G8B8A8_USCALED";
+ case VK_FORMAT_R8G8B8A8_SSCALED:
+ return "VK_FORMAT_R8G8B8A8_SSCALED";
+ case VK_FORMAT_R8G8B8A8_UINT:
+ return "VK_FORMAT_R8G8B8A8_UINT";
+ case VK_FORMAT_R8G8B8A8_SINT:
+ return "VK_FORMAT_R8G8B8A8_SINT";
+ case VK_FORMAT_R8G8B8A8_SRGB:
+ return "VK_FORMAT_R8G8B8A8_SRGB";
+ case VK_FORMAT_B8G8R8A8_UNORM:
+ return "VK_FORMAT_B8G8R8A8_UNORM";
+ case VK_FORMAT_B8G8R8A8_SNORM:
+ return "VK_FORMAT_B8G8R8A8_SNORM";
+ case VK_FORMAT_B8G8R8A8_USCALED:
+ return "VK_FORMAT_B8G8R8A8_USCALED";
+ case VK_FORMAT_B8G8R8A8_SSCALED:
+ return "VK_FORMAT_B8G8R8A8_SSCALED";
+ case VK_FORMAT_B8G8R8A8_UINT:
+ return "VK_FORMAT_B8G8R8A8_UINT";
+ case VK_FORMAT_B8G8R8A8_SINT:
+ return "VK_FORMAT_B8G8R8A8_SINT";
+ case VK_FORMAT_B8G8R8A8_SRGB:
+ return "VK_FORMAT_B8G8R8A8_SRGB";
+ case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+ return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
+ case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
+ return "VK_FORMAT_A8B8G8R8_SNORM_PACK32";
+ case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
+ return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
+ case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
+ return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32";
+ case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+ return "VK_FORMAT_A8B8G8R8_UINT_PACK32";
+ case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+ return "VK_FORMAT_A8B8G8R8_SINT_PACK32";
+ case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+ return "VK_FORMAT_A8B8G8R8_SRGB_PACK32";
+ case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+ return "VK_FORMAT_A2R10G10B10_UNORM_PACK32";
+ case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
+ return "VK_FORMAT_A2R10G10B10_SNORM_PACK32";
+ case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
+ return "VK_FORMAT_A2R10G10B10_USCALED_PACK32";
+ case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
+ return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32";
+ case VK_FORMAT_A2R10G10B10_UINT_PACK32:
+ return "VK_FORMAT_A2R10G10B10_UINT_PACK32";
+ case VK_FORMAT_A2R10G10B10_SINT_PACK32:
+ return "VK_FORMAT_A2R10G10B10_SINT_PACK32";
+ case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+ return "VK_FORMAT_A2B10G10R10_UNORM_PACK32";
+ case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
+ return "VK_FORMAT_A2B10G10R10_SNORM_PACK32";
+ case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
+ return "VK_FORMAT_A2B10G10R10_USCALED_PACK32";
+ case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
+ return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32";
+ case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+ return "VK_FORMAT_A2B10G10R10_UINT_PACK32";
+ case VK_FORMAT_A2B10G10R10_SINT_PACK32:
+ return "VK_FORMAT_A2B10G10R10_SINT_PACK32";
+ case VK_FORMAT_R16_UNORM:
+ return "VK_FORMAT_R16_UNORM";
+ case VK_FORMAT_R16_SNORM:
+ return "VK_FORMAT_R16_SNORM";
+ case VK_FORMAT_R16_USCALED:
+ return "VK_FORMAT_R16_USCALED";
+ case VK_FORMAT_R16_SSCALED:
+ return "VK_FORMAT_R16_SSCALED";
+ case VK_FORMAT_R16_UINT:
+ return "VK_FORMAT_R16_UINT";
+ case VK_FORMAT_R16_SINT:
+ return "VK_FORMAT_R16_SINT";
+ case VK_FORMAT_R16_SFLOAT:
+ return "VK_FORMAT_R16_SFLOAT";
+ case VK_FORMAT_R16G16_UNORM:
+ return "VK_FORMAT_R16G16_UNORM";
+ case VK_FORMAT_R16G16_SNORM:
+ return "VK_FORMAT_R16G16_SNORM";
+ case VK_FORMAT_R16G16_USCALED:
+ return "VK_FORMAT_R16G16_USCALED";
+ case VK_FORMAT_R16G16_SSCALED:
+ return "VK_FORMAT_R16G16_SSCALED";
+ case VK_FORMAT_R16G16_UINT:
+ return "VK_FORMAT_R16G16_UINT";
+ case VK_FORMAT_R16G16_SINT:
+ return "VK_FORMAT_R16G16_SINT";
+ case VK_FORMAT_R16G16_SFLOAT:
+ return "VK_FORMAT_R16G16_SFLOAT";
+ case VK_FORMAT_R16G16B16_UNORM:
+ return "VK_FORMAT_R16G16B16_UNORM";
+ case VK_FORMAT_R16G16B16_SNORM:
+ return "VK_FORMAT_R16G16B16_SNORM";
+ case VK_FORMAT_R16G16B16_USCALED:
+ return "VK_FORMAT_R16G16B16_USCALED";
+ case VK_FORMAT_R16G16B16_SSCALED:
+ return "VK_FORMAT_R16G16B16_SSCALED";
+ case VK_FORMAT_R16G16B16_UINT:
+ return "VK_FORMAT_R16G16B16_UINT";
+ case VK_FORMAT_R16G16B16_SINT:
+ return "VK_FORMAT_R16G16B16_SINT";
+ case VK_FORMAT_R16G16B16_SFLOAT:
+ return "VK_FORMAT_R16G16B16_SFLOAT";
+ case VK_FORMAT_R16G16B16A16_UNORM:
+ return "VK_FORMAT_R16G16B16A16_UNORM";
+ case VK_FORMAT_R16G16B16A16_SNORM:
+ return "VK_FORMAT_R16G16B16A16_SNORM";
+ case VK_FORMAT_R16G16B16A16_USCALED:
+ return "VK_FORMAT_R16G16B16A16_USCALED";
+ case VK_FORMAT_R16G16B16A16_SSCALED:
+ return "VK_FORMAT_R16G16B16A16_SSCALED";
+ case VK_FORMAT_R16G16B16A16_UINT:
+ return "VK_FORMAT_R16G16B16A16_UINT";
+ case VK_FORMAT_R16G16B16A16_SINT:
+ return "VK_FORMAT_R16G16B16A16_SINT";
+ case VK_FORMAT_R16G16B16A16_SFLOAT:
+ return "VK_FORMAT_R16G16B16A16_SFLOAT";
+ case VK_FORMAT_R32_UINT:
+ return "VK_FORMAT_R32_UINT";
+ case VK_FORMAT_R32_SINT:
+ return "VK_FORMAT_R32_SINT";
+ case VK_FORMAT_R32_SFLOAT:
+ return "VK_FORMAT_R32_SFLOAT";
+ case VK_FORMAT_R32G32_UINT:
+ return "VK_FORMAT_R32G32_UINT";
+ case VK_FORMAT_R32G32_SINT:
+ return "VK_FORMAT_R32G32_SINT";
+ case VK_FORMAT_R32G32_SFLOAT:
+ return "VK_FORMAT_R32G32_SFLOAT";
+ case VK_FORMAT_R32G32B32_UINT:
+ return "VK_FORMAT_R32G32B32_UINT";
+ case VK_FORMAT_R32G32B32_SINT:
+ return "VK_FORMAT_R32G32B32_SINT";
+ case VK_FORMAT_R32G32B32_SFLOAT:
+ return "VK_FORMAT_R32G32B32_SFLOAT";
+ case VK_FORMAT_R32G32B32A32_UINT:
+ return "VK_FORMAT_R32G32B32A32_UINT";
+ case VK_FORMAT_R32G32B32A32_SINT:
+ return "VK_FORMAT_R32G32B32A32_SINT";
+ case VK_FORMAT_R32G32B32A32_SFLOAT:
+ return "VK_FORMAT_R32G32B32A32_SFLOAT";
+ case VK_FORMAT_R64_UINT:
+ return "VK_FORMAT_R64_UINT";
+ case VK_FORMAT_R64_SINT:
+ return "VK_FORMAT_R64_SINT";
+ case VK_FORMAT_R64_SFLOAT:
+ return "VK_FORMAT_R64_SFLOAT";
+ case VK_FORMAT_R64G64_UINT:
+ return "VK_FORMAT_R64G64_UINT";
+ case VK_FORMAT_R64G64_SINT:
+ return "VK_FORMAT_R64G64_SINT";
+ case VK_FORMAT_R64G64_SFLOAT:
+ return "VK_FORMAT_R64G64_SFLOAT";
+ case VK_FORMAT_R64G64B64_UINT:
+ return "VK_FORMAT_R64G64B64_UINT";
+ case VK_FORMAT_R64G64B64_SINT:
+ return "VK_FORMAT_R64G64B64_SINT";
+ case VK_FORMAT_R64G64B64_SFLOAT:
+ return "VK_FORMAT_R64G64B64_SFLOAT";
+ case VK_FORMAT_R64G64B64A64_UINT:
+ return "VK_FORMAT_R64G64B64A64_UINT";
+ case VK_FORMAT_R64G64B64A64_SINT:
+ return "VK_FORMAT_R64G64B64A64_SINT";
+ case VK_FORMAT_R64G64B64A64_SFLOAT:
+ return "VK_FORMAT_R64G64B64A64_SFLOAT";
+ case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+ return "VK_FORMAT_B10G11R11_UFLOAT_PACK32";
+ case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+ return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32";
+ case VK_FORMAT_D16_UNORM:
+ return "VK_FORMAT_D16_UNORM";
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ return "VK_FORMAT_X8_D24_UNORM_PACK32";
+ case VK_FORMAT_D32_SFLOAT:
+ return "VK_FORMAT_D32_SFLOAT";
+ case VK_FORMAT_S8_UINT:
+ return "VK_FORMAT_S8_UINT";
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ return "VK_FORMAT_D16_UNORM_S8_UINT";
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ return "VK_FORMAT_D24_UNORM_S8_UINT";
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return "VK_FORMAT_D32_SFLOAT_S8_UINT";
+ case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
+ return "VK_FORMAT_BC1_RGB_UNORM_BLOCK";
+ case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
+ return "VK_FORMAT_BC1_RGB_SRGB_BLOCK";
+ case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
+ return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK";
+ case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
+ return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK";
+ case VK_FORMAT_BC2_UNORM_BLOCK:
+ return "VK_FORMAT_BC2_UNORM_BLOCK";
+ case VK_FORMAT_BC2_SRGB_BLOCK:
+ return "VK_FORMAT_BC2_SRGB_BLOCK";
+ case VK_FORMAT_BC3_UNORM_BLOCK:
+ return "VK_FORMAT_BC3_UNORM_BLOCK";
+ case VK_FORMAT_BC3_SRGB_BLOCK:
+ return "VK_FORMAT_BC3_SRGB_BLOCK";
+ case VK_FORMAT_BC4_UNORM_BLOCK:
+ return "VK_FORMAT_BC4_UNORM_BLOCK";
+ case VK_FORMAT_BC4_SNORM_BLOCK:
+ return "VK_FORMAT_BC4_SNORM_BLOCK";
+ case VK_FORMAT_BC5_UNORM_BLOCK:
+ return "VK_FORMAT_BC5_UNORM_BLOCK";
+ case VK_FORMAT_BC5_SNORM_BLOCK:
+ return "VK_FORMAT_BC5_SNORM_BLOCK";
+ case VK_FORMAT_BC6H_UFLOAT_BLOCK:
+ return "VK_FORMAT_BC6H_UFLOAT_BLOCK";
+ case VK_FORMAT_BC6H_SFLOAT_BLOCK:
+ return "VK_FORMAT_BC6H_SFLOAT_BLOCK";
+ case VK_FORMAT_BC7_UNORM_BLOCK:
+ return "VK_FORMAT_BC7_UNORM_BLOCK";
+ case VK_FORMAT_BC7_SRGB_BLOCK:
+ return "VK_FORMAT_BC7_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+ return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
+ case VK_FORMAT_EAC_R11_UNORM_BLOCK:
+ return "VK_FORMAT_EAC_R11_UNORM_BLOCK";
+ case VK_FORMAT_EAC_R11_SNORM_BLOCK:
+ return "VK_FORMAT_EAC_R11_SNORM_BLOCK";
+ case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
+ return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK";
+ case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
+ return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK";
+ case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
+ case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
+ return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
+ case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
+ return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
+ case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
+ case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
+ case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
+ case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
+ case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
+ case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
+ case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
+ case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
+ return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
+ default:
+ return "Unhandled VkFormat";
+ }
+}
+
+static inline const char* string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value)
+{
+ switch ((VkFormatFeatureFlagBits)input_value)
+ {
+ case VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT:
+ return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT";
+ case VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT:
+ return "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT";
+ case VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT:
+ return "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT";
+ case VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT:
+ return "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT";
+ case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT:
+ return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT";
+ case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT:
+ return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
+ case VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT:
+ return "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT";
+ case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT:
+ return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT";
+ case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT:
+ return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT";
+ case VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case VK_FORMAT_FEATURE_BLIT_SRC_BIT:
+ return "VK_FORMAT_FEATURE_BLIT_SRC_BIT";
+ case VK_FORMAT_FEATURE_BLIT_DST_BIT:
+ return "VK_FORMAT_FEATURE_BLIT_DST_BIT";
+ case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT:
+ return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
+ case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG:
+ return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG";
+ case VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR:
+ return "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR";
+ case VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR:
+ return "VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR";
+ case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT:
+ return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT";
+ default:
+ return "Unhandled VkFormatFeatureFlagBits";
+ }
+}
+
+static inline const char* string_VkImageType(VkImageType input_value)
+{
+ switch ((VkImageType)input_value)
+ {
+ case VK_IMAGE_TYPE_1D:
+ return "VK_IMAGE_TYPE_1D";
+ case VK_IMAGE_TYPE_2D:
+ return "VK_IMAGE_TYPE_2D";
+ case VK_IMAGE_TYPE_3D:
+ return "VK_IMAGE_TYPE_3D";
+ default:
+ return "Unhandled VkImageType";
+ }
+}
+
+static inline const char* string_VkImageTiling(VkImageTiling input_value)
+{
+ switch ((VkImageTiling)input_value)
+ {
+ case VK_IMAGE_TILING_OPTIMAL:
+ return "VK_IMAGE_TILING_OPTIMAL";
+ case VK_IMAGE_TILING_LINEAR:
+ return "VK_IMAGE_TILING_LINEAR";
+ case VK_IMAGE_TILING_SCANOUT_GOOGLE:
+ return "VK_IMAGE_TILING_SCANOUT_GOOGLE";
+ default:
+ return "Unhandled VkImageTiling";
+ }
+}
+
+static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)
+{
+ switch ((VkImageUsageFlagBits)input_value)
+ {
+ case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
+ return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
+ case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
+ return "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
+ case VK_IMAGE_USAGE_SAMPLED_BIT:
+ return "VK_IMAGE_USAGE_SAMPLED_BIT";
+ case VK_IMAGE_USAGE_STORAGE_BIT:
+ return "VK_IMAGE_USAGE_STORAGE_BIT";
+ case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT:
+ return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
+ case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
+ return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
+ default:
+ return "Unhandled VkImageUsageFlagBits";
+ }
+}
+
+static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)
+{
+ switch ((VkImageCreateFlagBits)input_value)
+ {
+ case VK_IMAGE_CREATE_SPARSE_BINDING_BIT:
+ return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT";
+ case VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT:
+ return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT";
+ case VK_IMAGE_CREATE_SPARSE_ALIASED_BIT:
+ return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT";
+ case VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
+ return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT";
+ case VK_IMAGE_CREATE_BIND_SFR_BIT_KHX:
+ return "VK_IMAGE_CREATE_BIND_SFR_BIT_KHX";
+ case VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR:
+ return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR";
+ default:
+ return "Unhandled VkImageCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)
+{
+ switch ((VkSampleCountFlagBits)input_value)
+ {
+ case VK_SAMPLE_COUNT_1_BIT:
+ return "VK_SAMPLE_COUNT_1_BIT";
+ case VK_SAMPLE_COUNT_2_BIT:
+ return "VK_SAMPLE_COUNT_2_BIT";
+ case VK_SAMPLE_COUNT_4_BIT:
+ return "VK_SAMPLE_COUNT_4_BIT";
+ case VK_SAMPLE_COUNT_8_BIT:
+ return "VK_SAMPLE_COUNT_8_BIT";
+ case VK_SAMPLE_COUNT_16_BIT:
+ return "VK_SAMPLE_COUNT_16_BIT";
+ case VK_SAMPLE_COUNT_32_BIT:
+ return "VK_SAMPLE_COUNT_32_BIT";
+ case VK_SAMPLE_COUNT_64_BIT:
+ return "VK_SAMPLE_COUNT_64_BIT";
+ default:
+ return "Unhandled VkSampleCountFlagBits";
+ }
+}
+
+static inline const char* string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)
+{
+ switch ((VkPhysicalDeviceType)input_value)
+ {
+ case VK_PHYSICAL_DEVICE_TYPE_OTHER:
+ return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
+ case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
+ return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
+ return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
+ return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_CPU:
+ return "VK_PHYSICAL_DEVICE_TYPE_CPU";
+ default:
+ return "Unhandled VkPhysicalDeviceType";
+ }
+}
+
+static inline const char* string_VkQueueFlagBits(VkQueueFlagBits input_value)
+{
+ switch ((VkQueueFlagBits)input_value)
+ {
+ case VK_QUEUE_GRAPHICS_BIT:
+ return "VK_QUEUE_GRAPHICS_BIT";
+ case VK_QUEUE_COMPUTE_BIT:
+ return "VK_QUEUE_COMPUTE_BIT";
+ case VK_QUEUE_TRANSFER_BIT:
+ return "VK_QUEUE_TRANSFER_BIT";
+ case VK_QUEUE_SPARSE_BINDING_BIT:
+ return "VK_QUEUE_SPARSE_BINDING_BIT";
+ default:
+ return "Unhandled VkQueueFlagBits";
+ }
+}
+
+static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)
+{
+ switch ((VkMemoryPropertyFlagBits)input_value)
+ {
+ case VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT:
+ return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
+ case VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT:
+ return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT";
+ case VK_MEMORY_PROPERTY_HOST_COHERENT_BIT:
+ return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT";
+ case VK_MEMORY_PROPERTY_HOST_CACHED_BIT:
+ return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
+ case VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT:
+ return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT";
+ default:
+ return "Unhandled VkMemoryPropertyFlagBits";
+ }
+}
+
+static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)
+{
+ switch ((VkMemoryHeapFlagBits)input_value)
+ {
+ case VK_MEMORY_HEAP_DEVICE_LOCAL_BIT:
+ return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
+ case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX:
+ return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX";
+ default:
+ return "Unhandled VkMemoryHeapFlagBits";
+ }
+}
+
+static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)
+{
+ switch ((VkPipelineStageFlagBits)input_value)
+ {
+ case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
+ return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT";
+ case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
+ return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT";
+ case VK_PIPELINE_STAGE_VERTEX_INPUT_BIT:
+ return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT";
+ case VK_PIPELINE_STAGE_VERTEX_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT";
+ case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT";
+ case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT";
+ case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT";
+ case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT";
+ case VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
+ return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT";
+ case VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
+ return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT";
+ case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
+ return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT";
+ case VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
+ return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT";
+ case VK_PIPELINE_STAGE_TRANSFER_BIT:
+ return "VK_PIPELINE_STAGE_TRANSFER_BIT";
+ case VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
+ return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT";
+ case VK_PIPELINE_STAGE_HOST_BIT:
+ return "VK_PIPELINE_STAGE_HOST_BIT";
+ case VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
+ return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT";
+ case VK_PIPELINE_STAGE_ALL_COMMANDS_BIT:
+ return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT";
+ case VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX:
+ return "VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX";
+ default:
+ return "Unhandled VkPipelineStageFlagBits";
+ }
+}
+
+static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)
+{
+ switch ((VkImageAspectFlagBits)input_value)
+ {
+ case VK_IMAGE_ASPECT_COLOR_BIT:
+ return "VK_IMAGE_ASPECT_COLOR_BIT";
+ case VK_IMAGE_ASPECT_DEPTH_BIT:
+ return "VK_IMAGE_ASPECT_DEPTH_BIT";
+ case VK_IMAGE_ASPECT_STENCIL_BIT:
+ return "VK_IMAGE_ASPECT_STENCIL_BIT";
+ case VK_IMAGE_ASPECT_METADATA_BIT:
+ return "VK_IMAGE_ASPECT_METADATA_BIT";
+ default:
+ return "Unhandled VkImageAspectFlagBits";
+ }
+}
+
+static inline const char* string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)
+{
+ switch ((VkSparseImageFormatFlagBits)input_value)
+ {
+ case VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT:
+ return "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT";
+ case VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT:
+ return "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT";
+ case VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT:
+ return "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT";
+ default:
+ return "Unhandled VkSparseImageFormatFlagBits";
+ }
+}
+
+static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)
+{
+ switch ((VkSparseMemoryBindFlagBits)input_value)
+ {
+ case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
+ return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
+ default:
+ return "Unhandled VkSparseMemoryBindFlagBits";
+ }
+}
+
+static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)
+{
+ switch ((VkFenceCreateFlagBits)input_value)
+ {
+ case VK_FENCE_CREATE_SIGNALED_BIT:
+ return "VK_FENCE_CREATE_SIGNALED_BIT";
+ default:
+ return "Unhandled VkFenceCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkQueryType(VkQueryType input_value)
+{
+ switch ((VkQueryType)input_value)
+ {
+ case VK_QUERY_TYPE_OCCLUSION:
+ return "VK_QUERY_TYPE_OCCLUSION";
+ case VK_QUERY_TYPE_PIPELINE_STATISTICS:
+ return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
+ case VK_QUERY_TYPE_TIMESTAMP:
+ return "VK_QUERY_TYPE_TIMESTAMP";
+ default:
+ return "Unhandled VkQueryType";
+ }
+}
+
+static inline const char* string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)
+{
+ switch ((VkQueryPipelineStatisticFlagBits)input_value)
+ {
+ case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT";
+ case VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT:
+ return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT";
+ default:
+ return "Unhandled VkQueryPipelineStatisticFlagBits";
+ }
+}
+
+static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)
+{
+ switch ((VkQueryResultFlagBits)input_value)
+ {
+ case VK_QUERY_RESULT_64_BIT:
+ return "VK_QUERY_RESULT_64_BIT";
+ case VK_QUERY_RESULT_WAIT_BIT:
+ return "VK_QUERY_RESULT_WAIT_BIT";
+ case VK_QUERY_RESULT_WITH_AVAILABILITY_BIT:
+ return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT";
+ case VK_QUERY_RESULT_PARTIAL_BIT:
+ return "VK_QUERY_RESULT_PARTIAL_BIT";
+ default:
+ return "Unhandled VkQueryResultFlagBits";
+ }
+}
+
+static inline const char* string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)
+{
+ switch ((VkBufferCreateFlagBits)input_value)
+ {
+ case VK_BUFFER_CREATE_SPARSE_BINDING_BIT:
+ return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT";
+ case VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT:
+ return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT";
+ case VK_BUFFER_CREATE_SPARSE_ALIASED_BIT:
+ return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT";
+ default:
+ return "Unhandled VkBufferCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)
+{
+ switch ((VkBufferUsageFlagBits)input_value)
+ {
+ case VK_BUFFER_USAGE_TRANSFER_SRC_BIT:
+ return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT";
+ case VK_BUFFER_USAGE_TRANSFER_DST_BIT:
+ return "VK_BUFFER_USAGE_TRANSFER_DST_BIT";
+ case VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT";
+ case VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT";
+ case VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT";
+ case VK_BUFFER_USAGE_STORAGE_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT";
+ case VK_BUFFER_USAGE_INDEX_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
+ case VK_BUFFER_USAGE_VERTEX_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
+ case VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT:
+ return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
+ default:
+ return "Unhandled VkBufferUsageFlagBits";
+ }
+}
+
+static inline const char* string_VkSharingMode(VkSharingMode input_value)
+{
+ switch ((VkSharingMode)input_value)
+ {
+ case VK_SHARING_MODE_EXCLUSIVE:
+ return "VK_SHARING_MODE_EXCLUSIVE";
+ case VK_SHARING_MODE_CONCURRENT:
+ return "VK_SHARING_MODE_CONCURRENT";
+ default:
+ return "Unhandled VkSharingMode";
+ }
+}
+
+static inline const char* string_VkImageLayout(VkImageLayout input_value)
+{
+ switch ((VkImageLayout)input_value)
+ {
+ case VK_IMAGE_LAYOUT_UNDEFINED:
+ return "VK_IMAGE_LAYOUT_UNDEFINED";
+ case VK_IMAGE_LAYOUT_GENERAL:
+ return "VK_IMAGE_LAYOUT_GENERAL";
+ case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+ return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
+ case VK_IMAGE_LAYOUT_PREINITIALIZED:
+ return "VK_IMAGE_LAYOUT_PREINITIALIZED";
+ case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
+ return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
+ case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
+ return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
+ default:
+ return "Unhandled VkImageLayout";
+ }
+}
+
+static inline const char* string_VkImageViewType(VkImageViewType input_value)
+{
+ switch ((VkImageViewType)input_value)
+ {
+ case VK_IMAGE_VIEW_TYPE_1D:
+ return "VK_IMAGE_VIEW_TYPE_1D";
+ case VK_IMAGE_VIEW_TYPE_2D:
+ return "VK_IMAGE_VIEW_TYPE_2D";
+ case VK_IMAGE_VIEW_TYPE_3D:
+ return "VK_IMAGE_VIEW_TYPE_3D";
+ case VK_IMAGE_VIEW_TYPE_CUBE:
+ return "VK_IMAGE_VIEW_TYPE_CUBE";
+ case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+ return "VK_IMAGE_VIEW_TYPE_1D_ARRAY";
+ case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+ return "VK_IMAGE_VIEW_TYPE_2D_ARRAY";
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
+ return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY";
+ default:
+ return "Unhandled VkImageViewType";
+ }
+}
+
+static inline const char* string_VkComponentSwizzle(VkComponentSwizzle input_value)
+{
+ switch ((VkComponentSwizzle)input_value)
+ {
+ case VK_COMPONENT_SWIZZLE_IDENTITY:
+ return "VK_COMPONENT_SWIZZLE_IDENTITY";
+ case VK_COMPONENT_SWIZZLE_ZERO:
+ return "VK_COMPONENT_SWIZZLE_ZERO";
+ case VK_COMPONENT_SWIZZLE_ONE:
+ return "VK_COMPONENT_SWIZZLE_ONE";
+ case VK_COMPONENT_SWIZZLE_R:
+ return "VK_COMPONENT_SWIZZLE_R";
+ case VK_COMPONENT_SWIZZLE_G:
+ return "VK_COMPONENT_SWIZZLE_G";
+ case VK_COMPONENT_SWIZZLE_B:
+ return "VK_COMPONENT_SWIZZLE_B";
+ case VK_COMPONENT_SWIZZLE_A:
+ return "VK_COMPONENT_SWIZZLE_A";
+ default:
+ return "Unhandled VkComponentSwizzle";
+ }
+}
+
+static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)
+{
+ switch ((VkPipelineCreateFlagBits)input_value)
+ {
+ case VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+ case VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT:
+ return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
+ case VK_PIPELINE_CREATE_DERIVATIVE_BIT:
+ return "VK_PIPELINE_CREATE_DERIVATIVE_BIT";
+ case VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX:
+ return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX";
+ case VK_PIPELINE_CREATE_DISPATCH_BASE_KHX:
+ return "VK_PIPELINE_CREATE_DISPATCH_BASE_KHX";
+ default:
+ return "Unhandled VkPipelineCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)
+{
+ switch ((VkShaderStageFlagBits)input_value)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ return "VK_SHADER_STAGE_VERTEX_BIT";
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ return "VK_SHADER_STAGE_GEOMETRY_BIT";
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ return "VK_SHADER_STAGE_FRAGMENT_BIT";
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ return "VK_SHADER_STAGE_COMPUTE_BIT";
+ case VK_SHADER_STAGE_ALL_GRAPHICS:
+ return "VK_SHADER_STAGE_ALL_GRAPHICS";
+ case VK_SHADER_STAGE_ALL:
+ return "VK_SHADER_STAGE_ALL";
+ default:
+ return "Unhandled VkShaderStageFlagBits";
+ }
+}
+
+static inline const char* string_VkVertexInputRate(VkVertexInputRate input_value)
+{
+ switch ((VkVertexInputRate)input_value)
+ {
+ case VK_VERTEX_INPUT_RATE_VERTEX:
+ return "VK_VERTEX_INPUT_RATE_VERTEX";
+ case VK_VERTEX_INPUT_RATE_INSTANCE:
+ return "VK_VERTEX_INPUT_RATE_INSTANCE";
+ default:
+ return "Unhandled VkVertexInputRate";
+ }
+}
+
+static inline const char* string_VkPrimitiveTopology(VkPrimitiveTopology input_value)
+{
+ switch ((VkPrimitiveTopology)input_value)
+ {
+ case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+ return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+ return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+ return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+ return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+ return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+ return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
+ return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
+ return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
+ return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
+ return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY";
+ case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
+ return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST";
+ default:
+ return "Unhandled VkPrimitiveTopology";
+ }
+}
+
+static inline const char* string_VkPolygonMode(VkPolygonMode input_value)
+{
+ switch ((VkPolygonMode)input_value)
+ {
+ case VK_POLYGON_MODE_FILL:
+ return "VK_POLYGON_MODE_FILL";
+ case VK_POLYGON_MODE_LINE:
+ return "VK_POLYGON_MODE_LINE";
+ case VK_POLYGON_MODE_POINT:
+ return "VK_POLYGON_MODE_POINT";
+ case VK_POLYGON_MODE_FILL_RECTANGLE_NV:
+ return "VK_POLYGON_MODE_FILL_RECTANGLE_NV";
+ default:
+ return "Unhandled VkPolygonMode";
+ }
+}
+
+static inline const char* string_VkCullModeFlagBits(VkCullModeFlagBits input_value)
+{
+ switch ((VkCullModeFlagBits)input_value)
+ {
+ case VK_CULL_MODE_NONE:
+ return "VK_CULL_MODE_NONE";
+ case VK_CULL_MODE_FRONT_BIT:
+ return "VK_CULL_MODE_FRONT_BIT";
+ case VK_CULL_MODE_BACK_BIT:
+ return "VK_CULL_MODE_BACK_BIT";
+ case VK_CULL_MODE_FRONT_AND_BACK:
+ return "VK_CULL_MODE_FRONT_AND_BACK";
+ default:
+ return "Unhandled VkCullModeFlagBits";
+ }
+}
+
+static inline const char* string_VkFrontFace(VkFrontFace input_value)
+{
+ switch ((VkFrontFace)input_value)
+ {
+ case VK_FRONT_FACE_COUNTER_CLOCKWISE:
+ return "VK_FRONT_FACE_COUNTER_CLOCKWISE";
+ case VK_FRONT_FACE_CLOCKWISE:
+ return "VK_FRONT_FACE_CLOCKWISE";
+ default:
+ return "Unhandled VkFrontFace";
+ }
+}
+
+static inline const char* string_VkCompareOp(VkCompareOp input_value)
+{
+ switch ((VkCompareOp)input_value)
+ {
+ case VK_COMPARE_OP_NEVER:
+ return "VK_COMPARE_OP_NEVER";
+ case VK_COMPARE_OP_LESS:
+ return "VK_COMPARE_OP_LESS";
+ case VK_COMPARE_OP_EQUAL:
+ return "VK_COMPARE_OP_EQUAL";
+ case VK_COMPARE_OP_LESS_OR_EQUAL:
+ return "VK_COMPARE_OP_LESS_OR_EQUAL";
+ case VK_COMPARE_OP_GREATER:
+ return "VK_COMPARE_OP_GREATER";
+ case VK_COMPARE_OP_NOT_EQUAL:
+ return "VK_COMPARE_OP_NOT_EQUAL";
+ case VK_COMPARE_OP_GREATER_OR_EQUAL:
+ return "VK_COMPARE_OP_GREATER_OR_EQUAL";
+ case VK_COMPARE_OP_ALWAYS:
+ return "VK_COMPARE_OP_ALWAYS";
+ default:
+ return "Unhandled VkCompareOp";
+ }
+}
+
+static inline const char* string_VkStencilOp(VkStencilOp input_value)
+{
+ switch ((VkStencilOp)input_value)
+ {
+ case VK_STENCIL_OP_KEEP:
+ return "VK_STENCIL_OP_KEEP";
+ case VK_STENCIL_OP_ZERO:
+ return "VK_STENCIL_OP_ZERO";
+ case VK_STENCIL_OP_REPLACE:
+ return "VK_STENCIL_OP_REPLACE";
+ case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
+ return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
+ case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
+ return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
+ case VK_STENCIL_OP_INVERT:
+ return "VK_STENCIL_OP_INVERT";
+ case VK_STENCIL_OP_INCREMENT_AND_WRAP:
+ return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
+ case VK_STENCIL_OP_DECREMENT_AND_WRAP:
+ return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
+ default:
+ return "Unhandled VkStencilOp";
+ }
+}
+
+static inline const char* string_VkLogicOp(VkLogicOp input_value)
+{
+ switch ((VkLogicOp)input_value)
+ {
+ case VK_LOGIC_OP_CLEAR:
+ return "VK_LOGIC_OP_CLEAR";
+ case VK_LOGIC_OP_AND:
+ return "VK_LOGIC_OP_AND";
+ case VK_LOGIC_OP_AND_REVERSE:
+ return "VK_LOGIC_OP_AND_REVERSE";
+ case VK_LOGIC_OP_COPY:
+ return "VK_LOGIC_OP_COPY";
+ case VK_LOGIC_OP_AND_INVERTED:
+ return "VK_LOGIC_OP_AND_INVERTED";
+ case VK_LOGIC_OP_NO_OP:
+ return "VK_LOGIC_OP_NO_OP";
+ case VK_LOGIC_OP_XOR:
+ return "VK_LOGIC_OP_XOR";
+ case VK_LOGIC_OP_OR:
+ return "VK_LOGIC_OP_OR";
+ case VK_LOGIC_OP_NOR:
+ return "VK_LOGIC_OP_NOR";
+ case VK_LOGIC_OP_EQUIVALENT:
+ return "VK_LOGIC_OP_EQUIVALENT";
+ case VK_LOGIC_OP_INVERT:
+ return "VK_LOGIC_OP_INVERT";
+ case VK_LOGIC_OP_OR_REVERSE:
+ return "VK_LOGIC_OP_OR_REVERSE";
+ case VK_LOGIC_OP_COPY_INVERTED:
+ return "VK_LOGIC_OP_COPY_INVERTED";
+ case VK_LOGIC_OP_OR_INVERTED:
+ return "VK_LOGIC_OP_OR_INVERTED";
+ case VK_LOGIC_OP_NAND:
+ return "VK_LOGIC_OP_NAND";
+ case VK_LOGIC_OP_SET:
+ return "VK_LOGIC_OP_SET";
+ default:
+ return "Unhandled VkLogicOp";
+ }
+}
+
+static inline const char* string_VkBlendFactor(VkBlendFactor input_value)
+{
+ switch ((VkBlendFactor)input_value)
+ {
+ case VK_BLEND_FACTOR_ZERO:
+ return "VK_BLEND_FACTOR_ZERO";
+ case VK_BLEND_FACTOR_ONE:
+ return "VK_BLEND_FACTOR_ONE";
+ case VK_BLEND_FACTOR_SRC_COLOR:
+ return "VK_BLEND_FACTOR_SRC_COLOR";
+ case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
+ return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR";
+ case VK_BLEND_FACTOR_DST_COLOR:
+ return "VK_BLEND_FACTOR_DST_COLOR";
+ case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
+ return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR";
+ case VK_BLEND_FACTOR_SRC_ALPHA:
+ return "VK_BLEND_FACTOR_SRC_ALPHA";
+ case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
+ return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA";
+ case VK_BLEND_FACTOR_DST_ALPHA:
+ return "VK_BLEND_FACTOR_DST_ALPHA";
+ case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
+ return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA";
+ case VK_BLEND_FACTOR_CONSTANT_COLOR:
+ return "VK_BLEND_FACTOR_CONSTANT_COLOR";
+ case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
+ return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR";
+ case VK_BLEND_FACTOR_CONSTANT_ALPHA:
+ return "VK_BLEND_FACTOR_CONSTANT_ALPHA";
+ case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
+ return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA";
+ case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
+ return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE";
+ case VK_BLEND_FACTOR_SRC1_COLOR:
+ return "VK_BLEND_FACTOR_SRC1_COLOR";
+ case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
+ return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR";
+ case VK_BLEND_FACTOR_SRC1_ALPHA:
+ return "VK_BLEND_FACTOR_SRC1_ALPHA";
+ case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
+ return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA";
+ default:
+ return "Unhandled VkBlendFactor";
+ }
+}
+
+static inline const char* string_VkBlendOp(VkBlendOp input_value)
+{
+ switch ((VkBlendOp)input_value)
+ {
+ case VK_BLEND_OP_ADD:
+ return "VK_BLEND_OP_ADD";
+ case VK_BLEND_OP_SUBTRACT:
+ return "VK_BLEND_OP_SUBTRACT";
+ case VK_BLEND_OP_REVERSE_SUBTRACT:
+ return "VK_BLEND_OP_REVERSE_SUBTRACT";
+ case VK_BLEND_OP_MIN:
+ return "VK_BLEND_OP_MIN";
+ case VK_BLEND_OP_MAX:
+ return "VK_BLEND_OP_MAX";
+ case VK_BLEND_OP_ZERO_EXT:
+ return "VK_BLEND_OP_ZERO_EXT";
+ case VK_BLEND_OP_SRC_EXT:
+ return "VK_BLEND_OP_SRC_EXT";
+ case VK_BLEND_OP_DST_EXT:
+ return "VK_BLEND_OP_DST_EXT";
+ case VK_BLEND_OP_SRC_OVER_EXT:
+ return "VK_BLEND_OP_SRC_OVER_EXT";
+ case VK_BLEND_OP_DST_OVER_EXT:
+ return "VK_BLEND_OP_DST_OVER_EXT";
+ case VK_BLEND_OP_SRC_IN_EXT:
+ return "VK_BLEND_OP_SRC_IN_EXT";
+ case VK_BLEND_OP_DST_IN_EXT:
+ return "VK_BLEND_OP_DST_IN_EXT";
+ case VK_BLEND_OP_SRC_OUT_EXT:
+ return "VK_BLEND_OP_SRC_OUT_EXT";
+ case VK_BLEND_OP_DST_OUT_EXT:
+ return "VK_BLEND_OP_DST_OUT_EXT";
+ case VK_BLEND_OP_SRC_ATOP_EXT:
+ return "VK_BLEND_OP_SRC_ATOP_EXT";
+ case VK_BLEND_OP_DST_ATOP_EXT:
+ return "VK_BLEND_OP_DST_ATOP_EXT";
+ case VK_BLEND_OP_XOR_EXT:
+ return "VK_BLEND_OP_XOR_EXT";
+ case VK_BLEND_OP_MULTIPLY_EXT:
+ return "VK_BLEND_OP_MULTIPLY_EXT";
+ case VK_BLEND_OP_SCREEN_EXT:
+ return "VK_BLEND_OP_SCREEN_EXT";
+ case VK_BLEND_OP_OVERLAY_EXT:
+ return "VK_BLEND_OP_OVERLAY_EXT";
+ case VK_BLEND_OP_DARKEN_EXT:
+ return "VK_BLEND_OP_DARKEN_EXT";
+ case VK_BLEND_OP_LIGHTEN_EXT:
+ return "VK_BLEND_OP_LIGHTEN_EXT";
+ case VK_BLEND_OP_COLORDODGE_EXT:
+ return "VK_BLEND_OP_COLORDODGE_EXT";
+ case VK_BLEND_OP_COLORBURN_EXT:
+ return "VK_BLEND_OP_COLORBURN_EXT";
+ case VK_BLEND_OP_HARDLIGHT_EXT:
+ return "VK_BLEND_OP_HARDLIGHT_EXT";
+ case VK_BLEND_OP_SOFTLIGHT_EXT:
+ return "VK_BLEND_OP_SOFTLIGHT_EXT";
+ case VK_BLEND_OP_DIFFERENCE_EXT:
+ return "VK_BLEND_OP_DIFFERENCE_EXT";
+ case VK_BLEND_OP_EXCLUSION_EXT:
+ return "VK_BLEND_OP_EXCLUSION_EXT";
+ case VK_BLEND_OP_INVERT_EXT:
+ return "VK_BLEND_OP_INVERT_EXT";
+ case VK_BLEND_OP_INVERT_RGB_EXT:
+ return "VK_BLEND_OP_INVERT_RGB_EXT";
+ case VK_BLEND_OP_LINEARDODGE_EXT:
+ return "VK_BLEND_OP_LINEARDODGE_EXT";
+ case VK_BLEND_OP_LINEARBURN_EXT:
+ return "VK_BLEND_OP_LINEARBURN_EXT";
+ case VK_BLEND_OP_VIVIDLIGHT_EXT:
+ return "VK_BLEND_OP_VIVIDLIGHT_EXT";
+ case VK_BLEND_OP_LINEARLIGHT_EXT:
+ return "VK_BLEND_OP_LINEARLIGHT_EXT";
+ case VK_BLEND_OP_PINLIGHT_EXT:
+ return "VK_BLEND_OP_PINLIGHT_EXT";
+ case VK_BLEND_OP_HARDMIX_EXT:
+ return "VK_BLEND_OP_HARDMIX_EXT";
+ case VK_BLEND_OP_HSL_HUE_EXT:
+ return "VK_BLEND_OP_HSL_HUE_EXT";
+ case VK_BLEND_OP_HSL_SATURATION_EXT:
+ return "VK_BLEND_OP_HSL_SATURATION_EXT";
+ case VK_BLEND_OP_HSL_COLOR_EXT:
+ return "VK_BLEND_OP_HSL_COLOR_EXT";
+ case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
+ return "VK_BLEND_OP_HSL_LUMINOSITY_EXT";
+ case VK_BLEND_OP_PLUS_EXT:
+ return "VK_BLEND_OP_PLUS_EXT";
+ case VK_BLEND_OP_PLUS_CLAMPED_EXT:
+ return "VK_BLEND_OP_PLUS_CLAMPED_EXT";
+ case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT:
+ return "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT";
+ case VK_BLEND_OP_PLUS_DARKER_EXT:
+ return "VK_BLEND_OP_PLUS_DARKER_EXT";
+ case VK_BLEND_OP_MINUS_EXT:
+ return "VK_BLEND_OP_MINUS_EXT";
+ case VK_BLEND_OP_MINUS_CLAMPED_EXT:
+ return "VK_BLEND_OP_MINUS_CLAMPED_EXT";
+ case VK_BLEND_OP_CONTRAST_EXT:
+ return "VK_BLEND_OP_CONTRAST_EXT";
+ case VK_BLEND_OP_INVERT_OVG_EXT:
+ return "VK_BLEND_OP_INVERT_OVG_EXT";
+ case VK_BLEND_OP_RED_EXT:
+ return "VK_BLEND_OP_RED_EXT";
+ case VK_BLEND_OP_GREEN_EXT:
+ return "VK_BLEND_OP_GREEN_EXT";
+ case VK_BLEND_OP_BLUE_EXT:
+ return "VK_BLEND_OP_BLUE_EXT";
+ default:
+ return "Unhandled VkBlendOp";
+ }
+}
+
+static inline const char* string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)
+{
+ switch ((VkColorComponentFlagBits)input_value)
+ {
+ case VK_COLOR_COMPONENT_R_BIT:
+ return "VK_COLOR_COMPONENT_R_BIT";
+ case VK_COLOR_COMPONENT_G_BIT:
+ return "VK_COLOR_COMPONENT_G_BIT";
+ case VK_COLOR_COMPONENT_B_BIT:
+ return "VK_COLOR_COMPONENT_B_BIT";
+ case VK_COLOR_COMPONENT_A_BIT:
+ return "VK_COLOR_COMPONENT_A_BIT";
+ default:
+ return "Unhandled VkColorComponentFlagBits";
+ }
+}
+
+static inline const char* string_VkDynamicState(VkDynamicState input_value)
+{
+ switch ((VkDynamicState)input_value)
+ {
+ case VK_DYNAMIC_STATE_VIEWPORT:
+ return "VK_DYNAMIC_STATE_VIEWPORT";
+ case VK_DYNAMIC_STATE_SCISSOR:
+ return "VK_DYNAMIC_STATE_SCISSOR";
+ case VK_DYNAMIC_STATE_LINE_WIDTH:
+ return "VK_DYNAMIC_STATE_LINE_WIDTH";
+ case VK_DYNAMIC_STATE_DEPTH_BIAS:
+ return "VK_DYNAMIC_STATE_DEPTH_BIAS";
+ case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
+ return "VK_DYNAMIC_STATE_BLEND_CONSTANTS";
+ case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
+ return "VK_DYNAMIC_STATE_DEPTH_BOUNDS";
+ case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
+ return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK";
+ case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
+ return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK";
+ case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
+ return "VK_DYNAMIC_STATE_STENCIL_REFERENCE";
+ case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
+ return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV";
+ case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
+ return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT";
+ default:
+ return "Unhandled VkDynamicState";
+ }
+}
+
+static inline const char* string_VkFilter(VkFilter input_value)
+{
+ switch ((VkFilter)input_value)
+ {
+ case VK_FILTER_NEAREST:
+ return "VK_FILTER_NEAREST";
+ case VK_FILTER_LINEAR:
+ return "VK_FILTER_LINEAR";
+ case VK_FILTER_CUBIC_IMG:
+ return "VK_FILTER_CUBIC_IMG";
+ default:
+ return "Unhandled VkFilter";
+ }
+}
+
+static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)
+{
+ switch ((VkSamplerMipmapMode)input_value)
+ {
+ case VK_SAMPLER_MIPMAP_MODE_NEAREST:
+ return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
+ case VK_SAMPLER_MIPMAP_MODE_LINEAR:
+ return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
+ default:
+ return "Unhandled VkSamplerMipmapMode";
+ }
+}
+
+static inline const char* string_VkSamplerAddressMode(VkSamplerAddressMode input_value)
+{
+ switch ((VkSamplerAddressMode)input_value)
+ {
+ case VK_SAMPLER_ADDRESS_MODE_REPEAT:
+ return "VK_SAMPLER_ADDRESS_MODE_REPEAT";
+ case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
+ return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT";
+ case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
+ return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE";
+ case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
+ return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER";
+ case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
+ return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE";
+ default:
+ return "Unhandled VkSamplerAddressMode";
+ }
+}
+
+static inline const char* string_VkBorderColor(VkBorderColor input_value)
+{
+ switch ((VkBorderColor)input_value)
+ {
+ case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
+ return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK";
+ case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
+ return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK";
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
+ return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK";
+ case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
+ return "VK_BORDER_COLOR_INT_OPAQUE_BLACK";
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
+ return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE";
+ case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
+ return "VK_BORDER_COLOR_INT_OPAQUE_WHITE";
+ default:
+ return "Unhandled VkBorderColor";
+ }
+}
+
+static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)
+{
+ switch ((VkDescriptorSetLayoutCreateFlagBits)input_value)
+ {
+ case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR:
+ return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR";
+ default:
+ return "Unhandled VkDescriptorSetLayoutCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
+{
+ switch ((VkDescriptorType)input_value)
+ {
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ return "VK_DESCRIPTOR_TYPE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT";
+ default:
+ return "Unhandled VkDescriptorType";
+ }
+}
+
+static inline const char* string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)
+{
+ switch ((VkDescriptorPoolCreateFlagBits)input_value)
+ {
+ case VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT:
+ return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT";
+ default:
+ return "Unhandled VkDescriptorPoolCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)
+{
+ switch ((VkAttachmentDescriptionFlagBits)input_value)
+ {
+ case VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT:
+ return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT";
+ default:
+ return "Unhandled VkAttachmentDescriptionFlagBits";
+ }
+}
+
+static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)
+{
+ switch ((VkAttachmentLoadOp)input_value)
+ {
+ case VK_ATTACHMENT_LOAD_OP_LOAD:
+ return "VK_ATTACHMENT_LOAD_OP_LOAD";
+ case VK_ATTACHMENT_LOAD_OP_CLEAR:
+ return "VK_ATTACHMENT_LOAD_OP_CLEAR";
+ case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
+ default:
+ return "Unhandled VkAttachmentLoadOp";
+ }
+}
+
+static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)
+{
+ switch ((VkAttachmentStoreOp)input_value)
+ {
+ case VK_ATTACHMENT_STORE_OP_STORE:
+ return "VK_ATTACHMENT_STORE_OP_STORE";
+ case VK_ATTACHMENT_STORE_OP_DONT_CARE:
+ return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
+ default:
+ return "Unhandled VkAttachmentStoreOp";
+ }
+}
+
+static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)
+{
+ switch ((VkSubpassDescriptionFlagBits)input_value)
+ {
+ case VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX:
+ return "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX";
+ case VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX:
+ return "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX";
+ default:
+ return "Unhandled VkSubpassDescriptionFlagBits";
+ }
+}
+
+static inline const char* string_VkPipelineBindPoint(VkPipelineBindPoint input_value)
+{
+ switch ((VkPipelineBindPoint)input_value)
+ {
+ case VK_PIPELINE_BIND_POINT_GRAPHICS:
+ return "VK_PIPELINE_BIND_POINT_GRAPHICS";
+ case VK_PIPELINE_BIND_POINT_COMPUTE:
+ return "VK_PIPELINE_BIND_POINT_COMPUTE";
+ default:
+ return "Unhandled VkPipelineBindPoint";
+ }
+}
+
+static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value)
+{
+ switch ((VkAccessFlagBits)input_value)
+ {
+ case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
+ return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
+ case VK_ACCESS_INDEX_READ_BIT:
+ return "VK_ACCESS_INDEX_READ_BIT";
+ case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
+ return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
+ case VK_ACCESS_UNIFORM_READ_BIT:
+ return "VK_ACCESS_UNIFORM_READ_BIT";
+ case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
+ return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
+ case VK_ACCESS_SHADER_READ_BIT:
+ return "VK_ACCESS_SHADER_READ_BIT";
+ case VK_ACCESS_SHADER_WRITE_BIT:
+ return "VK_ACCESS_SHADER_WRITE_BIT";
+ case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
+ return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
+ case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
+ return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
+ case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
+ return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
+ case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
+ return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
+ case VK_ACCESS_TRANSFER_READ_BIT:
+ return "VK_ACCESS_TRANSFER_READ_BIT";
+ case VK_ACCESS_TRANSFER_WRITE_BIT:
+ return "VK_ACCESS_TRANSFER_WRITE_BIT";
+ case VK_ACCESS_HOST_READ_BIT:
+ return "VK_ACCESS_HOST_READ_BIT";
+ case VK_ACCESS_HOST_WRITE_BIT:
+ return "VK_ACCESS_HOST_WRITE_BIT";
+ case VK_ACCESS_MEMORY_READ_BIT:
+ return "VK_ACCESS_MEMORY_READ_BIT";
+ case VK_ACCESS_MEMORY_WRITE_BIT:
+ return "VK_ACCESS_MEMORY_WRITE_BIT";
+ case VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX:
+ return "VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX";
+ case VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX:
+ return "VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX";
+ case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
+ return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
+ default:
+ return "Unhandled VkAccessFlagBits";
+ }
+}
+
+static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input_value)
+{
+ switch ((VkDependencyFlagBits)input_value)
+ {
+ case VK_DEPENDENCY_BY_REGION_BIT:
+ return "VK_DEPENDENCY_BY_REGION_BIT";
+ case VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX:
+ return "VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX";
+ case VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX:
+ return "VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX";
+ default:
+ return "Unhandled VkDependencyFlagBits";
+ }
+}
+
+static inline const char* string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)
+{
+ switch ((VkCommandPoolCreateFlagBits)input_value)
+ {
+ case VK_COMMAND_POOL_CREATE_TRANSIENT_BIT:
+ return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT";
+ case VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT:
+ return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT";
+ default:
+ return "Unhandled VkCommandPoolCreateFlagBits";
+ }
+}
+
+static inline const char* string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)
+{
+ switch ((VkCommandPoolResetFlagBits)input_value)
+ {
+ case VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT:
+ return "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT";
+ default:
+ return "Unhandled VkCommandPoolResetFlagBits";
+ }
+}
+
+static inline const char* string_VkCommandBufferLevel(VkCommandBufferLevel input_value)
+{
+ switch ((VkCommandBufferLevel)input_value)
+ {
+ case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
+ return "VK_COMMAND_BUFFER_LEVEL_PRIMARY";
+ case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
+ return "VK_COMMAND_BUFFER_LEVEL_SECONDARY";
+ default:
+ return "Unhandled VkCommandBufferLevel";
+ }
+}
+
+static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)
+{
+ switch ((VkCommandBufferUsageFlagBits)input_value)
+ {
+ case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
+ return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
+ case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
+ return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
+ case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
+ return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
+ default:
+ return "Unhandled VkCommandBufferUsageFlagBits";
+ }
+}
+
+static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)
+{
+ switch ((VkQueryControlFlagBits)input_value)
+ {
+ case VK_QUERY_CONTROL_PRECISE_BIT:
+ return "VK_QUERY_CONTROL_PRECISE_BIT";
+ default:
+ return "Unhandled VkQueryControlFlagBits";
+ }
+}
+
+static inline const char* string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)
+{
+ switch ((VkCommandBufferResetFlagBits)input_value)
+ {
+ case VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT:
+ return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT";
+ default:
+ return "Unhandled VkCommandBufferResetFlagBits";
+ }
+}
+
+static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)
+{
+ switch ((VkStencilFaceFlagBits)input_value)
+ {
+ case VK_STENCIL_FACE_FRONT_BIT:
+ return "VK_STENCIL_FACE_FRONT_BIT";
+ case VK_STENCIL_FACE_BACK_BIT:
+ return "VK_STENCIL_FACE_BACK_BIT";
+ case VK_STENCIL_FRONT_AND_BACK:
+ return "VK_STENCIL_FRONT_AND_BACK";
+ default:
+ return "Unhandled VkStencilFaceFlagBits";
+ }
+}
+
+static inline const char* string_VkIndexType(VkIndexType input_value)
+{
+ switch ((VkIndexType)input_value)
+ {
+ case VK_INDEX_TYPE_UINT16:
+ return "VK_INDEX_TYPE_UINT16";
+ case VK_INDEX_TYPE_UINT32:
+ return "VK_INDEX_TYPE_UINT32";
+ default:
+ return "Unhandled VkIndexType";
+ }
+}
+
+static inline const char* string_VkSubpassContents(VkSubpassContents input_value)
+{
+ switch ((VkSubpassContents)input_value)
+ {
+ case VK_SUBPASS_CONTENTS_INLINE:
+ return "VK_SUBPASS_CONTENTS_INLINE";
+ case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
+ return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS";
+ default:
+ return "Unhandled VkSubpassContents";
+ }
+}
+
+static inline const char* string_VkObjectType(VkObjectType input_value)
+{
+ switch ((VkObjectType)input_value)
+ {
+ case VK_OBJECT_TYPE_UNKNOWN:
+ return "VK_OBJECT_TYPE_UNKNOWN";
+ case VK_OBJECT_TYPE_INSTANCE:
+ return "VK_OBJECT_TYPE_INSTANCE";
+ case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+ return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
+ case VK_OBJECT_TYPE_DEVICE:
+ return "VK_OBJECT_TYPE_DEVICE";
+ case VK_OBJECT_TYPE_QUEUE:
+ return "VK_OBJECT_TYPE_QUEUE";
+ case VK_OBJECT_TYPE_SEMAPHORE:
+ return "VK_OBJECT_TYPE_SEMAPHORE";
+ case VK_OBJECT_TYPE_COMMAND_BUFFER:
+ return "VK_OBJECT_TYPE_COMMAND_BUFFER";
+ case VK_OBJECT_TYPE_FENCE:
+ return "VK_OBJECT_TYPE_FENCE";
+ case VK_OBJECT_TYPE_DEVICE_MEMORY:
+ return "VK_OBJECT_TYPE_DEVICE_MEMORY";
+ case VK_OBJECT_TYPE_BUFFER:
+ return "VK_OBJECT_TYPE_BUFFER";
+ case VK_OBJECT_TYPE_IMAGE:
+ return "VK_OBJECT_TYPE_IMAGE";
+ case VK_OBJECT_TYPE_EVENT:
+ return "VK_OBJECT_TYPE_EVENT";
+ case VK_OBJECT_TYPE_QUERY_POOL:
+ return "VK_OBJECT_TYPE_QUERY_POOL";
+ case VK_OBJECT_TYPE_BUFFER_VIEW:
+ return "VK_OBJECT_TYPE_BUFFER_VIEW";
+ case VK_OBJECT_TYPE_IMAGE_VIEW:
+ return "VK_OBJECT_TYPE_IMAGE_VIEW";
+ case VK_OBJECT_TYPE_SHADER_MODULE:
+ return "VK_OBJECT_TYPE_SHADER_MODULE";
+ case VK_OBJECT_TYPE_PIPELINE_CACHE:
+ return "VK_OBJECT_TYPE_PIPELINE_CACHE";
+ case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
+ return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
+ case VK_OBJECT_TYPE_RENDER_PASS:
+ return "VK_OBJECT_TYPE_RENDER_PASS";
+ case VK_OBJECT_TYPE_PIPELINE:
+ return "VK_OBJECT_TYPE_PIPELINE";
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+ return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
+ case VK_OBJECT_TYPE_SAMPLER:
+ return "VK_OBJECT_TYPE_SAMPLER";
+ case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
+ return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET:
+ return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
+ case VK_OBJECT_TYPE_FRAMEBUFFER:
+ return "VK_OBJECT_TYPE_FRAMEBUFFER";
+ case VK_OBJECT_TYPE_COMMAND_POOL:
+ return "VK_OBJECT_TYPE_COMMAND_POOL";
+ case VK_OBJECT_TYPE_SURFACE_KHR:
+ return "VK_OBJECT_TYPE_SURFACE_KHR";
+ case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
+ return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
+ case VK_OBJECT_TYPE_DISPLAY_KHR:
+ return "VK_OBJECT_TYPE_DISPLAY_KHR";
+ case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
+ return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
+ case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
+ return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
+ case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR:
+ return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR";
+ case VK_OBJECT_TYPE_OBJECT_TABLE_NVX:
+ return "VK_OBJECT_TYPE_OBJECT_TABLE_NVX";
+ case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX:
+ return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX";
+ default:
+ return "Unhandled VkObjectType";
+ }
+}
+
+static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)
+{
+ switch ((VkSurfaceTransformFlagBitsKHR)input_value)
+ {
+ case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR";
+ case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
+ return "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR";
+ default:
+ return "Unhandled VkSurfaceTransformFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)
+{
+ switch ((VkCompositeAlphaFlagBitsKHR)input_value)
+ {
+ case VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR:
+ return "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR";
+ case VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR:
+ return "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR";
+ case VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR:
+ return "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR";
+ case VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR:
+ return "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR";
+ default:
+ return "Unhandled VkCompositeAlphaFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkColorSpaceKHR(VkColorSpaceKHR input_value)
+{
+ switch ((VkColorSpaceKHR)input_value)
+ {
+ case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
+ return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
+ case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
+ return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
+ case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
+ return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
+ case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
+ return "VK_COLOR_SPACE_DCI_P3_LINEAR_EXT";
+ case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
+ return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
+ case VK_COLOR_SPACE_BT709_LINEAR_EXT:
+ return "VK_COLOR_SPACE_BT709_LINEAR_EXT";
+ case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
+ return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT";
+ case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
+ return "VK_COLOR_SPACE_BT2020_LINEAR_EXT";
+ case VK_COLOR_SPACE_HDR10_ST2084_EXT:
+ return "VK_COLOR_SPACE_HDR10_ST2084_EXT";
+ case VK_COLOR_SPACE_DOLBYVISION_EXT:
+ return "VK_COLOR_SPACE_DOLBYVISION_EXT";
+ case VK_COLOR_SPACE_HDR10_HLG_EXT:
+ return "VK_COLOR_SPACE_HDR10_HLG_EXT";
+ case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
+ return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT";
+ case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
+ return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
+ case VK_COLOR_SPACE_PASS_THROUGH_EXT:
+ return "VK_COLOR_SPACE_PASS_THROUGH_EXT";
+ case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
+ return "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
+ default:
+ return "Unhandled VkColorSpaceKHR";
+ }
+}
+
+static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value)
+{
+ switch ((VkPresentModeKHR)input_value)
+ {
+ case VK_PRESENT_MODE_IMMEDIATE_KHR:
+ return "VK_PRESENT_MODE_IMMEDIATE_KHR";
+ case VK_PRESENT_MODE_MAILBOX_KHR:
+ return "VK_PRESENT_MODE_MAILBOX_KHR";
+ case VK_PRESENT_MODE_FIFO_KHR:
+ return "VK_PRESENT_MODE_FIFO_KHR";
+ case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
+ return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
+ case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
+ return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
+ case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
+ return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
+ default:
+ return "Unhandled VkPresentModeKHR";
+ }
+}
+
+static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)
+{
+ switch ((VkSwapchainCreateFlagBitsKHR)input_value)
+ {
+ case VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX:
+ return "VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX";
+ default:
+ return "Unhandled VkSwapchainCreateFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)
+{
+ switch ((VkDisplayPlaneAlphaFlagBitsKHR)input_value)
+ {
+ case VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR:
+ return "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR";
+ case VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR:
+ return "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR";
+ case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR:
+ return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR";
+ case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR:
+ return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR";
+ default:
+ return "Unhandled VkDisplayPlaneAlphaFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)
+{
+ switch ((VkExternalMemoryHandleTypeFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_FUCHSIA_VMO_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_FUCHSIA_VMO_BIT_KHR";
+ default:
+ return "Unhandled VkExternalMemoryHandleTypeFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)
+{
+ switch ((VkExternalMemoryFeatureFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR";
+ case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR";
+ default:
+ return "Unhandled VkExternalMemoryFeatureFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)
+{
+ switch ((VkExternalSemaphoreHandleTypeFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FUCHSIA_FENCE_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FUCHSIA_FENCE_BIT_KHR";
+ default:
+ return "Unhandled VkExternalSemaphoreHandleTypeFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)
+{
+ switch ((VkExternalSemaphoreFeatureFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR";
+ case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR";
+ default:
+ return "Unhandled VkExternalSemaphoreFeatureFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)
+{
+ switch ((VkSemaphoreImportFlagBitsKHR)input_value)
+ {
+ case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR:
+ return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR";
+ default:
+ return "Unhandled VkSemaphoreImportFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)
+{
+ switch ((VkDescriptorUpdateTemplateTypeKHR)input_value)
+ {
+ case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR:
+ return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR";
+ case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
+ return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
+ default:
+ return "Unhandled VkDescriptorUpdateTemplateTypeKHR";
+ }
+}
+
+static inline const char* string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)
+{
+ switch ((VkExternalFenceHandleTypeFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR";
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR";
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR";
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR";
+ default:
+ return "Unhandled VkExternalFenceHandleTypeFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)
+{
+ switch ((VkExternalFenceFeatureFlagBitsKHR)input_value)
+ {
+ case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR";
+ case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR:
+ return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR";
+ default:
+ return "Unhandled VkExternalFenceFeatureFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)
+{
+ switch ((VkFenceImportFlagBitsKHR)input_value)
+ {
+ case VK_FENCE_IMPORT_TEMPORARY_BIT_KHR:
+ return "VK_FENCE_IMPORT_TEMPORARY_BIT_KHR";
+ default:
+ return "Unhandled VkFenceImportFlagBitsKHR";
+ }
+}
+
+static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)
+{
+ switch ((VkDebugReportObjectTypeEXT)input_value)
+ {
+ case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT";
+ case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT:
+ return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT";
+ default:
+ return "Unhandled VkDebugReportObjectTypeEXT";
+ }
+}
+
+static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)
+{
+ switch ((VkDebugReportFlagBitsEXT)input_value)
+ {
+ case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
+ return "VK_DEBUG_REPORT_INFORMATION_BIT_EXT";
+ case VK_DEBUG_REPORT_WARNING_BIT_EXT:
+ return "VK_DEBUG_REPORT_WARNING_BIT_EXT";
+ case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
+ return "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT";
+ case VK_DEBUG_REPORT_ERROR_BIT_EXT:
+ return "VK_DEBUG_REPORT_ERROR_BIT_EXT";
+ case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
+ return "VK_DEBUG_REPORT_DEBUG_BIT_EXT";
+ default:
+ return "Unhandled VkDebugReportFlagBitsEXT";
+ }
+}
+
+static inline const char* string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)
+{
+ switch ((VkRasterizationOrderAMD)input_value)
+ {
+ case VK_RASTERIZATION_ORDER_STRICT_AMD:
+ return "VK_RASTERIZATION_ORDER_STRICT_AMD";
+ case VK_RASTERIZATION_ORDER_RELAXED_AMD:
+ return "VK_RASTERIZATION_ORDER_RELAXED_AMD";
+ default:
+ return "Unhandled VkRasterizationOrderAMD";
+ }
+}
+
+static inline const char* string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)
+{
+ switch ((VkExternalMemoryHandleTypeFlagBitsNV)input_value)
+ {
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV";
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV";
+ default:
+ return "Unhandled VkExternalMemoryHandleTypeFlagBitsNV";
+ }
+}
+
+static inline const char* string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)
+{
+ switch ((VkExternalMemoryFeatureFlagBitsNV)input_value)
+ {
+ case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV";
+ case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV";
+ case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV:
+ return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV";
+ default:
+ return "Unhandled VkExternalMemoryFeatureFlagBitsNV";
+ }
+}
+
+static inline const char* string_VkPeerMemoryFeatureFlagBitsKHX(VkPeerMemoryFeatureFlagBitsKHX input_value)
+{
+ switch ((VkPeerMemoryFeatureFlagBitsKHX)input_value)
+ {
+ case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX:
+ return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX";
+ case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX:
+ return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX";
+ case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX:
+ return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX";
+ case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX:
+ return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX";
+ default:
+ return "Unhandled VkPeerMemoryFeatureFlagBitsKHX";
+ }
+}
+
+static inline const char* string_VkMemoryAllocateFlagBitsKHX(VkMemoryAllocateFlagBitsKHX input_value)
+{
+ switch ((VkMemoryAllocateFlagBitsKHX)input_value)
+ {
+ case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX:
+ return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX";
+ default:
+ return "Unhandled VkMemoryAllocateFlagBitsKHX";
+ }
+}
+
+static inline const char* string_VkDeviceGroupPresentModeFlagBitsKHX(VkDeviceGroupPresentModeFlagBitsKHX input_value)
+{
+ switch ((VkDeviceGroupPresentModeFlagBitsKHX)input_value)
+ {
+ case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX:
+ return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX";
+ case VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX:
+ return "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX";
+ case VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX:
+ return "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX";
+ case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX:
+ return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX";
+ default:
+ return "Unhandled VkDeviceGroupPresentModeFlagBitsKHX";
+ }
+}
+
+static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input_value)
+{
+ switch ((VkValidationCheckEXT)input_value)
+ {
+ case VK_VALIDATION_CHECK_ALL_EXT:
+ return "VK_VALIDATION_CHECK_ALL_EXT";
+ case VK_VALIDATION_CHECK_SHADERS_EXT:
+ return "VK_VALIDATION_CHECK_SHADERS_EXT";
+ default:
+ return "Unhandled VkValidationCheckEXT";
+ }
+}
+
+static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsNVX(VkIndirectCommandsLayoutUsageFlagBitsNVX input_value)
+{
+ switch ((VkIndirectCommandsLayoutUsageFlagBitsNVX)input_value)
+ {
+ case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX:
+ return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX";
+ case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX:
+ return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX";
+ case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX:
+ return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX";
+ case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX:
+ return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX";
+ default:
+ return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsNVX";
+ }
+}
+
+static inline const char* string_VkObjectEntryUsageFlagBitsNVX(VkObjectEntryUsageFlagBitsNVX input_value)
+{
+ switch ((VkObjectEntryUsageFlagBitsNVX)input_value)
+ {
+ case VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX:
+ return "VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX";
+ case VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX:
+ return "VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX";
+ default:
+ return "Unhandled VkObjectEntryUsageFlagBitsNVX";
+ }
+}
+
+static inline const char* string_VkIndirectCommandsTokenTypeNVX(VkIndirectCommandsTokenTypeNVX input_value)
+{
+ switch ((VkIndirectCommandsTokenTypeNVX)input_value)
+ {
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX";
+ case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX:
+ return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX";
+ default:
+ return "Unhandled VkIndirectCommandsTokenTypeNVX";
+ }
+}
+
+static inline const char* string_VkObjectEntryTypeNVX(VkObjectEntryTypeNVX input_value)
+{
+ switch ((VkObjectEntryTypeNVX)input_value)
+ {
+ case VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX:
+ return "VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX";
+ case VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX:
+ return "VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX";
+ case VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX:
+ return "VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX";
+ case VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX:
+ return "VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX";
+ case VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX:
+ return "VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX";
+ default:
+ return "Unhandled VkObjectEntryTypeNVX";
+ }
+}
+
+static inline const char* string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)
+{
+ switch ((VkSurfaceCounterFlagBitsEXT)input_value)
+ {
+ case VK_SURFACE_COUNTER_VBLANK_EXT:
+ return "VK_SURFACE_COUNTER_VBLANK_EXT";
+ default:
+ return "Unhandled VkSurfaceCounterFlagBitsEXT";
+ }
+}
+
+static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)
+{
+ switch ((VkDisplayPowerStateEXT)input_value)
+ {
+ case VK_DISPLAY_POWER_STATE_OFF_EXT:
+ return "VK_DISPLAY_POWER_STATE_OFF_EXT";
+ case VK_DISPLAY_POWER_STATE_SUSPEND_EXT:
+ return "VK_DISPLAY_POWER_STATE_SUSPEND_EXT";
+ case VK_DISPLAY_POWER_STATE_ON_EXT:
+ return "VK_DISPLAY_POWER_STATE_ON_EXT";
+ default:
+ return "Unhandled VkDisplayPowerStateEXT";
+ }
+}
+
+static inline const char* string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)
+{
+ switch ((VkDeviceEventTypeEXT)input_value)
+ {
+ case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT:
+ return "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT";
+ default:
+ return "Unhandled VkDeviceEventTypeEXT";
+ }
+}
+
+static inline const char* string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)
+{
+ switch ((VkDisplayEventTypeEXT)input_value)
+ {
+ case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT:
+ return "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT";
+ default:
+ return "Unhandled VkDisplayEventTypeEXT";
+ }
+}
+
+static inline const char* string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)
+{
+ switch ((VkViewportCoordinateSwizzleNV)input_value)
+ {
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV";
+ case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV:
+ return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV";
+ default:
+ return "Unhandled VkViewportCoordinateSwizzleNV";
+ }
+}
+
+static inline const char* string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)
+{
+ switch ((VkDiscardRectangleModeEXT)input_value)
+ {
+ case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT:
+ return "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT";
+ case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT:
+ return "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT";
+ default:
+ return "Unhandled VkDiscardRectangleModeEXT";
+ }
+}
+
+static inline const char* string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)
+{
+ switch ((VkSamplerReductionModeEXT)input_value)
+ {
+ case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT:
+ return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT";
+ case VK_SAMPLER_REDUCTION_MODE_MIN_EXT:
+ return "VK_SAMPLER_REDUCTION_MODE_MIN_EXT";
+ case VK_SAMPLER_REDUCTION_MODE_MAX_EXT:
+ return "VK_SAMPLER_REDUCTION_MODE_MAX_EXT";
+ default:
+ return "Unhandled VkSamplerReductionModeEXT";
+ }
+}
+
+static inline const char* string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)
+{
+ switch ((VkBlendOverlapEXT)input_value)
+ {
+ case VK_BLEND_OVERLAP_UNCORRELATED_EXT:
+ return "VK_BLEND_OVERLAP_UNCORRELATED_EXT";
+ case VK_BLEND_OVERLAP_DISJOINT_EXT:
+ return "VK_BLEND_OVERLAP_DISJOINT_EXT";
+ case VK_BLEND_OVERLAP_CONJOINT_EXT:
+ return "VK_BLEND_OVERLAP_CONJOINT_EXT";
+ default:
+ return "Unhandled VkBlendOverlapEXT";
+ }
+}
+
+static inline const char* string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)
+{
+ switch ((VkCoverageModulationModeNV)input_value)
+ {
+ case VK_COVERAGE_MODULATION_MODE_NONE_NV:
+ return "VK_COVERAGE_MODULATION_MODE_NONE_NV";
+ case VK_COVERAGE_MODULATION_MODE_RGB_NV:
+ return "VK_COVERAGE_MODULATION_MODE_RGB_NV";
+ case VK_COVERAGE_MODULATION_MODE_ALPHA_NV:
+ return "VK_COVERAGE_MODULATION_MODE_ALPHA_NV";
+ case VK_COVERAGE_MODULATION_MODE_RGBA_NV:
+ return "VK_COVERAGE_MODULATION_MODE_RGBA_NV";
+ default:
+ return "Unhandled VkCoverageModulationModeNV";
+ }
+}
+
+static const char * GetPhysDevFeatureString(uint32_t index) {
+ const char * IndexToPhysDevFeatureString[] = {
+ "robustBufferAccess",
+ "fullDrawIndexUint32",
+ "imageCubeArray",
+ "independentBlend",
+ "geometryShader",
+ "tessellationShader",
+ "sampleRateShading",
+ "dualSrcBlend",
+ "logicOp",
+ "multiDrawIndirect",
+ "drawIndirectFirstInstance",
+ "depthClamp",
+ "depthBiasClamp",
+ "fillModeNonSolid",
+ "depthBounds",
+ "wideLines",
+ "largePoints",
+ "alphaToOne",
+ "multiViewport",
+ "samplerAnisotropy",
+ "textureCompressionETC2",
+ "textureCompressionASTC_LDR",
+ "textureCompressionBC",
+ "occlusionQueryPrecise",
+ "pipelineStatisticsQuery",
+ "vertexPipelineStoresAndAtomics",
+ "fragmentStoresAndAtomics",
+ "shaderTessellationAndGeometryPointSize",
+ "shaderImageGatherExtended",
+ "shaderStorageImageExtendedFormats",
+ "shaderStorageImageMultisample",
+ "shaderStorageImageReadWithoutFormat",
+ "shaderStorageImageWriteWithoutFormat",
+ "shaderUniformBufferArrayDynamicIndexing",
+ "shaderSampledImageArrayDynamicIndexing",
+ "shaderStorageBufferArrayDynamicIndexing",
+ "shaderStorageImageArrayDynamicIndexing",
+ "shaderClipDistance",
+ "shaderCullDistance",
+ "shaderFloat64",
+ "shaderInt64",
+ "shaderInt16",
+ "shaderResourceResidency",
+ "shaderResourceMinLod",
+ "sparseBinding",
+ "sparseResidencyBuffer",
+ "sparseResidencyImage2D",
+ "sparseResidencyImage3D",
+ "sparseResidency2Samples",
+ "sparseResidency4Samples",
+ "sparseResidency8Samples",
+ "sparseResidency16Samples",
+ "sparseResidencyAliased",
+ "variableMultisampleRate",
+ "inheritedQueries",
+ };
+
+ return IndexToPhysDevFeatureString[index];
+}
diff --git a/build-fuchsia/generated/include/vk_extension_helper.h b/build-fuchsia/generated/include/vk_extension_helper.h
new file mode 100644
index 0000000..e86a1b9
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_extension_helper.h
@@ -0,0 +1,330 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#ifndef VK_EXTENSION_HELPER_H_
+#define VK_EXTENSION_HELPER_H_
+#include <vulkan/vulkan.h>
+#include <string.h>
+#include <utility>
+
+
+struct InstanceExtensions {
+ bool vk_khr_mir_surface{false};
+ bool vk_khr_xcb_surface{false};
+ bool vk_mvk_macos_surface{false};
+ bool vk_khr_magma_surface{false};
+ bool vk_mvk_ios_surface{false};
+ bool vk_ext_acquire_xlib_display{false};
+ bool vk_ext_swapchain_color_space{false};
+ bool vk_khx_device_group_creation{false};
+ bool vk_khr_get_surface_capabilities_2{false};
+ bool vk_khr_external_memory_capabilities{false};
+ bool vk_ext_validation_flags{false};
+ bool vk_khr_win32_surface{false};
+ bool vk_khr_xlib_surface{false};
+ bool vk_nn_vi_surface{false};
+ bool vk_ext_direct_mode_display{false};
+ bool vk_ext_debug_report{false};
+ bool vk_nv_external_memory_capabilities{false};
+ bool vk_khr_display{false};
+ bool vk_khr_external_semaphore_capabilities{false};
+ bool vk_khr_android_surface{false};
+ bool vk_khr_get_physical_device_properties_2{false};
+ bool vk_khr_external_fence_capabilities{false};
+ bool vk_khr_wayland_surface{false};
+ bool vk_khr_surface{false};
+ bool vk_google_image_tiling_scanout{false};
+ bool vk_ext_display_surface_counter{false};
+
+ void InitFromInstanceCreateInfo(const VkInstanceCreateInfo *pCreateInfo) {
+
+ static const std::pair<char const *, bool InstanceExtensions::*> known_extensions[]{
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ {VK_KHR_MIR_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_mir_surface},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ {VK_KHR_XCB_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_xcb_surface},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ {VK_MVK_MACOS_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_mvk_macos_surface},
+#endif
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ {VK_KHR_MAGMA_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_magma_surface},
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ {VK_MVK_IOS_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_mvk_ios_surface},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ {VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME, &InstanceExtensions::vk_ext_acquire_xlib_display},
+#endif
+ {VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, &InstanceExtensions::vk_ext_swapchain_color_space},
+ {VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME, &InstanceExtensions::vk_khx_device_group_creation},
+ {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, &InstanceExtensions::vk_khr_get_surface_capabilities_2},
+ {VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, &InstanceExtensions::vk_khr_external_memory_capabilities},
+ {VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME, &InstanceExtensions::vk_ext_validation_flags},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_KHR_WIN32_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_win32_surface},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ {VK_KHR_XLIB_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_xlib_surface},
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+ {VK_NN_VI_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_nn_vi_surface},
+#endif
+ {VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, &InstanceExtensions::vk_ext_direct_mode_display},
+ {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, &InstanceExtensions::vk_ext_debug_report},
+ {VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, &InstanceExtensions::vk_nv_external_memory_capabilities},
+ {VK_KHR_DISPLAY_EXTENSION_NAME, &InstanceExtensions::vk_khr_display},
+ {VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, &InstanceExtensions::vk_khr_external_semaphore_capabilities},
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ {VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_android_surface},
+#endif
+ {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, &InstanceExtensions::vk_khr_get_physical_device_properties_2},
+ {VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, &InstanceExtensions::vk_khr_external_fence_capabilities},
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ {VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_wayland_surface},
+#endif
+ {VK_KHR_SURFACE_EXTENSION_NAME, &InstanceExtensions::vk_khr_surface},
+ {VK_GOOGLE_IMAGE_TILING_SCANOUT_EXTENSION_NAME, &InstanceExtensions::vk_google_image_tiling_scanout},
+ {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, &InstanceExtensions::vk_ext_display_surface_counter},
+ };
+
+ // Initialize struct data
+
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+ for (auto ext : known_extensions) {
+ if (!strcmp(ext.first, pCreateInfo->ppEnabledExtensionNames[i])) {
+ this->*(ext.second) = true;
+ break;
+ }
+ }
+ }
+ }
+};
+
+struct DeviceExtensions : public InstanceExtensions {
+ bool vk_nv_viewport_array2{false};
+ bool vk_nv_sample_mask_override_coverage{false};
+ bool vk_nv_clip_space_w_scaling{false};
+ bool vk_amd_negative_viewport_height{false};
+ bool vk_ext_blend_operation_advanced{false};
+ bool vk_nvx_device_generated_commands{false};
+ bool vk_nv_external_memory{false};
+ bool vk_khr_external_fence{false};
+ bool vk_amd_mixed_attachment_samples{false};
+ bool vk_khr_descriptor_update_template{false};
+ bool vk_khr_storage_buffer_storage_class{false};
+ bool vk_amd_shader_explicit_vertex_parameter{false};
+ bool vk_khr_external_semaphore{false};
+ bool vk_nv_win32_keyed_mutex{false};
+ bool vk_ext_shader_subgroup_ballot{false};
+ bool vk_nv_viewport_swizzle{false};
+ bool vk_nv_dedicated_allocation{false};
+ bool vk_nv_external_memory_win32{false};
+ bool vk_amd_rasterization_order{false};
+ bool vk_ext_post_depth_coverage{false};
+ bool vk_nv_fill_rectangle{false};
+ bool vk_amd_shader_trinary_minmax{false};
+ bool vk_google_external_memory_magma{false};
+ bool vk_khr_external_semaphore_fd{false};
+ bool vk_img_format_pvrtc{false};
+ bool vk_nv_glsl_shader{false};
+ bool vk_ext_sampler_filter_minmax{false};
+ bool vk_amd_shader_ballot{false};
+ bool vk_khr_sampler_mirror_clamp_to_edge{false};
+ bool vk_khr_external_semaphore_fuchsia{false};
+ bool vk_khr_external_memory_fuchsia{false};
+ bool vk_khr_relaxed_block_layout{false};
+ bool vk_amd_gcn_shader{false};
+ bool vk_khr_external_memory{false};
+ bool vk_amd_draw_indirect_count{false};
+ bool vk_img_filter_cubic{false};
+ bool vk_khx_device_group{false};
+ bool vk_khr_variable_pointers{false};
+ bool vk_amd_gpu_shader_int16{false};
+ bool vk_khr_display_swapchain{false};
+ bool vk_khr_shared_presentable_image{false};
+ bool vk_khr_incremental_present{false};
+ bool vk_khx_multiview{false};
+ bool vk_ext_depth_range_unrestricted{false};
+ bool vk_ext_debug_marker{false};
+ bool vk_khr_external_semaphore_win32{false};
+ bool vk_khr_dedicated_allocation{false};
+ bool vk_khr_maintenance1{false};
+ bool vk_amd_texture_gather_bias_lod{false};
+ bool vk_google_display_timing{false};
+ bool vk_khr_swapchain{false};
+ bool vk_khr_get_memory_requirements_2{false};
+ bool vk_khr_win32_keyed_mutex{false};
+ bool vk_khr_external_fence_fd{false};
+ bool vk_khr_push_descriptor{false};
+ bool vk_khr_external_memory_fd{false};
+ bool vk_ext_discard_rectangles{false};
+ bool vk_khr_external_memory_win32{false};
+ bool vk_khr_16bit_storage{false};
+ bool vk_ext_hdr_metadata{false};
+ bool vk_nv_geometry_shader_passthrough{false};
+ bool vk_nvx_multiview_per_view_attributes{false};
+ bool vk_nv_fragment_coverage_to_color{false};
+ bool vk_amd_gpu_shader_half_float{false};
+ bool vk_khr_shader_draw_parameters{false};
+ bool vk_nv_framebuffer_mixed_samples{false};
+ bool vk_khr_external_fence_win32{false};
+ bool vk_ext_shader_subgroup_vote{false};
+ bool vk_ext_display_control{false};
+
+ void InitFromDeviceCreateInfo(const InstanceExtensions *instance_extensions, const VkDeviceCreateInfo *pCreateInfo) {
+
+ static const std::pair<char const *, bool DeviceExtensions::*> known_extensions[]{
+ {VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, &DeviceExtensions::vk_nv_viewport_array2},
+ {VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME, &DeviceExtensions::vk_nv_sample_mask_override_coverage},
+ {VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME, &DeviceExtensions::vk_nv_clip_space_w_scaling},
+ {VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME, &DeviceExtensions::vk_amd_negative_viewport_height},
+ {VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, &DeviceExtensions::vk_ext_blend_operation_advanced},
+ {VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, &DeviceExtensions::vk_nvx_device_generated_commands},
+ {VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME, &DeviceExtensions::vk_nv_external_memory},
+ {VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_fence},
+ {VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME, &DeviceExtensions::vk_amd_mixed_attachment_samples},
+ {VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, &DeviceExtensions::vk_khr_descriptor_update_template},
+ {VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, &DeviceExtensions::vk_khr_storage_buffer_storage_class},
+ {VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME, &DeviceExtensions::vk_amd_shader_explicit_vertex_parameter},
+ {VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_semaphore},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, &DeviceExtensions::vk_nv_win32_keyed_mutex},
+#endif
+ {VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, &DeviceExtensions::vk_ext_shader_subgroup_ballot},
+ {VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, &DeviceExtensions::vk_nv_viewport_swizzle},
+ {VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME, &DeviceExtensions::vk_nv_dedicated_allocation},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, &DeviceExtensions::vk_nv_external_memory_win32},
+#endif
+ {VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME, &DeviceExtensions::vk_amd_rasterization_order},
+ {VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME, &DeviceExtensions::vk_ext_post_depth_coverage},
+ {VK_NV_FILL_RECTANGLE_EXTENSION_NAME, &DeviceExtensions::vk_nv_fill_rectangle},
+ {VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME, &DeviceExtensions::vk_amd_shader_trinary_minmax},
+ {VK_GOOGLE_EXTERNAL_MEMORY_MAGMA_EXTENSION_NAME, &DeviceExtensions::vk_google_external_memory_magma},
+ {VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_semaphore_fd},
+ {VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, &DeviceExtensions::vk_img_format_pvrtc},
+ {VK_NV_GLSL_SHADER_EXTENSION_NAME, &DeviceExtensions::vk_nv_glsl_shader},
+ {VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME, &DeviceExtensions::vk_ext_sampler_filter_minmax},
+ {VK_AMD_SHADER_BALLOT_EXTENSION_NAME, &DeviceExtensions::vk_amd_shader_ballot},
+ {VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, &DeviceExtensions::vk_khr_sampler_mirror_clamp_to_edge},
+ {VK_KHR_EXTERNAL_SEMAPHORE_FUCHSIA_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_semaphore_fuchsia},
+ {VK_KHR_EXTERNAL_MEMORY_FUCHSIA_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_memory_fuchsia},
+ {VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, &DeviceExtensions::vk_khr_relaxed_block_layout},
+ {VK_AMD_GCN_SHADER_EXTENSION_NAME, &DeviceExtensions::vk_amd_gcn_shader},
+ {VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_memory},
+ {VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME, &DeviceExtensions::vk_amd_draw_indirect_count},
+ {VK_IMG_FILTER_CUBIC_EXTENSION_NAME, &DeviceExtensions::vk_img_filter_cubic},
+ {VK_KHX_DEVICE_GROUP_EXTENSION_NAME, &DeviceExtensions::vk_khx_device_group},
+ {VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, &DeviceExtensions::vk_khr_variable_pointers},
+ {VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME, &DeviceExtensions::vk_amd_gpu_shader_int16},
+ {VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME, &DeviceExtensions::vk_khr_display_swapchain},
+ {VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, &DeviceExtensions::vk_khr_shared_presentable_image},
+ {VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, &DeviceExtensions::vk_khr_incremental_present},
+ {VK_KHX_MULTIVIEW_EXTENSION_NAME, &DeviceExtensions::vk_khx_multiview},
+ {VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, &DeviceExtensions::vk_ext_depth_range_unrestricted},
+ {VK_EXT_DEBUG_MARKER_EXTENSION_NAME, &DeviceExtensions::vk_ext_debug_marker},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_semaphore_win32},
+#endif
+ {VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, &DeviceExtensions::vk_khr_dedicated_allocation},
+ {VK_KHR_MAINTENANCE1_EXTENSION_NAME, &DeviceExtensions::vk_khr_maintenance1},
+ {VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME, &DeviceExtensions::vk_amd_texture_gather_bias_lod},
+ {VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, &DeviceExtensions::vk_google_display_timing},
+ {VK_KHR_SWAPCHAIN_EXTENSION_NAME, &DeviceExtensions::vk_khr_swapchain},
+ {VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, &DeviceExtensions::vk_khr_get_memory_requirements_2},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME, &DeviceExtensions::vk_khr_win32_keyed_mutex},
+#endif
+ {VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_fence_fd},
+ {VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, &DeviceExtensions::vk_khr_push_descriptor},
+ {VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_memory_fd},
+ {VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME, &DeviceExtensions::vk_ext_discard_rectangles},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_memory_win32},
+#endif
+ {VK_KHR_16BIT_STORAGE_EXTENSION_NAME, &DeviceExtensions::vk_khr_16bit_storage},
+ {VK_EXT_HDR_METADATA_EXTENSION_NAME, &DeviceExtensions::vk_ext_hdr_metadata},
+ {VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME, &DeviceExtensions::vk_nv_geometry_shader_passthrough},
+ {VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME, &DeviceExtensions::vk_nvx_multiview_per_view_attributes},
+ {VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME, &DeviceExtensions::vk_nv_fragment_coverage_to_color},
+ {VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME, &DeviceExtensions::vk_amd_gpu_shader_half_float},
+ {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, &DeviceExtensions::vk_khr_shader_draw_parameters},
+ {VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME, &DeviceExtensions::vk_nv_framebuffer_mixed_samples},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ {VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME, &DeviceExtensions::vk_khr_external_fence_win32},
+#endif
+ {VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, &DeviceExtensions::vk_ext_shader_subgroup_vote},
+ {VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME, &DeviceExtensions::vk_ext_display_control},
+ };
+
+ // Initialize struct data
+ vk_khr_mir_surface = instance_extensions->vk_khr_mir_surface;
+ vk_khr_xcb_surface = instance_extensions->vk_khr_xcb_surface;
+ vk_mvk_macos_surface = instance_extensions->vk_mvk_macos_surface;
+ vk_khr_magma_surface = instance_extensions->vk_khr_magma_surface;
+ vk_mvk_ios_surface = instance_extensions->vk_mvk_ios_surface;
+ vk_ext_acquire_xlib_display = instance_extensions->vk_ext_acquire_xlib_display;
+ vk_ext_swapchain_color_space = instance_extensions->vk_ext_swapchain_color_space;
+ vk_khx_device_group_creation = instance_extensions->vk_khx_device_group_creation;
+ vk_khr_get_surface_capabilities_2 = instance_extensions->vk_khr_get_surface_capabilities_2;
+ vk_khr_external_memory_capabilities = instance_extensions->vk_khr_external_memory_capabilities;
+ vk_ext_validation_flags = instance_extensions->vk_ext_validation_flags;
+ vk_khr_win32_surface = instance_extensions->vk_khr_win32_surface;
+ vk_khr_xlib_surface = instance_extensions->vk_khr_xlib_surface;
+ vk_nn_vi_surface = instance_extensions->vk_nn_vi_surface;
+ vk_ext_direct_mode_display = instance_extensions->vk_ext_direct_mode_display;
+ vk_ext_debug_report = instance_extensions->vk_ext_debug_report;
+ vk_nv_external_memory_capabilities = instance_extensions->vk_nv_external_memory_capabilities;
+ vk_khr_display = instance_extensions->vk_khr_display;
+ vk_khr_external_semaphore_capabilities = instance_extensions->vk_khr_external_semaphore_capabilities;
+ vk_khr_android_surface = instance_extensions->vk_khr_android_surface;
+ vk_khr_get_physical_device_properties_2 = instance_extensions->vk_khr_get_physical_device_properties_2;
+ vk_khr_external_fence_capabilities = instance_extensions->vk_khr_external_fence_capabilities;
+ vk_khr_wayland_surface = instance_extensions->vk_khr_wayland_surface;
+ vk_khr_surface = instance_extensions->vk_khr_surface;
+ vk_google_image_tiling_scanout = instance_extensions->vk_google_image_tiling_scanout;
+ vk_ext_display_surface_counter = instance_extensions->vk_ext_display_surface_counter;
+
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+ for (auto ext : known_extensions) {
+ if (!strcmp(ext.first, pCreateInfo->ppEnabledExtensionNames[i])) {
+ this->*(ext.second) = true;
+ break;
+ }
+ }
+ }
+ }
+};
+
+
+#endif // VK_EXTENSION_HELPER_H_
diff --git a/build-fuchsia/generated/include/vk_layer_dispatch_table.h b/build-fuchsia/generated/include/vk_layer_dispatch_table.h
new file mode 100644
index 0000000..2c26ac3
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_layer_dispatch_table.h
@@ -0,0 +1,450 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See loader_extension_generator.py for modifications
+
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 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: Mark Young <marky@lunarg.com>
+ */
+
+#pragma once
+
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
+
+// Instance function pointer dispatch table
+typedef struct VkLayerInstanceDispatchTable_ {
+ // Manually add in GetPhysicalDeviceProcAddr entry
+ PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;
+
+ // ---- Core 1_0 commands
+ PFN_vkCreateInstance CreateInstance;
+ PFN_vkDestroyInstance DestroyInstance;
+ PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+ PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+ PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+ PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+ PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+ PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+ PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+ PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+ PFN_vkCreateDevice CreateDevice;
+ PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
+ PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+ PFN_vkEnumerateInstanceLayerProperties EnumerateInstanceLayerProperties;
+ PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+
+ // ---- VK_KHR_surface extension commands
+ PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+
+ // ---- VK_KHR_display extension commands
+ PFN_vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR;
+ PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR;
+ PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR;
+ PFN_vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR;
+ PFN_vkCreateDisplayModeKHR CreateDisplayModeKHR;
+ PFN_vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR;
+ PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ PFN_vkCreateXlibSurfaceKHR CreateXlibSurfaceKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR GetPhysicalDeviceXlibPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ PFN_vkCreateXcbSurfaceKHR CreateXcbSurfaceKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ PFN_vkCreateWaylandSurfaceKHR CreateWaylandSurfaceKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkCreateWin32SurfaceKHR CreateWin32SurfaceKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ PFN_vkCreateMagmaSurfaceKHR CreateMagmaSurfaceKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ PFN_vkGetPhysicalDeviceMagmaPresentationSupportKHR GetPhysicalDeviceMagmaPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR;
+ PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR;
+ PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR;
+ PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR;
+ PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR;
+ PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR;
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR;
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR;
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR;
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR;
+
+ // ---- VK_EXT_debug_report extension commands
+ PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
+ PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
+ PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV GetPhysicalDeviceExternalImageFormatPropertiesNV;
+
+ // ---- VK_KHX_device_group extension commands
+ PFN_vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX;
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ PFN_vkCreateViSurfaceNN CreateViSurfaceNN;
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX;
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ PFN_vkReleaseDisplayEXT ReleaseDisplayEXT;
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ PFN_vkAcquireXlibDisplayEXT AcquireXlibDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ PFN_vkGetRandROutputDisplayEXT GetRandROutputDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT GetPhysicalDeviceSurfaceCapabilities2EXT;
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ PFN_vkCreateIOSSurfaceMVK CreateIOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_MACOS_MVK
+} VkLayerInstanceDispatchTable;
+
+// Device function pointer dispatch table
+typedef struct VkLayerDispatchTable_ {
+
+ // ---- Core 1_0 commands
+ PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+ PFN_vkDestroyDevice DestroyDevice;
+ PFN_vkGetDeviceQueue GetDeviceQueue;
+ PFN_vkQueueSubmit QueueSubmit;
+ PFN_vkQueueWaitIdle QueueWaitIdle;
+ PFN_vkDeviceWaitIdle DeviceWaitIdle;
+ PFN_vkAllocateMemory AllocateMemory;
+ PFN_vkFreeMemory FreeMemory;
+ PFN_vkMapMemory MapMemory;
+ PFN_vkUnmapMemory UnmapMemory;
+ PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
+ PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
+ PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
+ PFN_vkBindBufferMemory BindBufferMemory;
+ PFN_vkBindImageMemory BindImageMemory;
+ PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
+ PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
+ PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
+ PFN_vkQueueBindSparse QueueBindSparse;
+ PFN_vkCreateFence CreateFence;
+ PFN_vkDestroyFence DestroyFence;
+ PFN_vkResetFences ResetFences;
+ PFN_vkGetFenceStatus GetFenceStatus;
+ PFN_vkWaitForFences WaitForFences;
+ PFN_vkCreateSemaphore CreateSemaphore;
+ PFN_vkDestroySemaphore DestroySemaphore;
+ PFN_vkCreateEvent CreateEvent;
+ PFN_vkDestroyEvent DestroyEvent;
+ PFN_vkGetEventStatus GetEventStatus;
+ PFN_vkSetEvent SetEvent;
+ PFN_vkResetEvent ResetEvent;
+ PFN_vkCreateQueryPool CreateQueryPool;
+ PFN_vkDestroyQueryPool DestroyQueryPool;
+ PFN_vkGetQueryPoolResults GetQueryPoolResults;
+ PFN_vkCreateBuffer CreateBuffer;
+ PFN_vkDestroyBuffer DestroyBuffer;
+ PFN_vkCreateBufferView CreateBufferView;
+ PFN_vkDestroyBufferView DestroyBufferView;
+ PFN_vkCreateImage CreateImage;
+ PFN_vkDestroyImage DestroyImage;
+ PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
+ PFN_vkCreateImageView CreateImageView;
+ PFN_vkDestroyImageView DestroyImageView;
+ PFN_vkCreateShaderModule CreateShaderModule;
+ PFN_vkDestroyShaderModule DestroyShaderModule;
+ PFN_vkCreatePipelineCache CreatePipelineCache;
+ PFN_vkDestroyPipelineCache DestroyPipelineCache;
+ PFN_vkGetPipelineCacheData GetPipelineCacheData;
+ PFN_vkMergePipelineCaches MergePipelineCaches;
+ PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
+ PFN_vkCreateComputePipelines CreateComputePipelines;
+ PFN_vkDestroyPipeline DestroyPipeline;
+ PFN_vkCreatePipelineLayout CreatePipelineLayout;
+ PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
+ PFN_vkCreateSampler CreateSampler;
+ PFN_vkDestroySampler DestroySampler;
+ PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
+ PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
+ PFN_vkCreateDescriptorPool CreateDescriptorPool;
+ PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
+ PFN_vkResetDescriptorPool ResetDescriptorPool;
+ PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
+ PFN_vkFreeDescriptorSets FreeDescriptorSets;
+ PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
+ PFN_vkCreateFramebuffer CreateFramebuffer;
+ PFN_vkDestroyFramebuffer DestroyFramebuffer;
+ PFN_vkCreateRenderPass CreateRenderPass;
+ PFN_vkDestroyRenderPass DestroyRenderPass;
+ PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
+ PFN_vkCreateCommandPool CreateCommandPool;
+ PFN_vkDestroyCommandPool DestroyCommandPool;
+ PFN_vkResetCommandPool ResetCommandPool;
+ PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+ PFN_vkFreeCommandBuffers FreeCommandBuffers;
+ PFN_vkBeginCommandBuffer BeginCommandBuffer;
+ PFN_vkEndCommandBuffer EndCommandBuffer;
+ PFN_vkResetCommandBuffer ResetCommandBuffer;
+ PFN_vkCmdBindPipeline CmdBindPipeline;
+ PFN_vkCmdSetViewport CmdSetViewport;
+ PFN_vkCmdSetScissor CmdSetScissor;
+ PFN_vkCmdSetLineWidth CmdSetLineWidth;
+ PFN_vkCmdSetDepthBias CmdSetDepthBias;
+ PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
+ PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
+ PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
+ PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
+ PFN_vkCmdSetStencilReference CmdSetStencilReference;
+ PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
+ PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
+ PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
+ PFN_vkCmdDraw CmdDraw;
+ PFN_vkCmdDrawIndexed CmdDrawIndexed;
+ PFN_vkCmdDrawIndirect CmdDrawIndirect;
+ PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
+ PFN_vkCmdDispatch CmdDispatch;
+ PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
+ PFN_vkCmdCopyBuffer CmdCopyBuffer;
+ PFN_vkCmdCopyImage CmdCopyImage;
+ PFN_vkCmdBlitImage CmdBlitImage;
+ PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
+ PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
+ PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
+ PFN_vkCmdFillBuffer CmdFillBuffer;
+ PFN_vkCmdClearColorImage CmdClearColorImage;
+ PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
+ PFN_vkCmdClearAttachments CmdClearAttachments;
+ PFN_vkCmdResolveImage CmdResolveImage;
+ PFN_vkCmdSetEvent CmdSetEvent;
+ PFN_vkCmdResetEvent CmdResetEvent;
+ PFN_vkCmdWaitEvents CmdWaitEvents;
+ PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
+ PFN_vkCmdBeginQuery CmdBeginQuery;
+ PFN_vkCmdEndQuery CmdEndQuery;
+ PFN_vkCmdResetQueryPool CmdResetQueryPool;
+ PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
+ PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
+ PFN_vkCmdPushConstants CmdPushConstants;
+ PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
+ PFN_vkCmdNextSubpass CmdNextSubpass;
+ PFN_vkCmdEndRenderPass CmdEndRenderPass;
+ PFN_vkCmdExecuteCommands CmdExecuteCommands;
+
+ // ---- VK_KHR_swapchain extension commands
+ PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+ PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+ PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+ PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
+ PFN_vkQueuePresentKHR QueuePresentKHR;
+
+ // ---- VK_KHR_display_swapchain extension commands
+ PFN_vkCreateSharedSwapchainsKHR CreateSharedSwapchainsKHR;
+
+ // ---- VK_KHR_maintenance1 extension commands
+ PFN_vkTrimCommandPoolKHR TrimCommandPoolKHR;
+
+ // ---- VK_KHR_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetMemoryWin32HandleKHR GetMemoryWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetMemoryWin32HandlePropertiesKHR GetMemoryWin32HandlePropertiesKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_memory_fd extension commands
+ PFN_vkGetMemoryFdKHR GetMemoryFdKHR;
+ PFN_vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkImportSemaphoreWin32HandleKHR ImportSemaphoreWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetSemaphoreWin32HandleKHR GetSemaphoreWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_semaphore_fd extension commands
+ PFN_vkImportSemaphoreFdKHR ImportSemaphoreFdKHR;
+ PFN_vkGetSemaphoreFdKHR GetSemaphoreFdKHR;
+
+ // ---- VK_KHR_push_descriptor extension commands
+ PFN_vkCmdPushDescriptorSetKHR CmdPushDescriptorSetKHR;
+
+ // ---- VK_KHR_descriptor_update_template extension commands
+ PFN_vkCreateDescriptorUpdateTemplateKHR CreateDescriptorUpdateTemplateKHR;
+ PFN_vkDestroyDescriptorUpdateTemplateKHR DestroyDescriptorUpdateTemplateKHR;
+ PFN_vkUpdateDescriptorSetWithTemplateKHR UpdateDescriptorSetWithTemplateKHR;
+ PFN_vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR;
+
+ // ---- VK_KHR_shared_presentable_image extension commands
+ PFN_vkGetSwapchainStatusKHR GetSwapchainStatusKHR;
+
+ // ---- VK_KHR_external_fence_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkImportFenceWin32HandleKHR ImportFenceWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetFenceWin32HandleKHR GetFenceWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_fence_fd extension commands
+ PFN_vkImportFenceFdKHR ImportFenceFdKHR;
+ PFN_vkGetFenceFdKHR GetFenceFdKHR;
+
+ // ---- VK_KHR_get_memory_requirements2 extension commands
+ PFN_vkGetImageMemoryRequirements2KHR GetImageMemoryRequirements2KHR;
+ PFN_vkGetBufferMemoryRequirements2KHR GetBufferMemoryRequirements2KHR;
+ PFN_vkGetImageSparseMemoryRequirements2KHR GetImageSparseMemoryRequirements2KHR;
+
+ // ---- VK_KHR_external_memory_fuchsia extension commands
+ PFN_vkGetMemoryFuchsiaHandleKHR GetMemoryFuchsiaHandleKHR;
+ PFN_vkGetMemoryFuchsiaHandlePropertiesKHR GetMemoryFuchsiaHandlePropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_fuchsia extension commands
+ PFN_vkImportSemaphoreFuchsiaHandleKHR ImportSemaphoreFuchsiaHandleKHR;
+ PFN_vkGetSemaphoreFuchsiaHandleKHR GetSemaphoreFuchsiaHandleKHR;
+
+ // ---- VK_EXT_debug_marker extension commands
+ PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT;
+ PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT;
+ PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBeginEXT;
+ PFN_vkCmdDebugMarkerEndEXT CmdDebugMarkerEndEXT;
+ PFN_vkCmdDebugMarkerInsertEXT CmdDebugMarkerInsertEXT;
+
+ // ---- VK_AMD_draw_indirect_count extension commands
+ PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
+ PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
+
+ // ---- VK_NV_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetMemoryWin32HandleNV GetMemoryWin32HandleNV;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHX_device_group extension commands
+ PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX GetDeviceGroupPeerMemoryFeaturesKHX;
+ PFN_vkBindBufferMemory2KHX BindBufferMemory2KHX;
+ PFN_vkBindImageMemory2KHX BindImageMemory2KHX;
+ PFN_vkCmdSetDeviceMaskKHX CmdSetDeviceMaskKHX;
+ PFN_vkGetDeviceGroupPresentCapabilitiesKHX GetDeviceGroupPresentCapabilitiesKHX;
+ PFN_vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX;
+ PFN_vkAcquireNextImage2KHX AcquireNextImage2KHX;
+ PFN_vkCmdDispatchBaseKHX CmdDispatchBaseKHX;
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ PFN_vkCmdProcessCommandsNVX CmdProcessCommandsNVX;
+ PFN_vkCmdReserveSpaceForCommandsNVX CmdReserveSpaceForCommandsNVX;
+ PFN_vkCreateIndirectCommandsLayoutNVX CreateIndirectCommandsLayoutNVX;
+ PFN_vkDestroyIndirectCommandsLayoutNVX DestroyIndirectCommandsLayoutNVX;
+ PFN_vkCreateObjectTableNVX CreateObjectTableNVX;
+ PFN_vkDestroyObjectTableNVX DestroyObjectTableNVX;
+ PFN_vkRegisterObjectsNVX RegisterObjectsNVX;
+ PFN_vkUnregisterObjectsNVX UnregisterObjectsNVX;
+
+ // ---- VK_NV_clip_space_w_scaling extension commands
+ PFN_vkCmdSetViewportWScalingNV CmdSetViewportWScalingNV;
+
+ // ---- VK_EXT_display_control extension commands
+ PFN_vkDisplayPowerControlEXT DisplayPowerControlEXT;
+ PFN_vkRegisterDeviceEventEXT RegisterDeviceEventEXT;
+ PFN_vkRegisterDisplayEventEXT RegisterDisplayEventEXT;
+ PFN_vkGetSwapchainCounterEXT GetSwapchainCounterEXT;
+
+ // ---- VK_GOOGLE_display_timing extension commands
+ PFN_vkGetRefreshCycleDurationGOOGLE GetRefreshCycleDurationGOOGLE;
+ PFN_vkGetPastPresentationTimingGOOGLE GetPastPresentationTimingGOOGLE;
+
+ // ---- VK_EXT_discard_rectangles extension commands
+ PFN_vkCmdSetDiscardRectangleEXT CmdSetDiscardRectangleEXT;
+
+ // ---- VK_EXT_hdr_metadata extension commands
+ PFN_vkSetHdrMetadataEXT SetHdrMetadataEXT;
+
+ // ---- VK_GOOGLE_external_memory_magma extension commands
+ PFN_vkExportDeviceMemoryMAGMA ExportDeviceMemoryMAGMA;
+ PFN_vkImportDeviceMemoryMAGMA ImportDeviceMemoryMAGMA;
+} VkLayerDispatchTable;
+
+
diff --git a/build-fuchsia/generated/include/vk_loader_extensions.c b/build-fuchsia/generated/include/vk_loader_extensions.c
new file mode 100644
index 0000000..d6b99a1
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_loader_extensions.c
@@ -0,0 +1,2683 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See loader_extension_generator.py for modifications
+
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 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: Mark Young <marky@lunarg.com>
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "vk_loader_platform.h"
+#include "loader.h"
+#include "vk_loader_extensions.h"
+#include <vulkan/vk_icd.h>
+#include "wsi.h"
+#include "debug_report.h"
+#include "extension_manual.h"
+
+// Device extension error function
+VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev) {
+ struct loader_device *found_dev;
+ // The device going in is a trampoline device
+ struct loader_icd_term *icd_term = loader_get_icd_and_device(dev, &found_dev, NULL);
+
+ if (icd_term)
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ "Bad destination in loader trampoline dispatch,"
+ "Are layers and extensions that you are calling enabled?");
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
+}
+
+VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
+ const PFN_vkGetInstanceProcAddr fp_gipa) {
+
+#define LOOKUP_GIPA(func, required) \
+ do { \
+ icd_term->dispatch.func = (PFN_vk##func)fp_gipa(inst, "vk" #func); \
+ if (!icd_term->dispatch.func && required) { \
+ loader_log((struct loader_instance *)inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \
+ loader_platform_get_proc_address_error("vk" #func)); \
+ return false; \
+ } \
+ } while (0)
+
+
+ // ---- Core 1_0
+ LOOKUP_GIPA(DestroyInstance, true);
+ LOOKUP_GIPA(EnumeratePhysicalDevices, true);
+ LOOKUP_GIPA(GetPhysicalDeviceFeatures, true);
+ LOOKUP_GIPA(GetPhysicalDeviceFormatProperties, true);
+ LOOKUP_GIPA(GetPhysicalDeviceImageFormatProperties, true);
+ LOOKUP_GIPA(GetPhysicalDeviceProperties, true);
+ LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties, true);
+ LOOKUP_GIPA(GetPhysicalDeviceMemoryProperties, true);
+ LOOKUP_GIPA(GetDeviceProcAddr, true);
+ LOOKUP_GIPA(CreateDevice, true);
+ LOOKUP_GIPA(EnumerateDeviceExtensionProperties, true);
+ LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties, true);
+
+ // ---- VK_KHR_surface extension commands
+ LOOKUP_GIPA(DestroySurfaceKHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportKHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilitiesKHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormatsKHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSurfacePresentModesKHR, false);
+
+ // ---- VK_KHR_swapchain extension commands
+ LOOKUP_GIPA(CreateSwapchainKHR, false);
+
+ // ---- VK_KHR_display extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceDisplayPropertiesKHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceDisplayPlanePropertiesKHR, false);
+ LOOKUP_GIPA(GetDisplayPlaneSupportedDisplaysKHR, false);
+ LOOKUP_GIPA(GetDisplayModePropertiesKHR, false);
+ LOOKUP_GIPA(CreateDisplayModeKHR, false);
+ LOOKUP_GIPA(GetDisplayPlaneCapabilitiesKHR, false);
+ LOOKUP_GIPA(CreateDisplayPlaneSurfaceKHR, false);
+
+ // ---- VK_KHR_display_swapchain extension commands
+ LOOKUP_GIPA(CreateSharedSwapchainsKHR, false);
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ LOOKUP_GIPA(CreateXlibSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceXlibPresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ LOOKUP_GIPA(CreateXcbSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceXcbPresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ LOOKUP_GIPA(CreateWaylandSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceWaylandPresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ LOOKUP_GIPA(CreateMirSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceMirPresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ LOOKUP_GIPA(CreateAndroidSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ LOOKUP_GIPA(CreateWin32SurfaceKHR, false);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceWin32PresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ LOOKUP_GIPA(CreateMagmaSurfaceKHR, false);
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ LOOKUP_GIPA(GetPhysicalDeviceMagmaPresentationSupportKHR, false);
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceFeatures2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceProperties2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceFormatProperties2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceImageFormatProperties2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceMemoryProperties2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties2KHR, false);
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceExternalBufferPropertiesKHR, false);
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceExternalSemaphorePropertiesKHR, false);
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceExternalFencePropertiesKHR, false);
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilities2KHR, false);
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormats2KHR, false);
+
+ // ---- VK_EXT_debug_report extension commands
+ LOOKUP_GIPA(CreateDebugReportCallbackEXT, false);
+ LOOKUP_GIPA(DestroyDebugReportCallbackEXT, false);
+ LOOKUP_GIPA(DebugReportMessageEXT, false);
+
+ // ---- VK_EXT_debug_marker extension commands
+ LOOKUP_GIPA(DebugMarkerSetObjectTagEXT, false);
+ LOOKUP_GIPA(DebugMarkerSetObjectNameEXT, false);
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceExternalImageFormatPropertiesNV, false);
+
+ // ---- VK_KHX_device_group extension commands
+ LOOKUP_GIPA(GetDeviceGroupSurfacePresentModesKHX, false);
+ LOOKUP_GIPA(GetPhysicalDevicePresentRectanglesKHX, false);
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ LOOKUP_GIPA(CreateViSurfaceNN, false);
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ LOOKUP_GIPA(EnumeratePhysicalDeviceGroupsKHX, false);
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceGeneratedCommandsPropertiesNVX, false);
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ LOOKUP_GIPA(ReleaseDisplayEXT, false);
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ LOOKUP_GIPA(AcquireXlibDisplayEXT, false);
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ LOOKUP_GIPA(GetRandROutputDisplayEXT, false);
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilities2EXT, false);
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ LOOKUP_GIPA(CreateIOSSurfaceMVK, false);
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ LOOKUP_GIPA(CreateMacOSSurfaceMVK, false);
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+#undef LOOKUP_GIPA
+
+ return true;
+};
+
+// Init Device function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
+ VkDevice dev) {
+ VkLayerDispatchTable *table = &dev_table->core_dispatch;
+ for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError;
+
+ // ---- Core 1_0 commands
+ table->GetDeviceProcAddr = gpa;
+ table->DestroyDevice = (PFN_vkDestroyDevice)gpa(dev, "vkDestroyDevice");
+ table->GetDeviceQueue = (PFN_vkGetDeviceQueue)gpa(dev, "vkGetDeviceQueue");
+ table->QueueSubmit = (PFN_vkQueueSubmit)gpa(dev, "vkQueueSubmit");
+ table->QueueWaitIdle = (PFN_vkQueueWaitIdle)gpa(dev, "vkQueueWaitIdle");
+ table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle)gpa(dev, "vkDeviceWaitIdle");
+ table->AllocateMemory = (PFN_vkAllocateMemory)gpa(dev, "vkAllocateMemory");
+ table->FreeMemory = (PFN_vkFreeMemory)gpa(dev, "vkFreeMemory");
+ table->MapMemory = (PFN_vkMapMemory)gpa(dev, "vkMapMemory");
+ table->UnmapMemory = (PFN_vkUnmapMemory)gpa(dev, "vkUnmapMemory");
+ table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)gpa(dev, "vkFlushMappedMemoryRanges");
+ table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)gpa(dev, "vkInvalidateMappedMemoryRanges");
+ table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)gpa(dev, "vkGetDeviceMemoryCommitment");
+ table->BindBufferMemory = (PFN_vkBindBufferMemory)gpa(dev, "vkBindBufferMemory");
+ table->BindImageMemory = (PFN_vkBindImageMemory)gpa(dev, "vkBindImageMemory");
+ table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)gpa(dev, "vkGetBufferMemoryRequirements");
+ table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)gpa(dev, "vkGetImageMemoryRequirements");
+ table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements)gpa(dev, "vkGetImageSparseMemoryRequirements");
+ table->QueueBindSparse = (PFN_vkQueueBindSparse)gpa(dev, "vkQueueBindSparse");
+ table->CreateFence = (PFN_vkCreateFence)gpa(dev, "vkCreateFence");
+ table->DestroyFence = (PFN_vkDestroyFence)gpa(dev, "vkDestroyFence");
+ table->ResetFences = (PFN_vkResetFences)gpa(dev, "vkResetFences");
+ table->GetFenceStatus = (PFN_vkGetFenceStatus)gpa(dev, "vkGetFenceStatus");
+ table->WaitForFences = (PFN_vkWaitForFences)gpa(dev, "vkWaitForFences");
+ table->CreateSemaphore = (PFN_vkCreateSemaphore)gpa(dev, "vkCreateSemaphore");
+ table->DestroySemaphore = (PFN_vkDestroySemaphore)gpa(dev, "vkDestroySemaphore");
+ table->CreateEvent = (PFN_vkCreateEvent)gpa(dev, "vkCreateEvent");
+ table->DestroyEvent = (PFN_vkDestroyEvent)gpa(dev, "vkDestroyEvent");
+ table->GetEventStatus = (PFN_vkGetEventStatus)gpa(dev, "vkGetEventStatus");
+ table->SetEvent = (PFN_vkSetEvent)gpa(dev, "vkSetEvent");
+ table->ResetEvent = (PFN_vkResetEvent)gpa(dev, "vkResetEvent");
+ table->CreateQueryPool = (PFN_vkCreateQueryPool)gpa(dev, "vkCreateQueryPool");
+ table->DestroyQueryPool = (PFN_vkDestroyQueryPool)gpa(dev, "vkDestroyQueryPool");
+ table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults)gpa(dev, "vkGetQueryPoolResults");
+ table->CreateBuffer = (PFN_vkCreateBuffer)gpa(dev, "vkCreateBuffer");
+ table->DestroyBuffer = (PFN_vkDestroyBuffer)gpa(dev, "vkDestroyBuffer");
+ table->CreateBufferView = (PFN_vkCreateBufferView)gpa(dev, "vkCreateBufferView");
+ table->DestroyBufferView = (PFN_vkDestroyBufferView)gpa(dev, "vkDestroyBufferView");
+ table->CreateImage = (PFN_vkCreateImage)gpa(dev, "vkCreateImage");
+ table->DestroyImage = (PFN_vkDestroyImage)gpa(dev, "vkDestroyImage");
+ table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)gpa(dev, "vkGetImageSubresourceLayout");
+ table->CreateImageView = (PFN_vkCreateImageView)gpa(dev, "vkCreateImageView");
+ table->DestroyImageView = (PFN_vkDestroyImageView)gpa(dev, "vkDestroyImageView");
+ table->CreateShaderModule = (PFN_vkCreateShaderModule)gpa(dev, "vkCreateShaderModule");
+ table->DestroyShaderModule = (PFN_vkDestroyShaderModule)gpa(dev, "vkDestroyShaderModule");
+ table->CreatePipelineCache = (PFN_vkCreatePipelineCache)gpa(dev, "vkCreatePipelineCache");
+ table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache)gpa(dev, "vkDestroyPipelineCache");
+ table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData)gpa(dev, "vkGetPipelineCacheData");
+ table->MergePipelineCaches = (PFN_vkMergePipelineCaches)gpa(dev, "vkMergePipelineCaches");
+ table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)gpa(dev, "vkCreateGraphicsPipelines");
+ table->CreateComputePipelines = (PFN_vkCreateComputePipelines)gpa(dev, "vkCreateComputePipelines");
+ table->DestroyPipeline = (PFN_vkDestroyPipeline)gpa(dev, "vkDestroyPipeline");
+ table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout)gpa(dev, "vkCreatePipelineLayout");
+ table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)gpa(dev, "vkDestroyPipelineLayout");
+ table->CreateSampler = (PFN_vkCreateSampler)gpa(dev, "vkCreateSampler");
+ table->DestroySampler = (PFN_vkDestroySampler)gpa(dev, "vkDestroySampler");
+ table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)gpa(dev, "vkCreateDescriptorSetLayout");
+ table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)gpa(dev, "vkDestroyDescriptorSetLayout");
+ table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool)gpa(dev, "vkCreateDescriptorPool");
+ table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)gpa(dev, "vkDestroyDescriptorPool");
+ table->ResetDescriptorPool = (PFN_vkResetDescriptorPool)gpa(dev, "vkResetDescriptorPool");
+ table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)gpa(dev, "vkAllocateDescriptorSets");
+ table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets)gpa(dev, "vkFreeDescriptorSets");
+ table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)gpa(dev, "vkUpdateDescriptorSets");
+ table->CreateFramebuffer = (PFN_vkCreateFramebuffer)gpa(dev, "vkCreateFramebuffer");
+ table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer)gpa(dev, "vkDestroyFramebuffer");
+ table->CreateRenderPass = (PFN_vkCreateRenderPass)gpa(dev, "vkCreateRenderPass");
+ table->DestroyRenderPass = (PFN_vkDestroyRenderPass)gpa(dev, "vkDestroyRenderPass");
+ table->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)gpa(dev, "vkGetRenderAreaGranularity");
+ table->CreateCommandPool = (PFN_vkCreateCommandPool)gpa(dev, "vkCreateCommandPool");
+ table->DestroyCommandPool = (PFN_vkDestroyCommandPool)gpa(dev, "vkDestroyCommandPool");
+ table->ResetCommandPool = (PFN_vkResetCommandPool)gpa(dev, "vkResetCommandPool");
+ table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)gpa(dev, "vkAllocateCommandBuffers");
+ table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers)gpa(dev, "vkFreeCommandBuffers");
+ table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer)gpa(dev, "vkBeginCommandBuffer");
+ table->EndCommandBuffer = (PFN_vkEndCommandBuffer)gpa(dev, "vkEndCommandBuffer");
+ table->ResetCommandBuffer = (PFN_vkResetCommandBuffer)gpa(dev, "vkResetCommandBuffer");
+ table->CmdBindPipeline = (PFN_vkCmdBindPipeline)gpa(dev, "vkCmdBindPipeline");
+ table->CmdSetViewport = (PFN_vkCmdSetViewport)gpa(dev, "vkCmdSetViewport");
+ table->CmdSetScissor = (PFN_vkCmdSetScissor)gpa(dev, "vkCmdSetScissor");
+ table->CmdSetLineWidth = (PFN_vkCmdSetLineWidth)gpa(dev, "vkCmdSetLineWidth");
+ table->CmdSetDepthBias = (PFN_vkCmdSetDepthBias)gpa(dev, "vkCmdSetDepthBias");
+ table->CmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)gpa(dev, "vkCmdSetBlendConstants");
+ table->CmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)gpa(dev, "vkCmdSetDepthBounds");
+ table->CmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)gpa(dev, "vkCmdSetStencilCompareMask");
+ table->CmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)gpa(dev, "vkCmdSetStencilWriteMask");
+ table->CmdSetStencilReference = (PFN_vkCmdSetStencilReference)gpa(dev, "vkCmdSetStencilReference");
+ table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)gpa(dev, "vkCmdBindDescriptorSets");
+ table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)gpa(dev, "vkCmdBindIndexBuffer");
+ table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)gpa(dev, "vkCmdBindVertexBuffers");
+ table->CmdDraw = (PFN_vkCmdDraw)gpa(dev, "vkCmdDraw");
+ table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed)gpa(dev, "vkCmdDrawIndexed");
+ table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect)gpa(dev, "vkCmdDrawIndirect");
+ table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)gpa(dev, "vkCmdDrawIndexedIndirect");
+ table->CmdDispatch = (PFN_vkCmdDispatch)gpa(dev, "vkCmdDispatch");
+ table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)gpa(dev, "vkCmdDispatchIndirect");
+ table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer)gpa(dev, "vkCmdCopyBuffer");
+ table->CmdCopyImage = (PFN_vkCmdCopyImage)gpa(dev, "vkCmdCopyImage");
+ table->CmdBlitImage = (PFN_vkCmdBlitImage)gpa(dev, "vkCmdBlitImage");
+ table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)gpa(dev, "vkCmdCopyBufferToImage");
+ table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)gpa(dev, "vkCmdCopyImageToBuffer");
+ table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)gpa(dev, "vkCmdUpdateBuffer");
+ table->CmdFillBuffer = (PFN_vkCmdFillBuffer)gpa(dev, "vkCmdFillBuffer");
+ table->CmdClearColorImage = (PFN_vkCmdClearColorImage)gpa(dev, "vkCmdClearColorImage");
+ table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)gpa(dev, "vkCmdClearDepthStencilImage");
+ table->CmdClearAttachments = (PFN_vkCmdClearAttachments)gpa(dev, "vkCmdClearAttachments");
+ table->CmdResolveImage = (PFN_vkCmdResolveImage)gpa(dev, "vkCmdResolveImage");
+ table->CmdSetEvent = (PFN_vkCmdSetEvent)gpa(dev, "vkCmdSetEvent");
+ table->CmdResetEvent = (PFN_vkCmdResetEvent)gpa(dev, "vkCmdResetEvent");
+ table->CmdWaitEvents = (PFN_vkCmdWaitEvents)gpa(dev, "vkCmdWaitEvents");
+ table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)gpa(dev, "vkCmdPipelineBarrier");
+ table->CmdBeginQuery = (PFN_vkCmdBeginQuery)gpa(dev, "vkCmdBeginQuery");
+ table->CmdEndQuery = (PFN_vkCmdEndQuery)gpa(dev, "vkCmdEndQuery");
+ table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool)gpa(dev, "vkCmdResetQueryPool");
+ table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)gpa(dev, "vkCmdWriteTimestamp");
+ table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)gpa(dev, "vkCmdCopyQueryPoolResults");
+ table->CmdPushConstants = (PFN_vkCmdPushConstants)gpa(dev, "vkCmdPushConstants");
+ table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)gpa(dev, "vkCmdBeginRenderPass");
+ table->CmdNextSubpass = (PFN_vkCmdNextSubpass)gpa(dev, "vkCmdNextSubpass");
+ table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass)gpa(dev, "vkCmdEndRenderPass");
+ table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands)gpa(dev, "vkCmdExecuteCommands");
+}
+
+// Init Device function pointer dispatch table with extension commands
+VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,
+ PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {
+ VkLayerDispatchTable *table = &dev_table->core_dispatch;
+
+ // ---- VK_KHR_swapchain extension commands
+ table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(dev, "vkCreateSwapchainKHR");
+ table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gpa(dev, "vkDestroySwapchainKHR");
+ table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gpa(dev, "vkGetSwapchainImagesKHR");
+ table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)gpa(dev, "vkAcquireNextImageKHR");
+ table->QueuePresentKHR = (PFN_vkQueuePresentKHR)gpa(dev, "vkQueuePresentKHR");
+
+ // ---- VK_KHR_display_swapchain extension commands
+ table->CreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)gpa(dev, "vkCreateSharedSwapchainsKHR");
+
+ // ---- VK_KHR_maintenance1 extension commands
+ table->TrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)gpa(dev, "vkTrimCommandPoolKHR");
+
+ // ---- VK_KHR_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)gpa(dev, "vkGetMemoryWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR)gpa(dev, "vkGetMemoryWin32HandlePropertiesKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_memory_fd extension commands
+ table->GetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)gpa(dev, "vkGetMemoryFdKHR");
+ table->GetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)gpa(dev, "vkGetMemoryFdPropertiesKHR");
+
+ // ---- VK_KHR_external_semaphore_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->ImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR)gpa(dev, "vkImportSemaphoreWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR)gpa(dev, "vkGetSemaphoreWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_semaphore_fd extension commands
+ table->ImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)gpa(dev, "vkImportSemaphoreFdKHR");
+ table->GetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)gpa(dev, "vkGetSemaphoreFdKHR");
+
+ // ---- VK_KHR_push_descriptor extension commands
+ table->CmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)gpa(dev, "vkCmdPushDescriptorSetKHR");
+
+ // ---- VK_KHR_descriptor_update_template extension commands
+ table->CreateDescriptorUpdateTemplateKHR = (PFN_vkCreateDescriptorUpdateTemplateKHR)gpa(dev, "vkCreateDescriptorUpdateTemplateKHR");
+ table->DestroyDescriptorUpdateTemplateKHR = (PFN_vkDestroyDescriptorUpdateTemplateKHR)gpa(dev, "vkDestroyDescriptorUpdateTemplateKHR");
+ table->UpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR)gpa(dev, "vkUpdateDescriptorSetWithTemplateKHR");
+ table->CmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)gpa(dev, "vkCmdPushDescriptorSetWithTemplateKHR");
+
+ // ---- VK_KHR_shared_presentable_image extension commands
+ table->GetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR)gpa(dev, "vkGetSwapchainStatusKHR");
+
+ // ---- VK_KHR_external_fence_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->ImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR)gpa(dev, "vkImportFenceWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR)gpa(dev, "vkGetFenceWin32HandleKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_fence_fd extension commands
+ table->ImportFenceFdKHR = (PFN_vkImportFenceFdKHR)gpa(dev, "vkImportFenceFdKHR");
+ table->GetFenceFdKHR = (PFN_vkGetFenceFdKHR)gpa(dev, "vkGetFenceFdKHR");
+
+ // ---- VK_KHR_get_memory_requirements2 extension commands
+ table->GetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)gpa(dev, "vkGetImageMemoryRequirements2KHR");
+ table->GetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR)gpa(dev, "vkGetBufferMemoryRequirements2KHR");
+ table->GetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)gpa(dev, "vkGetImageSparseMemoryRequirements2KHR");
+
+ // ---- VK_KHR_external_memory_fuchsia extension commands
+ table->GetMemoryFuchsiaHandleKHR = (PFN_vkGetMemoryFuchsiaHandleKHR)gpa(dev, "vkGetMemoryFuchsiaHandleKHR");
+ table->GetMemoryFuchsiaHandlePropertiesKHR = (PFN_vkGetMemoryFuchsiaHandlePropertiesKHR)gpa(dev, "vkGetMemoryFuchsiaHandlePropertiesKHR");
+
+ // ---- VK_KHR_external_semaphore_fuchsia extension commands
+ table->ImportSemaphoreFuchsiaHandleKHR = (PFN_vkImportSemaphoreFuchsiaHandleKHR)gpa(dev, "vkImportSemaphoreFuchsiaHandleKHR");
+ table->GetSemaphoreFuchsiaHandleKHR = (PFN_vkGetSemaphoreFuchsiaHandleKHR)gpa(dev, "vkGetSemaphoreFuchsiaHandleKHR");
+
+ // ---- VK_EXT_debug_marker extension commands
+ table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(dev, "vkDebugMarkerSetObjectTagEXT");
+ table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gpa(dev, "vkDebugMarkerSetObjectNameEXT");
+ table->CmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)gpa(dev, "vkCmdDebugMarkerBeginEXT");
+ table->CmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT");
+ table->CmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT");
+
+ // ---- VK_AMD_draw_indirect_count extension commands
+ table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gpa(dev, "vkCmdDrawIndirectCountAMD");
+ table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gpa(dev, "vkCmdDrawIndexedIndirectCountAMD");
+
+ // ---- VK_NV_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV)gpa(dev, "vkGetMemoryWin32HandleNV");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHX_device_group extension commands
+ table->GetDeviceGroupPeerMemoryFeaturesKHX = (PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)gpa(dev, "vkGetDeviceGroupPeerMemoryFeaturesKHX");
+ table->BindBufferMemory2KHX = (PFN_vkBindBufferMemory2KHX)gpa(dev, "vkBindBufferMemory2KHX");
+ table->BindImageMemory2KHX = (PFN_vkBindImageMemory2KHX)gpa(dev, "vkBindImageMemory2KHX");
+ table->CmdSetDeviceMaskKHX = (PFN_vkCmdSetDeviceMaskKHX)gpa(dev, "vkCmdSetDeviceMaskKHX");
+ table->GetDeviceGroupPresentCapabilitiesKHX = (PFN_vkGetDeviceGroupPresentCapabilitiesKHX)gpa(dev, "vkGetDeviceGroupPresentCapabilitiesKHX");
+ table->GetDeviceGroupSurfacePresentModesKHX = (PFN_vkGetDeviceGroupSurfacePresentModesKHX)gpa(dev, "vkGetDeviceGroupSurfacePresentModesKHX");
+ table->AcquireNextImage2KHX = (PFN_vkAcquireNextImage2KHX)gpa(dev, "vkAcquireNextImage2KHX");
+ table->CmdDispatchBaseKHX = (PFN_vkCmdDispatchBaseKHX)gpa(dev, "vkCmdDispatchBaseKHX");
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ table->CmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX");
+ table->CmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(dev, "vkCmdReserveSpaceForCommandsNVX");
+ table->CreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX)gpa(dev, "vkCreateIndirectCommandsLayoutNVX");
+ table->DestroyIndirectCommandsLayoutNVX = (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa(dev, "vkDestroyIndirectCommandsLayoutNVX");
+ table->CreateObjectTableNVX = (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX");
+ table->DestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX");
+ table->RegisterObjectsNVX = (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX");
+ table->UnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX");
+
+ // ---- VK_NV_clip_space_w_scaling extension commands
+ table->CmdSetViewportWScalingNV = (PFN_vkCmdSetViewportWScalingNV)gpa(dev, "vkCmdSetViewportWScalingNV");
+
+ // ---- VK_EXT_display_control extension commands
+ table->DisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT)gpa(dev, "vkDisplayPowerControlEXT");
+ table->RegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT)gpa(dev, "vkRegisterDeviceEventEXT");
+ table->RegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT)gpa(dev, "vkRegisterDisplayEventEXT");
+ table->GetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT)gpa(dev, "vkGetSwapchainCounterEXT");
+
+ // ---- VK_GOOGLE_display_timing extension commands
+ table->GetRefreshCycleDurationGOOGLE = (PFN_vkGetRefreshCycleDurationGOOGLE)gpa(dev, "vkGetRefreshCycleDurationGOOGLE");
+ table->GetPastPresentationTimingGOOGLE = (PFN_vkGetPastPresentationTimingGOOGLE)gpa(dev, "vkGetPastPresentationTimingGOOGLE");
+
+ // ---- VK_EXT_discard_rectangles extension commands
+ table->CmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)gpa(dev, "vkCmdSetDiscardRectangleEXT");
+
+ // ---- VK_EXT_hdr_metadata extension commands
+ table->SetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)gpa(dev, "vkSetHdrMetadataEXT");
+
+ // ---- VK_GOOGLE_external_memory_magma extension commands
+ table->ExportDeviceMemoryMAGMA = (PFN_vkExportDeviceMemoryMAGMA)gpa(dev, "vkExportDeviceMemoryMAGMA");
+ table->ImportDeviceMemoryMAGMA = (PFN_vkImportDeviceMemoryMAGMA)gpa(dev, "vkImportDeviceMemoryMAGMA");
+}
+
+// Init Instance function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+ VkInstance inst) {
+
+ // ---- Core 1_0 commands
+ table->DestroyInstance = (PFN_vkDestroyInstance)gpa(inst, "vkDestroyInstance");
+ table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)gpa(inst, "vkEnumeratePhysicalDevices");
+ table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)gpa(inst, "vkGetPhysicalDeviceFeatures");
+ table->GetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties)gpa(inst, "vkGetPhysicalDeviceFormatProperties");
+ table->GetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties");
+ table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gpa(inst, "vkGetPhysicalDeviceProperties");
+ table->GetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties");
+ table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)gpa(inst, "vkGetPhysicalDeviceMemoryProperties");
+ table->GetInstanceProcAddr = gpa;
+ table->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)gpa(inst, "vkEnumerateDeviceExtensionProperties");
+ table->EnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties)gpa(inst, "vkEnumerateDeviceLayerProperties");
+ table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
+}
+
+// Init Instance function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+ VkInstance inst) {
+
+ // ---- VK_KHR_surface extension commands
+ table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)gpa(inst, "vkDestroySurfaceKHR");
+ table->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
+ table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+ table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+ table->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)gpa(inst, "vkGetPhysicalDeviceSurfacePresentModesKHR");
+
+ // ---- VK_KHR_display extension commands
+ table->GetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPropertiesKHR");
+ table->GetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
+ table->GetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)gpa(inst, "vkGetDisplayPlaneSupportedDisplaysKHR");
+ table->GetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR)gpa(inst, "vkGetDisplayModePropertiesKHR");
+ table->CreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR)gpa(inst, "vkCreateDisplayModeKHR");
+ table->GetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR)gpa(inst, "vkGetDisplayPlaneCapabilitiesKHR");
+ table->CreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa(inst, "vkCreateDisplayPlaneSurfaceKHR");
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ table->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)gpa(inst, "vkCreateXlibSurfaceKHR");
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ table->GetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ table->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)gpa(inst, "vkCreateXcbSurfaceKHR");
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ table->GetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ table->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)gpa(inst, "vkCreateWaylandSurfaceKHR");
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ table->GetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ table->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR)gpa(inst, "vkCreateMirSurfaceKHR");
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ table->GetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceMirPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ table->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)gpa(inst, "vkCreateAndroidSurfaceKHR");
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)gpa(inst, "vkCreateWin32SurfaceKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ table->GetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ table->CreateMagmaSurfaceKHR = (PFN_vkCreateMagmaSurfaceKHR)gpa(inst, "vkCreateMagmaSurfaceKHR");
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ table->GetPhysicalDeviceMagmaPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMagmaPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceMagmaPresentationSupportKHR");
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ table->GetPhysicalDeviceFeatures2KHR = (PFN_vkGetPhysicalDeviceFeatures2KHR)gpa(inst, "vkGetPhysicalDeviceFeatures2KHR");
+ table->GetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR)gpa(inst, "vkGetPhysicalDeviceProperties2KHR");
+ table->GetPhysicalDeviceFormatProperties2KHR = (PFN_vkGetPhysicalDeviceFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceFormatProperties2KHR");
+ table->GetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties2KHR");
+ table->GetPhysicalDeviceQueueFamilyProperties2KHR = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+ table->GetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)gpa(inst, "vkGetPhysicalDeviceMemoryProperties2KHR");
+ table->GetPhysicalDeviceSparseImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ table->GetPhysicalDeviceExternalBufferPropertiesKHR = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ table->GetPhysicalDeviceExternalSemaphorePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ table->GetPhysicalDeviceExternalFencePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalFencePropertiesKHR");
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ table->GetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+ table->GetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormats2KHR");
+
+ // ---- VK_EXT_debug_report extension commands
+ table->CreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)gpa(inst, "vkCreateDebugReportCallbackEXT");
+ table->DestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)gpa(inst, "vkDestroyDebugReportCallbackEXT");
+ table->DebugReportMessageEXT = (PFN_vkDebugReportMessageEXT)gpa(inst, "vkDebugReportMessageEXT");
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ table->GetPhysicalDeviceExternalImageFormatPropertiesNV = (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)gpa(inst, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+
+ // ---- VK_KHX_device_group extension commands
+ table->GetPhysicalDevicePresentRectanglesKHX = (PFN_vkGetPhysicalDevicePresentRectanglesKHX)gpa(inst, "vkGetPhysicalDevicePresentRectanglesKHX");
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ table->CreateViSurfaceNN = (PFN_vkCreateViSurfaceNN)gpa(inst, "vkCreateViSurfaceNN");
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ table->EnumeratePhysicalDeviceGroupsKHX = (PFN_vkEnumeratePhysicalDeviceGroupsKHX)gpa(inst, "vkEnumeratePhysicalDeviceGroupsKHX");
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX = (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ table->ReleaseDisplayEXT = (PFN_vkReleaseDisplayEXT)gpa(inst, "vkReleaseDisplayEXT");
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ table->AcquireXlibDisplayEXT = (PFN_vkAcquireXlibDisplayEXT)gpa(inst, "vkAcquireXlibDisplayEXT");
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ table->GetRandROutputDisplayEXT = (PFN_vkGetRandROutputDisplayEXT)gpa(inst, "vkGetRandROutputDisplayEXT");
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ table->GetPhysicalDeviceSurfaceCapabilities2EXT = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ table->CreateIOSSurfaceMVK = (PFN_vkCreateIOSSurfaceMVK)gpa(inst, "vkCreateIOSSurfaceMVK");
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ table->CreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK)gpa(inst, "vkCreateMacOSSurfaceMVK");
+#endif // VK_USE_PLATFORM_MACOS_MVK
+}
+
+// Device command lookup function
+VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name) {
+ if (!name || name[0] != 'v' || name[1] != 'k') return NULL;
+
+ name += 2;
+
+ // ---- Core 1_0 commands
+ if (!strcmp(name, "GetDeviceProcAddr")) return (void *)table->GetDeviceProcAddr;
+ if (!strcmp(name, "DestroyDevice")) return (void *)table->DestroyDevice;
+ if (!strcmp(name, "GetDeviceQueue")) return (void *)table->GetDeviceQueue;
+ if (!strcmp(name, "QueueSubmit")) return (void *)table->QueueSubmit;
+ if (!strcmp(name, "QueueWaitIdle")) return (void *)table->QueueWaitIdle;
+ if (!strcmp(name, "DeviceWaitIdle")) return (void *)table->DeviceWaitIdle;
+ if (!strcmp(name, "AllocateMemory")) return (void *)table->AllocateMemory;
+ if (!strcmp(name, "FreeMemory")) return (void *)table->FreeMemory;
+ if (!strcmp(name, "MapMemory")) return (void *)table->MapMemory;
+ if (!strcmp(name, "UnmapMemory")) return (void *)table->UnmapMemory;
+ if (!strcmp(name, "FlushMappedMemoryRanges")) return (void *)table->FlushMappedMemoryRanges;
+ if (!strcmp(name, "InvalidateMappedMemoryRanges")) return (void *)table->InvalidateMappedMemoryRanges;
+ if (!strcmp(name, "GetDeviceMemoryCommitment")) return (void *)table->GetDeviceMemoryCommitment;
+ if (!strcmp(name, "BindBufferMemory")) return (void *)table->BindBufferMemory;
+ if (!strcmp(name, "BindImageMemory")) return (void *)table->BindImageMemory;
+ if (!strcmp(name, "GetBufferMemoryRequirements")) return (void *)table->GetBufferMemoryRequirements;
+ if (!strcmp(name, "GetImageMemoryRequirements")) return (void *)table->GetImageMemoryRequirements;
+ if (!strcmp(name, "GetImageSparseMemoryRequirements")) return (void *)table->GetImageSparseMemoryRequirements;
+ if (!strcmp(name, "QueueBindSparse")) return (void *)table->QueueBindSparse;
+ if (!strcmp(name, "CreateFence")) return (void *)table->CreateFence;
+ if (!strcmp(name, "DestroyFence")) return (void *)table->DestroyFence;
+ if (!strcmp(name, "ResetFences")) return (void *)table->ResetFences;
+ if (!strcmp(name, "GetFenceStatus")) return (void *)table->GetFenceStatus;
+ if (!strcmp(name, "WaitForFences")) return (void *)table->WaitForFences;
+ if (!strcmp(name, "CreateSemaphore")) return (void *)table->CreateSemaphore;
+ if (!strcmp(name, "DestroySemaphore")) return (void *)table->DestroySemaphore;
+ if (!strcmp(name, "CreateEvent")) return (void *)table->CreateEvent;
+ if (!strcmp(name, "DestroyEvent")) return (void *)table->DestroyEvent;
+ if (!strcmp(name, "GetEventStatus")) return (void *)table->GetEventStatus;
+ if (!strcmp(name, "SetEvent")) return (void *)table->SetEvent;
+ if (!strcmp(name, "ResetEvent")) return (void *)table->ResetEvent;
+ if (!strcmp(name, "CreateQueryPool")) return (void *)table->CreateQueryPool;
+ if (!strcmp(name, "DestroyQueryPool")) return (void *)table->DestroyQueryPool;
+ if (!strcmp(name, "GetQueryPoolResults")) return (void *)table->GetQueryPoolResults;
+ if (!strcmp(name, "CreateBuffer")) return (void *)table->CreateBuffer;
+ if (!strcmp(name, "DestroyBuffer")) return (void *)table->DestroyBuffer;
+ if (!strcmp(name, "CreateBufferView")) return (void *)table->CreateBufferView;
+ if (!strcmp(name, "DestroyBufferView")) return (void *)table->DestroyBufferView;
+ if (!strcmp(name, "CreateImage")) return (void *)table->CreateImage;
+ if (!strcmp(name, "DestroyImage")) return (void *)table->DestroyImage;
+ if (!strcmp(name, "GetImageSubresourceLayout")) return (void *)table->GetImageSubresourceLayout;
+ if (!strcmp(name, "CreateImageView")) return (void *)table->CreateImageView;
+ if (!strcmp(name, "DestroyImageView")) return (void *)table->DestroyImageView;
+ if (!strcmp(name, "CreateShaderModule")) return (void *)table->CreateShaderModule;
+ if (!strcmp(name, "DestroyShaderModule")) return (void *)table->DestroyShaderModule;
+ if (!strcmp(name, "CreatePipelineCache")) return (void *)table->CreatePipelineCache;
+ if (!strcmp(name, "DestroyPipelineCache")) return (void *)table->DestroyPipelineCache;
+ if (!strcmp(name, "GetPipelineCacheData")) return (void *)table->GetPipelineCacheData;
+ if (!strcmp(name, "MergePipelineCaches")) return (void *)table->MergePipelineCaches;
+ if (!strcmp(name, "CreateGraphicsPipelines")) return (void *)table->CreateGraphicsPipelines;
+ if (!strcmp(name, "CreateComputePipelines")) return (void *)table->CreateComputePipelines;
+ if (!strcmp(name, "DestroyPipeline")) return (void *)table->DestroyPipeline;
+ if (!strcmp(name, "CreatePipelineLayout")) return (void *)table->CreatePipelineLayout;
+ if (!strcmp(name, "DestroyPipelineLayout")) return (void *)table->DestroyPipelineLayout;
+ if (!strcmp(name, "CreateSampler")) return (void *)table->CreateSampler;
+ if (!strcmp(name, "DestroySampler")) return (void *)table->DestroySampler;
+ if (!strcmp(name, "CreateDescriptorSetLayout")) return (void *)table->CreateDescriptorSetLayout;
+ if (!strcmp(name, "DestroyDescriptorSetLayout")) return (void *)table->DestroyDescriptorSetLayout;
+ if (!strcmp(name, "CreateDescriptorPool")) return (void *)table->CreateDescriptorPool;
+ if (!strcmp(name, "DestroyDescriptorPool")) return (void *)table->DestroyDescriptorPool;
+ if (!strcmp(name, "ResetDescriptorPool")) return (void *)table->ResetDescriptorPool;
+ if (!strcmp(name, "AllocateDescriptorSets")) return (void *)table->AllocateDescriptorSets;
+ if (!strcmp(name, "FreeDescriptorSets")) return (void *)table->FreeDescriptorSets;
+ if (!strcmp(name, "UpdateDescriptorSets")) return (void *)table->UpdateDescriptorSets;
+ if (!strcmp(name, "CreateFramebuffer")) return (void *)table->CreateFramebuffer;
+ if (!strcmp(name, "DestroyFramebuffer")) return (void *)table->DestroyFramebuffer;
+ if (!strcmp(name, "CreateRenderPass")) return (void *)table->CreateRenderPass;
+ if (!strcmp(name, "DestroyRenderPass")) return (void *)table->DestroyRenderPass;
+ if (!strcmp(name, "GetRenderAreaGranularity")) return (void *)table->GetRenderAreaGranularity;
+ if (!strcmp(name, "CreateCommandPool")) return (void *)table->CreateCommandPool;
+ if (!strcmp(name, "DestroyCommandPool")) return (void *)table->DestroyCommandPool;
+ if (!strcmp(name, "ResetCommandPool")) return (void *)table->ResetCommandPool;
+ if (!strcmp(name, "AllocateCommandBuffers")) return (void *)table->AllocateCommandBuffers;
+ if (!strcmp(name, "FreeCommandBuffers")) return (void *)table->FreeCommandBuffers;
+ if (!strcmp(name, "BeginCommandBuffer")) return (void *)table->BeginCommandBuffer;
+ if (!strcmp(name, "EndCommandBuffer")) return (void *)table->EndCommandBuffer;
+ if (!strcmp(name, "ResetCommandBuffer")) return (void *)table->ResetCommandBuffer;
+ if (!strcmp(name, "CmdBindPipeline")) return (void *)table->CmdBindPipeline;
+ if (!strcmp(name, "CmdSetViewport")) return (void *)table->CmdSetViewport;
+ if (!strcmp(name, "CmdSetScissor")) return (void *)table->CmdSetScissor;
+ if (!strcmp(name, "CmdSetLineWidth")) return (void *)table->CmdSetLineWidth;
+ if (!strcmp(name, "CmdSetDepthBias")) return (void *)table->CmdSetDepthBias;
+ if (!strcmp(name, "CmdSetBlendConstants")) return (void *)table->CmdSetBlendConstants;
+ if (!strcmp(name, "CmdSetDepthBounds")) return (void *)table->CmdSetDepthBounds;
+ if (!strcmp(name, "CmdSetStencilCompareMask")) return (void *)table->CmdSetStencilCompareMask;
+ if (!strcmp(name, "CmdSetStencilWriteMask")) return (void *)table->CmdSetStencilWriteMask;
+ if (!strcmp(name, "CmdSetStencilReference")) return (void *)table->CmdSetStencilReference;
+ if (!strcmp(name, "CmdBindDescriptorSets")) return (void *)table->CmdBindDescriptorSets;
+ if (!strcmp(name, "CmdBindIndexBuffer")) return (void *)table->CmdBindIndexBuffer;
+ if (!strcmp(name, "CmdBindVertexBuffers")) return (void *)table->CmdBindVertexBuffers;
+ if (!strcmp(name, "CmdDraw")) return (void *)table->CmdDraw;
+ if (!strcmp(name, "CmdDrawIndexed")) return (void *)table->CmdDrawIndexed;
+ if (!strcmp(name, "CmdDrawIndirect")) return (void *)table->CmdDrawIndirect;
+ if (!strcmp(name, "CmdDrawIndexedIndirect")) return (void *)table->CmdDrawIndexedIndirect;
+ if (!strcmp(name, "CmdDispatch")) return (void *)table->CmdDispatch;
+ if (!strcmp(name, "CmdDispatchIndirect")) return (void *)table->CmdDispatchIndirect;
+ if (!strcmp(name, "CmdCopyBuffer")) return (void *)table->CmdCopyBuffer;
+ if (!strcmp(name, "CmdCopyImage")) return (void *)table->CmdCopyImage;
+ if (!strcmp(name, "CmdBlitImage")) return (void *)table->CmdBlitImage;
+ if (!strcmp(name, "CmdCopyBufferToImage")) return (void *)table->CmdCopyBufferToImage;
+ if (!strcmp(name, "CmdCopyImageToBuffer")) return (void *)table->CmdCopyImageToBuffer;
+ if (!strcmp(name, "CmdUpdateBuffer")) return (void *)table->CmdUpdateBuffer;
+ if (!strcmp(name, "CmdFillBuffer")) return (void *)table->CmdFillBuffer;
+ if (!strcmp(name, "CmdClearColorImage")) return (void *)table->CmdClearColorImage;
+ if (!strcmp(name, "CmdClearDepthStencilImage")) return (void *)table->CmdClearDepthStencilImage;
+ if (!strcmp(name, "CmdClearAttachments")) return (void *)table->CmdClearAttachments;
+ if (!strcmp(name, "CmdResolveImage")) return (void *)table->CmdResolveImage;
+ if (!strcmp(name, "CmdSetEvent")) return (void *)table->CmdSetEvent;
+ if (!strcmp(name, "CmdResetEvent")) return (void *)table->CmdResetEvent;
+ if (!strcmp(name, "CmdWaitEvents")) return (void *)table->CmdWaitEvents;
+ if (!strcmp(name, "CmdPipelineBarrier")) return (void *)table->CmdPipelineBarrier;
+ if (!strcmp(name, "CmdBeginQuery")) return (void *)table->CmdBeginQuery;
+ if (!strcmp(name, "CmdEndQuery")) return (void *)table->CmdEndQuery;
+ if (!strcmp(name, "CmdResetQueryPool")) return (void *)table->CmdResetQueryPool;
+ if (!strcmp(name, "CmdWriteTimestamp")) return (void *)table->CmdWriteTimestamp;
+ if (!strcmp(name, "CmdCopyQueryPoolResults")) return (void *)table->CmdCopyQueryPoolResults;
+ if (!strcmp(name, "CmdPushConstants")) return (void *)table->CmdPushConstants;
+ if (!strcmp(name, "CmdBeginRenderPass")) return (void *)table->CmdBeginRenderPass;
+ if (!strcmp(name, "CmdNextSubpass")) return (void *)table->CmdNextSubpass;
+ if (!strcmp(name, "CmdEndRenderPass")) return (void *)table->CmdEndRenderPass;
+ if (!strcmp(name, "CmdExecuteCommands")) return (void *)table->CmdExecuteCommands;
+
+ // ---- VK_KHR_swapchain extension commands
+ if (!strcmp(name, "CreateSwapchainKHR")) return (void *)table->CreateSwapchainKHR;
+ if (!strcmp(name, "DestroySwapchainKHR")) return (void *)table->DestroySwapchainKHR;
+ if (!strcmp(name, "GetSwapchainImagesKHR")) return (void *)table->GetSwapchainImagesKHR;
+ if (!strcmp(name, "AcquireNextImageKHR")) return (void *)table->AcquireNextImageKHR;
+ if (!strcmp(name, "QueuePresentKHR")) return (void *)table->QueuePresentKHR;
+
+ // ---- VK_KHR_display_swapchain extension commands
+ if (!strcmp(name, "CreateSharedSwapchainsKHR")) return (void *)table->CreateSharedSwapchainsKHR;
+
+ // ---- VK_KHR_maintenance1 extension commands
+ if (!strcmp(name, "TrimCommandPoolKHR")) return (void *)table->TrimCommandPoolKHR;
+
+ // ---- VK_KHR_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetMemoryWin32HandleKHR")) return (void *)table->GetMemoryWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetMemoryWin32HandlePropertiesKHR")) return (void *)table->GetMemoryWin32HandlePropertiesKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_memory_fd extension commands
+ if (!strcmp(name, "GetMemoryFdKHR")) return (void *)table->GetMemoryFdKHR;
+ if (!strcmp(name, "GetMemoryFdPropertiesKHR")) return (void *)table->GetMemoryFdPropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "ImportSemaphoreWin32HandleKHR")) return (void *)table->ImportSemaphoreWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetSemaphoreWin32HandleKHR")) return (void *)table->GetSemaphoreWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_semaphore_fd extension commands
+ if (!strcmp(name, "ImportSemaphoreFdKHR")) return (void *)table->ImportSemaphoreFdKHR;
+ if (!strcmp(name, "GetSemaphoreFdKHR")) return (void *)table->GetSemaphoreFdKHR;
+
+ // ---- VK_KHR_push_descriptor extension commands
+ if (!strcmp(name, "CmdPushDescriptorSetKHR")) return (void *)table->CmdPushDescriptorSetKHR;
+
+ // ---- VK_KHR_descriptor_update_template extension commands
+ if (!strcmp(name, "CreateDescriptorUpdateTemplateKHR")) return (void *)table->CreateDescriptorUpdateTemplateKHR;
+ if (!strcmp(name, "DestroyDescriptorUpdateTemplateKHR")) return (void *)table->DestroyDescriptorUpdateTemplateKHR;
+ if (!strcmp(name, "UpdateDescriptorSetWithTemplateKHR")) return (void *)table->UpdateDescriptorSetWithTemplateKHR;
+ if (!strcmp(name, "CmdPushDescriptorSetWithTemplateKHR")) return (void *)table->CmdPushDescriptorSetWithTemplateKHR;
+
+ // ---- VK_KHR_shared_presentable_image extension commands
+ if (!strcmp(name, "GetSwapchainStatusKHR")) return (void *)table->GetSwapchainStatusKHR;
+
+ // ---- VK_KHR_external_fence_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "ImportFenceWin32HandleKHR")) return (void *)table->ImportFenceWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetFenceWin32HandleKHR")) return (void *)table->GetFenceWin32HandleKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_fence_fd extension commands
+ if (!strcmp(name, "ImportFenceFdKHR")) return (void *)table->ImportFenceFdKHR;
+ if (!strcmp(name, "GetFenceFdKHR")) return (void *)table->GetFenceFdKHR;
+
+ // ---- VK_KHR_get_memory_requirements2 extension commands
+ if (!strcmp(name, "GetImageMemoryRequirements2KHR")) return (void *)table->GetImageMemoryRequirements2KHR;
+ if (!strcmp(name, "GetBufferMemoryRequirements2KHR")) return (void *)table->GetBufferMemoryRequirements2KHR;
+ if (!strcmp(name, "GetImageSparseMemoryRequirements2KHR")) return (void *)table->GetImageSparseMemoryRequirements2KHR;
+
+ // ---- VK_KHR_external_memory_fuchsia extension commands
+ if (!strcmp(name, "GetMemoryFuchsiaHandleKHR")) return (void *)table->GetMemoryFuchsiaHandleKHR;
+ if (!strcmp(name, "GetMemoryFuchsiaHandlePropertiesKHR")) return (void *)table->GetMemoryFuchsiaHandlePropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_fuchsia extension commands
+ if (!strcmp(name, "ImportSemaphoreFuchsiaHandleKHR")) return (void *)table->ImportSemaphoreFuchsiaHandleKHR;
+ if (!strcmp(name, "GetSemaphoreFuchsiaHandleKHR")) return (void *)table->GetSemaphoreFuchsiaHandleKHR;
+
+ // ---- VK_EXT_debug_marker extension commands
+ if (!strcmp(name, "DebugMarkerSetObjectTagEXT")) return (void *)table->DebugMarkerSetObjectTagEXT;
+ if (!strcmp(name, "DebugMarkerSetObjectNameEXT")) return (void *)table->DebugMarkerSetObjectNameEXT;
+ if (!strcmp(name, "CmdDebugMarkerBeginEXT")) return (void *)table->CmdDebugMarkerBeginEXT;
+ if (!strcmp(name, "CmdDebugMarkerEndEXT")) return (void *)table->CmdDebugMarkerEndEXT;
+ if (!strcmp(name, "CmdDebugMarkerInsertEXT")) return (void *)table->CmdDebugMarkerInsertEXT;
+
+ // ---- VK_AMD_draw_indirect_count extension commands
+ if (!strcmp(name, "CmdDrawIndirectCountAMD")) return (void *)table->CmdDrawIndirectCountAMD;
+ if (!strcmp(name, "CmdDrawIndexedIndirectCountAMD")) return (void *)table->CmdDrawIndexedIndirectCountAMD;
+
+ // ---- VK_NV_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetMemoryWin32HandleNV")) return (void *)table->GetMemoryWin32HandleNV;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHX_device_group extension commands
+ if (!strcmp(name, "GetDeviceGroupPeerMemoryFeaturesKHX")) return (void *)table->GetDeviceGroupPeerMemoryFeaturesKHX;
+ if (!strcmp(name, "BindBufferMemory2KHX")) return (void *)table->BindBufferMemory2KHX;
+ if (!strcmp(name, "BindImageMemory2KHX")) return (void *)table->BindImageMemory2KHX;
+ if (!strcmp(name, "CmdSetDeviceMaskKHX")) return (void *)table->CmdSetDeviceMaskKHX;
+ if (!strcmp(name, "GetDeviceGroupPresentCapabilitiesKHX")) return (void *)table->GetDeviceGroupPresentCapabilitiesKHX;
+ if (!strcmp(name, "GetDeviceGroupSurfacePresentModesKHX")) return (void *)table->GetDeviceGroupSurfacePresentModesKHX;
+ if (!strcmp(name, "AcquireNextImage2KHX")) return (void *)table->AcquireNextImage2KHX;
+ if (!strcmp(name, "CmdDispatchBaseKHX")) return (void *)table->CmdDispatchBaseKHX;
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ if (!strcmp(name, "CmdProcessCommandsNVX")) return (void *)table->CmdProcessCommandsNVX;
+ if (!strcmp(name, "CmdReserveSpaceForCommandsNVX")) return (void *)table->CmdReserveSpaceForCommandsNVX;
+ if (!strcmp(name, "CreateIndirectCommandsLayoutNVX")) return (void *)table->CreateIndirectCommandsLayoutNVX;
+ if (!strcmp(name, "DestroyIndirectCommandsLayoutNVX")) return (void *)table->DestroyIndirectCommandsLayoutNVX;
+ if (!strcmp(name, "CreateObjectTableNVX")) return (void *)table->CreateObjectTableNVX;
+ if (!strcmp(name, "DestroyObjectTableNVX")) return (void *)table->DestroyObjectTableNVX;
+ if (!strcmp(name, "RegisterObjectsNVX")) return (void *)table->RegisterObjectsNVX;
+ if (!strcmp(name, "UnregisterObjectsNVX")) return (void *)table->UnregisterObjectsNVX;
+
+ // ---- VK_NV_clip_space_w_scaling extension commands
+ if (!strcmp(name, "CmdSetViewportWScalingNV")) return (void *)table->CmdSetViewportWScalingNV;
+
+ // ---- VK_EXT_display_control extension commands
+ if (!strcmp(name, "DisplayPowerControlEXT")) return (void *)table->DisplayPowerControlEXT;
+ if (!strcmp(name, "RegisterDeviceEventEXT")) return (void *)table->RegisterDeviceEventEXT;
+ if (!strcmp(name, "RegisterDisplayEventEXT")) return (void *)table->RegisterDisplayEventEXT;
+ if (!strcmp(name, "GetSwapchainCounterEXT")) return (void *)table->GetSwapchainCounterEXT;
+
+ // ---- VK_GOOGLE_display_timing extension commands
+ if (!strcmp(name, "GetRefreshCycleDurationGOOGLE")) return (void *)table->GetRefreshCycleDurationGOOGLE;
+ if (!strcmp(name, "GetPastPresentationTimingGOOGLE")) return (void *)table->GetPastPresentationTimingGOOGLE;
+
+ // ---- VK_EXT_discard_rectangles extension commands
+ if (!strcmp(name, "CmdSetDiscardRectangleEXT")) return (void *)table->CmdSetDiscardRectangleEXT;
+
+ // ---- VK_EXT_hdr_metadata extension commands
+ if (!strcmp(name, "SetHdrMetadataEXT")) return (void *)table->SetHdrMetadataEXT;
+
+ // ---- VK_GOOGLE_external_memory_magma extension commands
+ if (!strcmp(name, "ExportDeviceMemoryMAGMA")) return (void *)table->ExportDeviceMemoryMAGMA;
+ if (!strcmp(name, "ImportDeviceMemoryMAGMA")) return (void *)table->ImportDeviceMemoryMAGMA;
+
+ return NULL;
+}
+
+// Instance command lookup function
+VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
+ bool *found_name) {
+ if (!name || name[0] != 'v' || name[1] != 'k') {
+ *found_name = false;
+ return NULL;
+ }
+
+ *found_name = true;
+ name += 2;
+
+ // ---- Core 1_0 commands
+ if (!strcmp(name, "DestroyInstance")) return (void *)table->DestroyInstance;
+ if (!strcmp(name, "EnumeratePhysicalDevices")) return (void *)table->EnumeratePhysicalDevices;
+ if (!strcmp(name, "GetPhysicalDeviceFeatures")) return (void *)table->GetPhysicalDeviceFeatures;
+ if (!strcmp(name, "GetPhysicalDeviceFormatProperties")) return (void *)table->GetPhysicalDeviceFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties")) return (void *)table->GetPhysicalDeviceImageFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceProperties")) return (void *)table->GetPhysicalDeviceProperties;
+ if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties")) return (void *)table->GetPhysicalDeviceQueueFamilyProperties;
+ if (!strcmp(name, "GetPhysicalDeviceMemoryProperties")) return (void *)table->GetPhysicalDeviceMemoryProperties;
+ if (!strcmp(name, "GetInstanceProcAddr")) return (void *)table->GetInstanceProcAddr;
+ if (!strcmp(name, "EnumerateDeviceExtensionProperties")) return (void *)table->EnumerateDeviceExtensionProperties;
+ if (!strcmp(name, "EnumerateDeviceLayerProperties")) return (void *)table->EnumerateDeviceLayerProperties;
+ if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties")) return (void *)table->GetPhysicalDeviceSparseImageFormatProperties;
+
+ // ---- VK_KHR_surface extension commands
+ if (!strcmp(name, "DestroySurfaceKHR")) return (void *)table->DestroySurfaceKHR;
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceSupportKHR")) return (void *)table->GetPhysicalDeviceSurfaceSupportKHR;
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilitiesKHR")) return (void *)table->GetPhysicalDeviceSurfaceCapabilitiesKHR;
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceFormatsKHR")) return (void *)table->GetPhysicalDeviceSurfaceFormatsKHR;
+ if (!strcmp(name, "GetPhysicalDeviceSurfacePresentModesKHR")) return (void *)table->GetPhysicalDeviceSurfacePresentModesKHR;
+
+ // ---- VK_KHR_display extension commands
+ if (!strcmp(name, "GetPhysicalDeviceDisplayPropertiesKHR")) return (void *)table->GetPhysicalDeviceDisplayPropertiesKHR;
+ if (!strcmp(name, "GetPhysicalDeviceDisplayPlanePropertiesKHR")) return (void *)table->GetPhysicalDeviceDisplayPlanePropertiesKHR;
+ if (!strcmp(name, "GetDisplayPlaneSupportedDisplaysKHR")) return (void *)table->GetDisplayPlaneSupportedDisplaysKHR;
+ if (!strcmp(name, "GetDisplayModePropertiesKHR")) return (void *)table->GetDisplayModePropertiesKHR;
+ if (!strcmp(name, "CreateDisplayModeKHR")) return (void *)table->CreateDisplayModeKHR;
+ if (!strcmp(name, "GetDisplayPlaneCapabilitiesKHR")) return (void *)table->GetDisplayPlaneCapabilitiesKHR;
+ if (!strcmp(name, "CreateDisplayPlaneSurfaceKHR")) return (void *)table->CreateDisplayPlaneSurfaceKHR;
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ if (!strcmp(name, "CreateXlibSurfaceKHR")) return (void *)table->CreateXlibSurfaceKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ if (!strcmp(name, "GetPhysicalDeviceXlibPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceXlibPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ if (!strcmp(name, "CreateXcbSurfaceKHR")) return (void *)table->CreateXcbSurfaceKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ if (!strcmp(name, "GetPhysicalDeviceXcbPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceXcbPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ if (!strcmp(name, "CreateWaylandSurfaceKHR")) return (void *)table->CreateWaylandSurfaceKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ if (!strcmp(name, "GetPhysicalDeviceWaylandPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ if (!strcmp(name, "CreateMirSurfaceKHR")) return (void *)table->CreateMirSurfaceKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ if (!strcmp(name, "GetPhysicalDeviceMirPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceMirPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ if (!strcmp(name, "CreateAndroidSurfaceKHR")) return (void *)table->CreateAndroidSurfaceKHR;
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "CreateWin32SurfaceKHR")) return (void *)table->CreateWin32SurfaceKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp(name, "GetPhysicalDeviceWin32PresentationSupportKHR")) return (void *)table->GetPhysicalDeviceWin32PresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ if (!strcmp(name, "CreateMagmaSurfaceKHR")) return (void *)table->CreateMagmaSurfaceKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ if (!strcmp(name, "GetPhysicalDeviceMagmaPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceMagmaPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ if (!strcmp(name, "GetPhysicalDeviceFeatures2KHR")) return (void *)table->GetPhysicalDeviceFeatures2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceProperties2KHR")) return (void *)table->GetPhysicalDeviceProperties2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceFormatProperties2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceImageFormatProperties2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties2KHR")) return (void *)table->GetPhysicalDeviceQueueFamilyProperties2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceMemoryProperties2KHR")) return (void *)table->GetPhysicalDeviceMemoryProperties2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceSparseImageFormatProperties2KHR;
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ if (!strcmp(name, "GetPhysicalDeviceExternalBufferPropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalBufferPropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ if (!strcmp(name, "GetPhysicalDeviceExternalSemaphorePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalSemaphorePropertiesKHR;
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ if (!strcmp(name, "GetPhysicalDeviceExternalFencePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalFencePropertiesKHR;
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2KHR")) return (void *)table->GetPhysicalDeviceSurfaceCapabilities2KHR;
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceFormats2KHR")) return (void *)table->GetPhysicalDeviceSurfaceFormats2KHR;
+
+ // ---- VK_EXT_debug_report extension commands
+ if (!strcmp(name, "CreateDebugReportCallbackEXT")) return (void *)table->CreateDebugReportCallbackEXT;
+ if (!strcmp(name, "DestroyDebugReportCallbackEXT")) return (void *)table->DestroyDebugReportCallbackEXT;
+ if (!strcmp(name, "DebugReportMessageEXT")) return (void *)table->DebugReportMessageEXT;
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ if (!strcmp(name, "GetPhysicalDeviceExternalImageFormatPropertiesNV")) return (void *)table->GetPhysicalDeviceExternalImageFormatPropertiesNV;
+
+ // ---- VK_KHX_device_group extension commands
+ if (!strcmp(name, "GetPhysicalDevicePresentRectanglesKHX")) return (void *)table->GetPhysicalDevicePresentRectanglesKHX;
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ if (!strcmp(name, "CreateViSurfaceNN")) return (void *)table->CreateViSurfaceNN;
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ if (!strcmp(name, "EnumeratePhysicalDeviceGroupsKHX")) return (void *)table->EnumeratePhysicalDeviceGroupsKHX;
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX")) return (void *)table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ if (!strcmp(name, "ReleaseDisplayEXT")) return (void *)table->ReleaseDisplayEXT;
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ if (!strcmp(name, "AcquireXlibDisplayEXT")) return (void *)table->AcquireXlibDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ if (!strcmp(name, "GetRandROutputDisplayEXT")) return (void *)table->GetRandROutputDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2EXT")) return (void *)table->GetPhysicalDeviceSurfaceCapabilities2EXT;
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ if (!strcmp(name, "CreateIOSSurfaceMVK")) return (void *)table->CreateIOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ if (!strcmp(name, "CreateMacOSSurfaceMVK")) return (void *)table->CreateMacOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+ *found_name = false;
+ return NULL;
+}
+
+
+// ---- VK_KHR_maintenance1 extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->TrimCommandPoolKHR(device, commandPool, flags);
+}
+
+
+// ---- VK_KHR_external_memory_win32 extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+// ---- VK_KHR_external_memory_fd extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryFdKHR(device, pGetFdInfo, pFd);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
+}
+
+
+// ---- VK_KHR_external_semaphore_win32 extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+// ---- VK_KHR_external_semaphore_fd extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetSemaphoreFdKHR(device, pGetFdInfo, pFd);
+}
+
+
+// ---- VK_KHR_push_descriptor extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+}
+
+
+// ---- VK_KHR_descriptor_update_template extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
+}
+
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ const void* pData) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+}
+
+
+// ---- VK_KHR_shared_presentable_image extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetSwapchainStatusKHR(device, swapchain);
+}
+
+
+// ---- VK_KHR_external_fence_win32 extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+// ---- VK_KHR_external_fence_fd extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportFenceFdKHR(device, pImportFenceFdInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetFenceFdKHR(device, pGetFdInfo, pFd);
+}
+
+
+// ---- VK_KHR_get_memory_requirements2 extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+
+VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+
+// ---- VK_KHR_external_memory_fuchsia extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandleKHR(
+ VkDevice device,
+ const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryFuchsiaHandleKHR(device, pGetFuchsiaHandleInfo, pFuchsiaHandle);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFuchsiaHandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ uint32_t fuchsiaHandle,
+ VkMemoryFuchsiaHandlePropertiesKHR* pMemoryFuchsiaHandleProperties) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryFuchsiaHandlePropertiesKHR(device, handleType, fuchsiaHandle, pMemoryFuchsiaHandleProperties);
+}
+
+
+// ---- VK_KHR_external_semaphore_fuchsia extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportSemaphoreFuchsiaHandleKHR(device, pImportSemaphoreFuchsiaHandleInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFuchsiaHandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo,
+ uint32_t* pFuchsiaHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetSemaphoreFuchsiaHandleKHR(device, pGetFuchsiaHandleInfo, pFuchsiaHandle);
+}
+
+
+// ---- VK_EXT_debug_marker extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ VkDebugMarkerObjectTagInfoEXT local_tag_info;
+ memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT));
+ // If this is a physical device, we have to replace it with the proper one for the next call.
+ if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+ struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object;
+ local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
+ }
+ return disp->DebugMarkerSetObjectTagEXT(device, &local_tag_info);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
+ uint32_t icd_index = 0;
+ struct loader_device *dev;
+ struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
+ if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectTagEXT) {
+ VkDebugMarkerObjectTagInfoEXT local_tag_info;
+ memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT));
+ // If this is a physical device, we have to replace it with the proper one for the next call.
+ if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+ struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pTagInfo->object;
+ local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
+ // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call.
+ } else if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
+ if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {
+ VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pTagInfo->object;
+ if (NULL != icd_surface->real_icd_surfaces) {
+ local_tag_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];
+ }
+ }
+ }
+ return icd_term->dispatch.DebugMarkerSetObjectTagEXT(device, &local_tag_info);
+ } else {
+ return VK_SUCCESS;
+ }
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ VkDebugMarkerObjectNameInfoEXT local_name_info;
+ memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT));
+ // If this is a physical device, we have to replace it with the proper one for the next call.
+ if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+ struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object;
+ local_name_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
+ }
+ return disp->DebugMarkerSetObjectNameEXT(device, &local_name_info);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
+ uint32_t icd_index = 0;
+ struct loader_device *dev;
+ struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
+ if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectNameEXT) {
+ VkDebugMarkerObjectNameInfoEXT local_name_info;
+ memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT));
+ // If this is a physical device, we have to replace it with the proper one for the next call.
+ if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+ struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pNameInfo->object;
+ local_name_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
+ // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call.
+ } else if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
+ if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {
+ VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pNameInfo->object;
+ if (NULL != icd_surface->real_icd_surfaces) {
+ local_name_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];
+ }
+ }
+ }
+ return icd_term->dispatch.DebugMarkerSetObjectNameEXT(device, &local_name_info);
+ } else {
+ return VK_SUCCESS;
+ }
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDebugMarkerEndEXT(commandBuffer);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+}
+
+
+// ---- VK_AMD_draw_indirect_count extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+
+
+// ---- VK_NV_external_memory_win32 extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+}
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+// ---- VK_KHX_device_group extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfoKHX* pBindInfos) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->BindBufferMemory2KHX(device, bindInfoCount, pBindInfos);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfoKHX* pBindInfos) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->BindImageMemory2KHX(device, bindInfoCount, pBindInfos);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdSetDeviceMaskKHX(commandBuffer, deviceMask);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHX(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDeviceGroupSurfacePresentModesKHX(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHX* pModes) {
+ uint32_t icd_index = 0;
+ struct loader_device *dev;
+ struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
+ if (NULL != icd_term && NULL != icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX) {
+ VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
+ if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
+ return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX(device, icd_surface->real_icd_surfaces[icd_index], pModes);
+ }
+ return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
+ }
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHX* pAcquireInfo,
+ uint32_t* pImageIndex) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects) {
+ const VkLayerInstanceDispatchTable *disp;
+ VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
+ disp = loader_get_instance_layer_dispatch(physicalDevice);
+ return disp->GetPhysicalDevicePresentRectanglesKHX(unwrapped_phys_dev, surface, pRectCount, pRects);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDevicePresentRectanglesKHX(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects) {
+ struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+ if (NULL == icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX) {
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ "ICD associated with VkPhysicalDevice does not support GetPhysicalDevicePresentRectanglesKHX");
+ }
+ VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
+ uint8_t icd_index = phys_dev_term->icd_index;
+ if (NULL != icd_surface->real_icd_surfaces && NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) {
+ return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX(phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pRectCount, pRects);
+ }
+ return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX(phys_dev_term->phys_dev, surface, pRectCount, pRects);
+}
+
+
+// ---- VK_NN_vi_surface extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_VI_NN
+VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+ return disp->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+}
+
+#endif // VK_USE_PLATFORM_VI_NN
+
+// ---- VK_NVX_device_generated_commands extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->DestroyObjectTableNVX(device, objectTable, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+}
+
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits) {
+ const VkLayerInstanceDispatchTable *disp;
+ VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
+ disp = loader_get_instance_layer_dispatch(physicalDevice);
+ disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev, pFeatures, pLimits);
+}
+
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits) {
+ struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+ if (NULL == icd_term->dispatch.GetPhysicalDeviceGeneratedCommandsPropertiesNVX) {
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+ }
+ icd_term->dispatch.GetPhysicalDeviceGeneratedCommandsPropertiesNVX(phys_dev_term->phys_dev, pFeatures, pLimits);
+}
+
+
+// ---- VK_NV_clip_space_w_scaling extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+}
+
+
+// ---- VK_EXT_display_control extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+}
+
+
+// ---- VK_GOOGLE_display_timing extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+}
+
+
+// ---- VK_EXT_discard_rectangles extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+ disp->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+}
+
+
+// ---- VK_EXT_hdr_metadata extension trampoline/terminators
+
+VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ disp->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+}
+
+
+// ---- VK_MVK_ios_surface extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+ return disp->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+}
+
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+// ---- VK_MVK_macos_surface extension trampoline/terminators
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+ return disp->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+#error("Not implemented. Likely needs to be manually generated!");
+}
+
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+// ---- VK_GOOGLE_external_memory_magma extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL ExportDeviceMemoryMAGMA(
+ VkDevice device,
+ VkDeviceMemory memory,
+ uint32_t* pHandle) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ExportDeviceMemoryMAGMA(device, memory, pHandle);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ImportDeviceMemoryMAGMA(
+ VkDevice device,
+ uint32_t handle,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory) {
+ const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+ return disp->ImportDeviceMemoryMAGMA(device, handle, pAllocator, pMemory);
+}
+
+// GPA helpers for extensions
+bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
+ *addr = NULL;
+
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ if (!strcmp("vkGetPhysicalDeviceFeatures2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceFeatures2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceProperties2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceFormatProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceFormatProperties2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceImageFormatProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceImageFormatProperties2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceQueueFamilyProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceQueueFamilyProperties2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceMemoryProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceMemoryProperties2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
+ ? (void *)GetPhysicalDeviceSparseImageFormatProperties2KHR
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_KHR_maintenance1 extension commands
+ if (!strcmp("vkTrimCommandPoolKHR", name)) {
+ *addr = (void *)TrimCommandPoolKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ if (!strcmp("vkGetPhysicalDeviceExternalBufferPropertiesKHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_external_memory_capabilities == 1)
+ ? (void *)GetPhysicalDeviceExternalBufferPropertiesKHR
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_KHR_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkGetMemoryWin32HandleKHR", name)) {
+ *addr = (void *)GetMemoryWin32HandleKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkGetMemoryWin32HandlePropertiesKHR", name)) {
+ *addr = (void *)GetMemoryWin32HandlePropertiesKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_memory_fd extension commands
+ if (!strcmp("vkGetMemoryFdKHR", name)) {
+ *addr = (void *)GetMemoryFdKHR;
+ return true;
+ }
+ if (!strcmp("vkGetMemoryFdPropertiesKHR", name)) {
+ *addr = (void *)GetMemoryFdPropertiesKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ if (!strcmp("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities == 1)
+ ? (void *)GetPhysicalDeviceExternalSemaphorePropertiesKHR
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_KHR_external_semaphore_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkImportSemaphoreWin32HandleKHR", name)) {
+ *addr = (void *)ImportSemaphoreWin32HandleKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkGetSemaphoreWin32HandleKHR", name)) {
+ *addr = (void *)GetSemaphoreWin32HandleKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_semaphore_fd extension commands
+ if (!strcmp("vkImportSemaphoreFdKHR", name)) {
+ *addr = (void *)ImportSemaphoreFdKHR;
+ return true;
+ }
+ if (!strcmp("vkGetSemaphoreFdKHR", name)) {
+ *addr = (void *)GetSemaphoreFdKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_push_descriptor extension commands
+ if (!strcmp("vkCmdPushDescriptorSetKHR", name)) {
+ *addr = (void *)CmdPushDescriptorSetKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_descriptor_update_template extension commands
+ if (!strcmp("vkCreateDescriptorUpdateTemplateKHR", name)) {
+ *addr = (void *)CreateDescriptorUpdateTemplateKHR;
+ return true;
+ }
+ if (!strcmp("vkDestroyDescriptorUpdateTemplateKHR", name)) {
+ *addr = (void *)DestroyDescriptorUpdateTemplateKHR;
+ return true;
+ }
+ if (!strcmp("vkUpdateDescriptorSetWithTemplateKHR", name)) {
+ *addr = (void *)UpdateDescriptorSetWithTemplateKHR;
+ return true;
+ }
+ if (!strcmp("vkCmdPushDescriptorSetWithTemplateKHR", name)) {
+ *addr = (void *)CmdPushDescriptorSetWithTemplateKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_shared_presentable_image extension commands
+ if (!strcmp("vkGetSwapchainStatusKHR", name)) {
+ *addr = (void *)GetSwapchainStatusKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ if (!strcmp("vkGetPhysicalDeviceExternalFencePropertiesKHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_external_fence_capabilities == 1)
+ ? (void *)GetPhysicalDeviceExternalFencePropertiesKHR
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_KHR_external_fence_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkImportFenceWin32HandleKHR", name)) {
+ *addr = (void *)ImportFenceWin32HandleKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkGetFenceWin32HandleKHR", name)) {
+ *addr = (void *)GetFenceWin32HandleKHR;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_external_fence_fd extension commands
+ if (!strcmp("vkImportFenceFdKHR", name)) {
+ *addr = (void *)ImportFenceFdKHR;
+ return true;
+ }
+ if (!strcmp("vkGetFenceFdKHR", name)) {
+ *addr = (void *)GetFenceFdKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1)
+ ? (void *)GetPhysicalDeviceSurfaceCapabilities2KHR
+ : NULL;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceSurfaceFormats2KHR", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1)
+ ? (void *)GetPhysicalDeviceSurfaceFormats2KHR
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_KHR_get_memory_requirements2 extension commands
+ if (!strcmp("vkGetImageMemoryRequirements2KHR", name)) {
+ *addr = (void *)GetImageMemoryRequirements2KHR;
+ return true;
+ }
+ if (!strcmp("vkGetBufferMemoryRequirements2KHR", name)) {
+ *addr = (void *)GetBufferMemoryRequirements2KHR;
+ return true;
+ }
+ if (!strcmp("vkGetImageSparseMemoryRequirements2KHR", name)) {
+ *addr = (void *)GetImageSparseMemoryRequirements2KHR;
+ return true;
+ }
+
+ // ---- VK_KHR_external_memory_fuchsia extension commands
+ if (!strcmp("vkGetMemoryFuchsiaHandleKHR", name)) {
+ *addr = (void *)GetMemoryFuchsiaHandleKHR;
+ return true;
+ }
+ if (!strcmp("vkGetMemoryFuchsiaHandlePropertiesKHR", name)) {
+ *addr = (void *)GetMemoryFuchsiaHandlePropertiesKHR;
+ return true;
+ }
+
+ // ---- VK_KHR_external_semaphore_fuchsia extension commands
+ if (!strcmp("vkImportSemaphoreFuchsiaHandleKHR", name)) {
+ *addr = (void *)ImportSemaphoreFuchsiaHandleKHR;
+ return true;
+ }
+ if (!strcmp("vkGetSemaphoreFuchsiaHandleKHR", name)) {
+ *addr = (void *)GetSemaphoreFuchsiaHandleKHR;
+ return true;
+ }
+
+ // ---- VK_EXT_debug_marker extension commands
+ if (!strcmp("vkDebugMarkerSetObjectTagEXT", name)) {
+ *addr = (void *)DebugMarkerSetObjectTagEXT;
+ return true;
+ }
+ if (!strcmp("vkDebugMarkerSetObjectNameEXT", name)) {
+ *addr = (void *)DebugMarkerSetObjectNameEXT;
+ return true;
+ }
+ if (!strcmp("vkCmdDebugMarkerBeginEXT", name)) {
+ *addr = (void *)CmdDebugMarkerBeginEXT;
+ return true;
+ }
+ if (!strcmp("vkCmdDebugMarkerEndEXT", name)) {
+ *addr = (void *)CmdDebugMarkerEndEXT;
+ return true;
+ }
+ if (!strcmp("vkCmdDebugMarkerInsertEXT", name)) {
+ *addr = (void *)CmdDebugMarkerInsertEXT;
+ return true;
+ }
+
+ // ---- VK_AMD_draw_indirect_count extension commands
+ if (!strcmp("vkCmdDrawIndirectCountAMD", name)) {
+ *addr = (void *)CmdDrawIndirectCountAMD;
+ return true;
+ }
+ if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) {
+ *addr = (void *)CmdDrawIndexedIndirectCountAMD;
+ return true;
+ }
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.nv_external_memory_capabilities == 1)
+ ? (void *)GetPhysicalDeviceExternalImageFormatPropertiesNV
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_NV_external_memory_win32 extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkGetMemoryWin32HandleNV", name)) {
+ *addr = (void *)GetMemoryWin32HandleNV;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHX_device_group extension commands
+ if (!strcmp("vkGetDeviceGroupPeerMemoryFeaturesKHX", name)) {
+ *addr = (void *)GetDeviceGroupPeerMemoryFeaturesKHX;
+ return true;
+ }
+ if (!strcmp("vkBindBufferMemory2KHX", name)) {
+ *addr = (void *)BindBufferMemory2KHX;
+ return true;
+ }
+ if (!strcmp("vkBindImageMemory2KHX", name)) {
+ *addr = (void *)BindImageMemory2KHX;
+ return true;
+ }
+ if (!strcmp("vkCmdSetDeviceMaskKHX", name)) {
+ *addr = (void *)CmdSetDeviceMaskKHX;
+ return true;
+ }
+ if (!strcmp("vkGetDeviceGroupPresentCapabilitiesKHX", name)) {
+ *addr = (void *)GetDeviceGroupPresentCapabilitiesKHX;
+ return true;
+ }
+ if (!strcmp("vkGetDeviceGroupSurfacePresentModesKHX", name)) {
+ *addr = (void *)GetDeviceGroupSurfacePresentModesKHX;
+ return true;
+ }
+ if (!strcmp("vkAcquireNextImage2KHX", name)) {
+ *addr = (void *)AcquireNextImage2KHX;
+ return true;
+ }
+ if (!strcmp("vkCmdDispatchBaseKHX", name)) {
+ *addr = (void *)CmdDispatchBaseKHX;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDevicePresentRectanglesKHX", name)) {
+ *addr = (void *)GetPhysicalDevicePresentRectanglesKHX;
+ return true;
+ }
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ if (!strcmp("vkCreateViSurfaceNN", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.nn_vi_surface == 1)
+ ? (void *)CreateViSurfaceNN
+ : NULL;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ if (!strcmp("vkEnumeratePhysicalDeviceGroupsKHX", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.khx_device_group_creation == 1)
+ ? (void *)EnumeratePhysicalDeviceGroupsKHX
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ if (!strcmp("vkCmdProcessCommandsNVX", name)) {
+ *addr = (void *)CmdProcessCommandsNVX;
+ return true;
+ }
+ if (!strcmp("vkCmdReserveSpaceForCommandsNVX", name)) {
+ *addr = (void *)CmdReserveSpaceForCommandsNVX;
+ return true;
+ }
+ if (!strcmp("vkCreateIndirectCommandsLayoutNVX", name)) {
+ *addr = (void *)CreateIndirectCommandsLayoutNVX;
+ return true;
+ }
+ if (!strcmp("vkDestroyIndirectCommandsLayoutNVX", name)) {
+ *addr = (void *)DestroyIndirectCommandsLayoutNVX;
+ return true;
+ }
+ if (!strcmp("vkCreateObjectTableNVX", name)) {
+ *addr = (void *)CreateObjectTableNVX;
+ return true;
+ }
+ if (!strcmp("vkDestroyObjectTableNVX", name)) {
+ *addr = (void *)DestroyObjectTableNVX;
+ return true;
+ }
+ if (!strcmp("vkRegisterObjectsNVX", name)) {
+ *addr = (void *)RegisterObjectsNVX;
+ return true;
+ }
+ if (!strcmp("vkUnregisterObjectsNVX", name)) {
+ *addr = (void *)UnregisterObjectsNVX;
+ return true;
+ }
+ if (!strcmp("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", name)) {
+ *addr = (void *)GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+ return true;
+ }
+
+ // ---- VK_NV_clip_space_w_scaling extension commands
+ if (!strcmp("vkCmdSetViewportWScalingNV", name)) {
+ *addr = (void *)CmdSetViewportWScalingNV;
+ return true;
+ }
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ if (!strcmp("vkReleaseDisplayEXT", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.ext_direct_mode_display == 1)
+ ? (void *)ReleaseDisplayEXT
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ if (!strcmp("vkAcquireXlibDisplayEXT", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1)
+ ? (void *)AcquireXlibDisplayEXT
+ : NULL;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ if (!strcmp("vkGetRandROutputDisplayEXT", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1)
+ ? (void *)GetRandROutputDisplayEXT
+ : NULL;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2EXT", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.ext_display_surface_counter == 1)
+ ? (void *)GetPhysicalDeviceSurfaceCapabilities2EXT
+ : NULL;
+ return true;
+ }
+
+ // ---- VK_EXT_display_control extension commands
+ if (!strcmp("vkDisplayPowerControlEXT", name)) {
+ *addr = (void *)DisplayPowerControlEXT;
+ return true;
+ }
+ if (!strcmp("vkRegisterDeviceEventEXT", name)) {
+ *addr = (void *)RegisterDeviceEventEXT;
+ return true;
+ }
+ if (!strcmp("vkRegisterDisplayEventEXT", name)) {
+ *addr = (void *)RegisterDisplayEventEXT;
+ return true;
+ }
+ if (!strcmp("vkGetSwapchainCounterEXT", name)) {
+ *addr = (void *)GetSwapchainCounterEXT;
+ return true;
+ }
+
+ // ---- VK_GOOGLE_display_timing extension commands
+ if (!strcmp("vkGetRefreshCycleDurationGOOGLE", name)) {
+ *addr = (void *)GetRefreshCycleDurationGOOGLE;
+ return true;
+ }
+ if (!strcmp("vkGetPastPresentationTimingGOOGLE", name)) {
+ *addr = (void *)GetPastPresentationTimingGOOGLE;
+ return true;
+ }
+
+ // ---- VK_EXT_discard_rectangles extension commands
+ if (!strcmp("vkCmdSetDiscardRectangleEXT", name)) {
+ *addr = (void *)CmdSetDiscardRectangleEXT;
+ return true;
+ }
+
+ // ---- VK_EXT_hdr_metadata extension commands
+ if (!strcmp("vkSetHdrMetadataEXT", name)) {
+ *addr = (void *)SetHdrMetadataEXT;
+ return true;
+ }
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ if (!strcmp("vkCreateIOSSurfaceMVK", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.mvk_ios_surface == 1)
+ ? (void *)CreateIOSSurfaceMVK
+ : NULL;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ if (!strcmp("vkCreateMacOSSurfaceMVK", name)) {
+ *addr = (ptr_instance->enabled_known_extensions.mvk_macos_surface == 1)
+ ? (void *)CreateMacOSSurfaceMVK
+ : NULL;
+ return true;
+ }
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+ // ---- VK_GOOGLE_external_memory_magma extension commands
+ if (!strcmp("vkExportDeviceMemoryMAGMA", name)) {
+ *addr = (void *)ExportDeviceMemoryMAGMA;
+ return true;
+ }
+ if (!strcmp("vkImportDeviceMemoryMAGMA", name)) {
+ *addr = (void *)ImportDeviceMemoryMAGMA;
+ return true;
+ }
+ return false;
+}
+
+// A function that can be used to query enabled extensions during a vkCreateInstance call
+void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 = 1;
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khr_external_memory_capabilities = 1;
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities = 1;
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khr_external_fence_capabilities = 1;
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 = 1;
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 1;
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NN_VI_SURFACE_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.nn_vi_surface = 1;
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.khx_device_group_creation = 1;
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.ext_direct_mode_display = 1;
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.ext_acquire_xlib_display = 1;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.ext_display_surface_counter = 1;
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_IOS_SURFACE_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.mvk_ios_surface = 1;
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_MACOS_SURFACE_EXTENSION_NAME)) {
+ ptr_instance->enabled_known_extensions.mvk_macos_surface = 1;
+#endif // VK_USE_PLATFORM_MACOS_MVK
+ }
+ }
+}
+
+// Some device commands still need a terminator because the loader needs to unwrap something about them.
+// In many cases, the item needing unwrapping is a VkPhysicalDevice or VkSurfaceKHR object. But there may be other items
+// in the future.
+PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName) {
+ PFN_vkVoidFunction addr = NULL;
+
+ // ---- VK_KHR_swapchain extension commands
+ if(!strcmp(pName, "vkCreateSwapchainKHR")) {
+ addr = (PFN_vkVoidFunction)terminator_CreateSwapchainKHR;
+
+ // ---- VK_KHR_display_swapchain extension commands
+ } else if(!strcmp(pName, "vkCreateSharedSwapchainsKHR")) {
+ addr = (PFN_vkVoidFunction)terminator_CreateSharedSwapchainsKHR;
+
+ // ---- VK_EXT_debug_marker extension commands
+ } else if(!strcmp(pName, "vkDebugMarkerSetObjectTagEXT")) {
+ addr = (PFN_vkVoidFunction)terminator_DebugMarkerSetObjectTagEXT;
+ } else if(!strcmp(pName, "vkDebugMarkerSetObjectNameEXT")) {
+ addr = (PFN_vkVoidFunction)terminator_DebugMarkerSetObjectNameEXT;
+
+ // ---- VK_KHX_device_group extension commands
+ } else if(!strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHX")) {
+ addr = (PFN_vkVoidFunction)terminator_GetDeviceGroupSurfacePresentModesKHX;
+ }
+ return addr;
+}
+
+// This table contains the loader's instance dispatch table, which contains
+// default functions if no instance layers are activated. This contains
+// pointers to "terminator functions".
+const VkLayerInstanceDispatchTable instance_disp = {
+
+ // ---- Core 1_0 commands
+ .DestroyInstance = terminator_DestroyInstance,
+ .EnumeratePhysicalDevices = terminator_EnumeratePhysicalDevices,
+ .GetPhysicalDeviceFeatures = terminator_GetPhysicalDeviceFeatures,
+ .GetPhysicalDeviceFormatProperties = terminator_GetPhysicalDeviceFormatProperties,
+ .GetPhysicalDeviceImageFormatProperties = terminator_GetPhysicalDeviceImageFormatProperties,
+ .GetPhysicalDeviceProperties = terminator_GetPhysicalDeviceProperties,
+ .GetPhysicalDeviceQueueFamilyProperties = terminator_GetPhysicalDeviceQueueFamilyProperties,
+ .GetPhysicalDeviceMemoryProperties = terminator_GetPhysicalDeviceMemoryProperties,
+ .GetInstanceProcAddr = vkGetInstanceProcAddr,
+ .EnumerateDeviceExtensionProperties = terminator_EnumerateDeviceExtensionProperties,
+ .EnumerateDeviceLayerProperties = terminator_EnumerateDeviceLayerProperties,
+ .GetPhysicalDeviceSparseImageFormatProperties = terminator_GetPhysicalDeviceSparseImageFormatProperties,
+
+ // ---- VK_KHR_surface extension commands
+ .DestroySurfaceKHR = terminator_DestroySurfaceKHR,
+ .GetPhysicalDeviceSurfaceSupportKHR = terminator_GetPhysicalDeviceSurfaceSupportKHR,
+ .GetPhysicalDeviceSurfaceCapabilitiesKHR = terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR,
+ .GetPhysicalDeviceSurfaceFormatsKHR = terminator_GetPhysicalDeviceSurfaceFormatsKHR,
+ .GetPhysicalDeviceSurfacePresentModesKHR = terminator_GetPhysicalDeviceSurfacePresentModesKHR,
+
+ // ---- VK_KHR_display extension commands
+ .GetPhysicalDeviceDisplayPropertiesKHR = terminator_GetPhysicalDeviceDisplayPropertiesKHR,
+ .GetPhysicalDeviceDisplayPlanePropertiesKHR = terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR,
+ .GetDisplayPlaneSupportedDisplaysKHR = terminator_GetDisplayPlaneSupportedDisplaysKHR,
+ .GetDisplayModePropertiesKHR = terminator_GetDisplayModePropertiesKHR,
+ .CreateDisplayModeKHR = terminator_CreateDisplayModeKHR,
+ .GetDisplayPlaneCapabilitiesKHR = terminator_GetDisplayPlaneCapabilitiesKHR,
+ .CreateDisplayPlaneSurfaceKHR = terminator_CreateDisplayPlaneSurfaceKHR,
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ .CreateXlibSurfaceKHR = terminator_CreateXlibSurfaceKHR,
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ .GetPhysicalDeviceXlibPresentationSupportKHR = terminator_GetPhysicalDeviceXlibPresentationSupportKHR,
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ .CreateXcbSurfaceKHR = terminator_CreateXcbSurfaceKHR,
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ .GetPhysicalDeviceXcbPresentationSupportKHR = terminator_GetPhysicalDeviceXcbPresentationSupportKHR,
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ .CreateWaylandSurfaceKHR = terminator_CreateWaylandSurfaceKHR,
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ .GetPhysicalDeviceWaylandPresentationSupportKHR = terminator_GetPhysicalDeviceWaylandPresentationSupportKHR,
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ .CreateMirSurfaceKHR = terminator_CreateMirSurfaceKHR,
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ .GetPhysicalDeviceMirPresentationSupportKHR = terminator_GetPhysicalDeviceMirPresentationSupportKHR,
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ .CreateAndroidSurfaceKHR = terminator_CreateAndroidSurfaceKHR,
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ .CreateWin32SurfaceKHR = terminator_CreateWin32SurfaceKHR,
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ .GetPhysicalDeviceWin32PresentationSupportKHR = terminator_GetPhysicalDeviceWin32PresentationSupportKHR,
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ .CreateMagmaSurfaceKHR = terminator_CreateMagmaSurfaceKHR,
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ .GetPhysicalDeviceMagmaPresentationSupportKHR = terminator_GetPhysicalDeviceMagmaPresentationSupportKHR,
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ .GetPhysicalDeviceFeatures2KHR = terminator_GetPhysicalDeviceFeatures2KHR,
+ .GetPhysicalDeviceProperties2KHR = terminator_GetPhysicalDeviceProperties2KHR,
+ .GetPhysicalDeviceFormatProperties2KHR = terminator_GetPhysicalDeviceFormatProperties2KHR,
+ .GetPhysicalDeviceImageFormatProperties2KHR = terminator_GetPhysicalDeviceImageFormatProperties2KHR,
+ .GetPhysicalDeviceQueueFamilyProperties2KHR = terminator_GetPhysicalDeviceQueueFamilyProperties2KHR,
+ .GetPhysicalDeviceMemoryProperties2KHR = terminator_GetPhysicalDeviceMemoryProperties2KHR,
+ .GetPhysicalDeviceSparseImageFormatProperties2KHR = terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR,
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ .GetPhysicalDeviceExternalBufferPropertiesKHR = terminator_GetPhysicalDeviceExternalBufferPropertiesKHR,
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ .GetPhysicalDeviceExternalSemaphorePropertiesKHR = terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR,
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ .GetPhysicalDeviceExternalFencePropertiesKHR = terminator_GetPhysicalDeviceExternalFencePropertiesKHR,
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ .GetPhysicalDeviceSurfaceCapabilities2KHR = terminator_GetPhysicalDeviceSurfaceCapabilities2KHR,
+ .GetPhysicalDeviceSurfaceFormats2KHR = terminator_GetPhysicalDeviceSurfaceFormats2KHR,
+
+ // ---- VK_EXT_debug_report extension commands
+ .CreateDebugReportCallbackEXT = terminator_CreateDebugReportCallbackEXT,
+ .DestroyDebugReportCallbackEXT = terminator_DestroyDebugReportCallbackEXT,
+ .DebugReportMessageEXT = terminator_DebugReportMessageEXT,
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ .GetPhysicalDeviceExternalImageFormatPropertiesNV = terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV,
+
+ // ---- VK_KHX_device_group extension commands
+ .GetPhysicalDevicePresentRectanglesKHX = terminator_GetPhysicalDevicePresentRectanglesKHX,
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ .CreateViSurfaceNN = terminator_CreateViSurfaceNN,
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ .EnumeratePhysicalDeviceGroupsKHX = terminator_EnumeratePhysicalDeviceGroupsKHX,
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ .GetPhysicalDeviceGeneratedCommandsPropertiesNVX = terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX,
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ .ReleaseDisplayEXT = terminator_ReleaseDisplayEXT,
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ .AcquireXlibDisplayEXT = terminator_AcquireXlibDisplayEXT,
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ .GetRandROutputDisplayEXT = terminator_GetRandROutputDisplayEXT,
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ .GetPhysicalDeviceSurfaceCapabilities2EXT = terminator_GetPhysicalDeviceSurfaceCapabilities2EXT,
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ .CreateIOSSurfaceMVK = terminator_CreateIOSSurfaceMVK,
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ .CreateMacOSSurfaceMVK = terminator_CreateMacOSSurfaceMVK,
+#endif // VK_USE_PLATFORM_MACOS_MVK
+};
+
+// A null-terminated list of all of the instance extensions supported by the loader.
+// If an instance extension name is not in this list, but it is exported by one or more of the
+// ICDs detected by the loader, then the extension name not in the list will be filtered out
+// before passing the list of extensions to the application.
+const char *const LOADER_INSTANCE_EXTENSIONS[] = {
+ VK_KHR_SURFACE_EXTENSION_NAME,
+ VK_KHR_DISPLAY_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ VK_KHR_XCB_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ VK_KHR_MIR_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ VK_KHR_MAGMA_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
+ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME,
+ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME,
+ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,
+ VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+ VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
+ VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_VI_NN
+ VK_NN_VI_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_VI_NN
+ VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME,
+ VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
+ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ VK_MVK_IOS_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ VK_MVK_MACOS_SURFACE_EXTENSION_NAME,
+#endif // VK_USE_PLATFORM_MACOS_MVK
+ VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME,
+ VK_GOOGLE_IMAGE_TILING_SCANOUT_EXTENSION_NAME,
+ NULL };
+
diff --git a/build-fuchsia/generated/include/vk_loader_extensions.h b/build-fuchsia/generated/include/vk_loader_extensions.h
new file mode 100644
index 0000000..2081ba8
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_loader_extensions.h
@@ -0,0 +1,345 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See loader_extension_generator.py for modifications
+
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 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: Mark Young <marky@lunarg.com>
+ */
+
+#pragma once
+
+// Structures defined externally, but used here
+struct loader_instance;
+struct loader_icd_term;
+struct loader_dev_dispatch_table;
+
+// Device extension error function
+VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev);
+
+// Extension interception for vkGetInstanceProcAddr function, so we can return
+// the appropriate information for any instance extensions we know about.
+bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
+
+// Extension interception for vkCreateInstance function, so we can properly
+// detect and enable any instance extension information for extensions we know
+// about.
+void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
+
+// Extension interception for vkGetDeviceProcAddr function, so we can return
+// an appropriate terminator if this is one of those few device commands requiring
+// a terminator.
+PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName);
+
+// Dispatch table properly filled in with appropriate terminators for the
+// supported extensions.
+extern const VkLayerInstanceDispatchTable instance_disp;
+
+// Array of extension strings for instance extensions we support.
+extern const char *const LOADER_INSTANCE_EXTENSIONS[];
+
+VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
+ const PFN_vkGetInstanceProcAddr fp_gipa);
+
+// Init Device function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
+ VkDevice dev);
+
+// Init Device function pointer dispatch table with extension commands
+VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,
+ PFN_vkGetDeviceProcAddr gpa, VkDevice dev);
+
+// Init Instance function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+ VkInstance inst);
+
+// Init Instance function pointer dispatch table with core commands
+VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+ VkInstance inst);
+
+// Device command lookup function
+VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name);
+
+// Instance command lookup function
+VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
+ bool *found_name);
+
+VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
+ const PFN_vkGetInstanceProcAddr fp_gipa);
+
+// Loader core instance terminators
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL terminator_GetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+
+// ICD function pointer dispatch table
+struct loader_icd_term_dispatch {
+
+ // ---- Core 1_0 commands
+ PFN_vkCreateInstance CreateInstance;
+ PFN_vkDestroyInstance DestroyInstance;
+ PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+ PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+ PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+ PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+ PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+ PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+ PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+ PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+ PFN_vkCreateDevice CreateDevice;
+ PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
+ PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+ PFN_vkEnumerateInstanceLayerProperties EnumerateInstanceLayerProperties;
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+
+ // ---- VK_KHR_surface extension commands
+ PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+
+ // ---- VK_KHR_swapchain extension commands
+ PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+
+ // ---- VK_KHR_display extension commands
+ PFN_vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR;
+ PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR;
+ PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR;
+ PFN_vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR;
+ PFN_vkCreateDisplayModeKHR CreateDisplayModeKHR;
+ PFN_vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR;
+ PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
+
+ // ---- VK_KHR_display_swapchain extension commands
+ PFN_vkCreateSharedSwapchainsKHR CreateSharedSwapchainsKHR;
+
+ // ---- VK_KHR_xlib_surface extension commands
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ PFN_vkCreateXlibSurfaceKHR CreateXlibSurfaceKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR GetPhysicalDeviceXlibPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+ // ---- VK_KHR_xcb_surface extension commands
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ PFN_vkCreateXcbSurfaceKHR CreateXcbSurfaceKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+ // ---- VK_KHR_wayland_surface extension commands
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ PFN_vkCreateWaylandSurfaceKHR CreateWaylandSurfaceKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+ // ---- VK_KHR_mir_surface extension commands
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+ // ---- VK_KHR_android_surface extension commands
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+ // ---- VK_KHR_win32_surface extension commands
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkCreateWin32SurfaceKHR CreateWin32SurfaceKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ // ---- VK_KHR_magma_surface extension commands
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ PFN_vkCreateMagmaSurfaceKHR CreateMagmaSurfaceKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ PFN_vkGetPhysicalDeviceMagmaPresentationSupportKHR GetPhysicalDeviceMagmaPresentationSupportKHR;
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+ // ---- VK_KHR_get_physical_device_properties2 extension commands
+ PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR;
+ PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR;
+ PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR;
+ PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR;
+ PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR;
+ PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR;
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR;
+
+ // ---- VK_KHR_external_memory_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR;
+
+ // ---- VK_KHR_external_semaphore_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR;
+
+ // ---- VK_KHR_external_fence_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR;
+
+ // ---- VK_KHR_get_surface_capabilities2 extension commands
+ PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR;
+
+ // ---- VK_EXT_debug_report extension commands
+ PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
+ PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
+ PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
+
+ // ---- VK_EXT_debug_marker extension commands
+ PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT;
+ PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT;
+
+ // ---- VK_NV_external_memory_capabilities extension commands
+ PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV GetPhysicalDeviceExternalImageFormatPropertiesNV;
+
+ // ---- VK_KHX_device_group extension commands
+ PFN_vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX;
+ PFN_vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX;
+
+ // ---- VK_NN_vi_surface extension commands
+#ifdef VK_USE_PLATFORM_VI_NN
+ PFN_vkCreateViSurfaceNN CreateViSurfaceNN;
+#endif // VK_USE_PLATFORM_VI_NN
+
+ // ---- VK_KHX_device_group_creation extension commands
+ PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX;
+
+ // ---- VK_NVX_device_generated_commands extension commands
+ PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+
+ // ---- VK_EXT_direct_mode_display extension commands
+ PFN_vkReleaseDisplayEXT ReleaseDisplayEXT;
+
+ // ---- VK_EXT_acquire_xlib_display extension commands
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ PFN_vkAcquireXlibDisplayEXT AcquireXlibDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ PFN_vkGetRandROutputDisplayEXT GetRandROutputDisplayEXT;
+#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+ // ---- VK_EXT_display_surface_counter extension commands
+ PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT GetPhysicalDeviceSurfaceCapabilities2EXT;
+
+ // ---- VK_MVK_ios_surface extension commands
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ PFN_vkCreateIOSSurfaceMVK CreateIOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+ // ---- VK_MVK_macos_surface extension commands
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurfaceMVK;
+#endif // VK_USE_PLATFORM_MACOS_MVK
+};
+
+union loader_instance_extension_enables {
+ struct {
+ uint8_t khr_get_physical_device_properties2 : 1;
+ uint8_t khr_external_memory_capabilities : 1;
+ uint8_t khr_external_semaphore_capabilities : 1;
+ uint8_t khr_external_fence_capabilities : 1;
+ uint8_t khr_get_surface_capabilities2 : 1;
+ uint8_t ext_debug_report : 1;
+ uint8_t nv_external_memory_capabilities : 1;
+ uint8_t nn_vi_surface : 1;
+ uint8_t khx_device_group_creation : 1;
+ uint8_t ext_direct_mode_display : 1;
+ uint8_t ext_acquire_xlib_display : 1;
+ uint8_t ext_display_surface_counter : 1;
+ uint8_t mvk_ios_surface : 1;
+ uint8_t mvk_macos_surface : 1;
+ };
+ uint64_t padding[4];
+};
+
+
diff --git a/build-fuchsia/generated/include/vk_object_types.h b/build-fuchsia/generated/include/vk_object_types.h
new file mode 100644
index 0000000..b8af8c5
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_object_types.h
@@ -0,0 +1,185 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+// Object Type enum for validation layer internal object handling
+typedef enum VulkanObjectType {
+ kVulkanObjectTypeUnknown = 0,
+ kVulkanObjectTypeInstance = 1,
+ kVulkanObjectTypePhysicalDevice = 2,
+ kVulkanObjectTypeDevice = 3,
+ kVulkanObjectTypeQueue = 4,
+ kVulkanObjectTypeSemaphore = 5,
+ kVulkanObjectTypeCommandBuffer = 6,
+ kVulkanObjectTypeFence = 7,
+ kVulkanObjectTypeDeviceMemory = 8,
+ kVulkanObjectTypeBuffer = 9,
+ kVulkanObjectTypeImage = 10,
+ kVulkanObjectTypeEvent = 11,
+ kVulkanObjectTypeQueryPool = 12,
+ kVulkanObjectTypeBufferView = 13,
+ kVulkanObjectTypeImageView = 14,
+ kVulkanObjectTypeShaderModule = 15,
+ kVulkanObjectTypePipelineCache = 16,
+ kVulkanObjectTypePipelineLayout = 17,
+ kVulkanObjectTypeRenderPass = 18,
+ kVulkanObjectTypePipeline = 19,
+ kVulkanObjectTypeDescriptorSetLayout = 20,
+ kVulkanObjectTypeSampler = 21,
+ kVulkanObjectTypeDescriptorPool = 22,
+ kVulkanObjectTypeDescriptorSet = 23,
+ kVulkanObjectTypeFramebuffer = 24,
+ kVulkanObjectTypeCommandPool = 25,
+ kVulkanObjectTypeSurfaceKHR = 26,
+ kVulkanObjectTypeSwapchainKHR = 27,
+ kVulkanObjectTypeDisplayKHR = 28,
+ kVulkanObjectTypeDisplayModeKHR = 29,
+ kVulkanObjectTypeDescriptorUpdateTemplateKHR = 30,
+ kVulkanObjectTypeDebugReportCallbackEXT = 31,
+ kVulkanObjectTypeObjectTableNVX = 32,
+ kVulkanObjectTypeIndirectCommandsLayoutNVX = 33,
+ kVulkanObjectTypeMax = 34,
+} VulkanObjectType;
+
+// Array of object name strings for OBJECT_TYPE enum conversion
+static const char * const object_string[kVulkanObjectTypeMax] = {
+ "Unknown",
+ "Instance",
+ "PhysicalDevice",
+ "Device",
+ "Queue",
+ "Semaphore",
+ "CommandBuffer",
+ "Fence",
+ "DeviceMemory",
+ "Buffer",
+ "Image",
+ "Event",
+ "QueryPool",
+ "BufferView",
+ "ImageView",
+ "ShaderModule",
+ "PipelineCache",
+ "PipelineLayout",
+ "RenderPass",
+ "Pipeline",
+ "DescriptorSetLayout",
+ "Sampler",
+ "DescriptorPool",
+ "DescriptorSet",
+ "Framebuffer",
+ "CommandPool",
+ "SurfaceKHR",
+ "SwapchainKHR",
+ "DisplayKHR",
+ "DisplayModeKHR",
+ "DescriptorUpdateTemplateKHR",
+ "DebugReportCallbackEXT",
+ "ObjectTableNVX",
+ "IndirectCommandsLayoutNVX",
+};
+
+// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version
+const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {
+ VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, // kVulkanObjectTypeInstance
+ VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, // kVulkanObjectTypePhysicalDevice
+ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, // kVulkanObjectTypeDevice
+ VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, // kVulkanObjectTypeQueue
+ VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, // kVulkanObjectTypeSemaphore
+ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, // kVulkanObjectTypeCommandBuffer
+ VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, // kVulkanObjectTypeFence
+ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, // kVulkanObjectTypeDeviceMemory
+ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, // kVulkanObjectTypeBuffer
+ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, // kVulkanObjectTypeImage
+ VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, // kVulkanObjectTypeEvent
+ VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, // kVulkanObjectTypeQueryPool
+ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, // kVulkanObjectTypeBufferView
+ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, // kVulkanObjectTypeImageView
+ VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, // kVulkanObjectTypeShaderModule
+ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, // kVulkanObjectTypePipelineCache
+ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, // kVulkanObjectTypePipelineLayout
+ VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, // kVulkanObjectTypeRenderPass
+ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, // kVulkanObjectTypePipeline
+ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, // kVulkanObjectTypeDescriptorSetLayout
+ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, // kVulkanObjectTypeSampler
+ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, // kVulkanObjectTypeDescriptorPool
+ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, // kVulkanObjectTypeDescriptorSet
+ VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, // kVulkanObjectTypeFramebuffer
+ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, // kVulkanObjectTypeCommandPool
+ VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, // kVulkanObjectTypeSurfaceKHR
+ VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, // kVulkanObjectTypeSwapchainKHR
+ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, // kVulkanObjectTypeDisplayKHR
+ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, // kVulkanObjectTypeDisplayModeKHR
+ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, // kVulkanObjectTypeDescriptorUpdateTemplateKHR
+ VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, // kVulkanObjectTypeDebugReportCallbackEXT
+ VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, // kVulkanObjectTypeObjectTableNVX
+ VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, // kVulkanObjectTypeIndirectCommandsLayoutNVX
+};
+
+// Helper array to get Official Vulkan VkObjectType enum from the internal layers version
+const VkObjectType get_object_type_enum[] = {
+ VK_OBJECT_TYPE_INSTANCE, // kVulkanObjectTypeInstance
+ VK_OBJECT_TYPE_PHYSICAL_DEVICE, // kVulkanObjectTypePhysicalDevice
+ VK_OBJECT_TYPE_DEVICE, // kVulkanObjectTypeDevice
+ VK_OBJECT_TYPE_QUEUE, // kVulkanObjectTypeQueue
+ VK_OBJECT_TYPE_SEMAPHORE, // kVulkanObjectTypeSemaphore
+ VK_OBJECT_TYPE_COMMAND_BUFFER, // kVulkanObjectTypeCommandBuffer
+ VK_OBJECT_TYPE_FENCE, // kVulkanObjectTypeFence
+ VK_OBJECT_TYPE_DEVICE_MEMORY, // kVulkanObjectTypeDeviceMemory
+ VK_OBJECT_TYPE_BUFFER, // kVulkanObjectTypeBuffer
+ VK_OBJECT_TYPE_IMAGE, // kVulkanObjectTypeImage
+ VK_OBJECT_TYPE_EVENT, // kVulkanObjectTypeEvent
+ VK_OBJECT_TYPE_QUERY_POOL, // kVulkanObjectTypeQueryPool
+ VK_OBJECT_TYPE_BUFFER_VIEW, // kVulkanObjectTypeBufferView
+ VK_OBJECT_TYPE_IMAGE_VIEW, // kVulkanObjectTypeImageView
+ VK_OBJECT_TYPE_SHADER_MODULE, // kVulkanObjectTypeShaderModule
+ VK_OBJECT_TYPE_PIPELINE_CACHE, // kVulkanObjectTypePipelineCache
+ VK_OBJECT_TYPE_PIPELINE_LAYOUT, // kVulkanObjectTypePipelineLayout
+ VK_OBJECT_TYPE_RENDER_PASS, // kVulkanObjectTypeRenderPass
+ VK_OBJECT_TYPE_PIPELINE, // kVulkanObjectTypePipeline
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, // kVulkanObjectTypeDescriptorSetLayout
+ VK_OBJECT_TYPE_SAMPLER, // kVulkanObjectTypeSampler
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL, // kVulkanObjectTypeDescriptorPool
+ VK_OBJECT_TYPE_DESCRIPTOR_SET, // kVulkanObjectTypeDescriptorSet
+ VK_OBJECT_TYPE_FRAMEBUFFER, // kVulkanObjectTypeFramebuffer
+ VK_OBJECT_TYPE_COMMAND_POOL, // kVulkanObjectTypeCommandPool
+ VK_OBJECT_TYPE_SURFACE_KHR, // kVulkanObjectTypeSurfaceKHR
+ VK_OBJECT_TYPE_SWAPCHAIN_KHR, // kVulkanObjectTypeSwapchainKHR
+ VK_OBJECT_TYPE_DISPLAY_KHR, // kVulkanObjectTypeDisplayKHR
+ VK_OBJECT_TYPE_DISPLAY_MODE_KHR, // kVulkanObjectTypeDisplayModeKHR
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, // kVulkanObjectTypeDescriptorUpdateTemplateKHR
+ VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, // kVulkanObjectTypeDebugReportCallbackEXT
+ VK_OBJECT_TYPE_OBJECT_TABLE_NVX, // kVulkanObjectTypeObjectTableNVX
+ VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, // kVulkanObjectTypeIndirectCommandsLayoutNVX
+};
diff --git a/build-fuchsia/generated/include/vk_safe_struct.cpp b/build-fuchsia/generated/include/vk_safe_struct.cpp
new file mode 100644
index 0000000..1a7741b
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_safe_struct.cpp
@@ -0,0 +1,10739 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#include "vk_safe_struct.h"
+#include <string.h>
+
+
+safe_VkApplicationInfo::safe_VkApplicationInfo(const VkApplicationInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pApplicationName(in_struct->pApplicationName),
+ applicationVersion(in_struct->applicationVersion),
+ pEngineName(in_struct->pEngineName),
+ engineVersion(in_struct->engineVersion),
+ apiVersion(in_struct->apiVersion)
+{
+}
+
+safe_VkApplicationInfo::safe_VkApplicationInfo()
+{}
+
+safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pApplicationName = src.pApplicationName;
+ applicationVersion = src.applicationVersion;
+ pEngineName = src.pEngineName;
+ engineVersion = src.engineVersion;
+ apiVersion = src.apiVersion;
+}
+
+safe_VkApplicationInfo::~safe_VkApplicationInfo()
+{
+}
+
+void safe_VkApplicationInfo::initialize(const VkApplicationInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pApplicationName = in_struct->pApplicationName;
+ applicationVersion = in_struct->applicationVersion;
+ pEngineName = in_struct->pEngineName;
+ engineVersion = in_struct->engineVersion;
+ apiVersion = in_struct->apiVersion;
+}
+
+void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pApplicationName = src->pApplicationName;
+ applicationVersion = src->applicationVersion;
+ pEngineName = src->pEngineName;
+ engineVersion = src->engineVersion;
+ apiVersion = src->apiVersion;
+}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ enabledLayerCount(in_struct->enabledLayerCount),
+ ppEnabledLayerNames(in_struct->ppEnabledLayerNames),
+ enabledExtensionCount(in_struct->enabledExtensionCount),
+ ppEnabledExtensionNames(in_struct->ppEnabledExtensionNames)
+{
+ if (in_struct->pApplicationInfo)
+ pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
+ else
+ pApplicationInfo = NULL;
+}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo()
+{}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ enabledLayerCount = src.enabledLayerCount;
+ ppEnabledLayerNames = src.ppEnabledLayerNames;
+ enabledExtensionCount = src.enabledExtensionCount;
+ ppEnabledExtensionNames = src.ppEnabledExtensionNames;
+ if (src.pApplicationInfo)
+ pApplicationInfo = new safe_VkApplicationInfo(*src.pApplicationInfo);
+ else
+ pApplicationInfo = NULL;
+}
+
+safe_VkInstanceCreateInfo::~safe_VkInstanceCreateInfo()
+{
+ if (pApplicationInfo)
+ delete pApplicationInfo;
+}
+
+void safe_VkInstanceCreateInfo::initialize(const VkInstanceCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ enabledLayerCount = in_struct->enabledLayerCount;
+ ppEnabledLayerNames = in_struct->ppEnabledLayerNames;
+ enabledExtensionCount = in_struct->enabledExtensionCount;
+ ppEnabledExtensionNames = in_struct->ppEnabledExtensionNames;
+ if (in_struct->pApplicationInfo)
+ pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
+ else
+ pApplicationInfo = NULL;
+}
+
+void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ enabledLayerCount = src->enabledLayerCount;
+ ppEnabledLayerNames = src->ppEnabledLayerNames;
+ enabledExtensionCount = src->enabledExtensionCount;
+ ppEnabledExtensionNames = src->ppEnabledExtensionNames;
+ if (src->pApplicationInfo)
+ pApplicationInfo = new safe_VkApplicationInfo(*src->pApplicationInfo);
+ else
+ pApplicationInfo = NULL;
+}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct) :
+ pUserData(in_struct->pUserData),
+ pfnAllocation(in_struct->pfnAllocation),
+ pfnReallocation(in_struct->pfnReallocation),
+ pfnFree(in_struct->pfnFree),
+ pfnInternalAllocation(in_struct->pfnInternalAllocation),
+ pfnInternalFree(in_struct->pfnInternalFree)
+{
+}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks()
+{}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src)
+{
+ pUserData = src.pUserData;
+ pfnAllocation = src.pfnAllocation;
+ pfnReallocation = src.pfnReallocation;
+ pfnFree = src.pfnFree;
+ pfnInternalAllocation = src.pfnInternalAllocation;
+ pfnInternalFree = src.pfnInternalFree;
+}
+
+safe_VkAllocationCallbacks::~safe_VkAllocationCallbacks()
+{
+}
+
+void safe_VkAllocationCallbacks::initialize(const VkAllocationCallbacks* in_struct)
+{
+ pUserData = in_struct->pUserData;
+ pfnAllocation = in_struct->pfnAllocation;
+ pfnReallocation = in_struct->pfnReallocation;
+ pfnFree = in_struct->pfnFree;
+ pfnInternalAllocation = in_struct->pfnInternalAllocation;
+ pfnInternalFree = in_struct->pfnInternalFree;
+}
+
+void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* src)
+{
+ pUserData = src->pUserData;
+ pfnAllocation = src->pfnAllocation;
+ pfnReallocation = src->pfnReallocation;
+ pfnFree = src->pfnFree;
+ pfnInternalAllocation = src->pfnInternalAllocation;
+ pfnInternalFree = src->pfnInternalFree;
+}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ queueFamilyIndex(in_struct->queueFamilyIndex),
+ queueCount(in_struct->queueCount),
+ pQueuePriorities(nullptr)
+{
+ if (in_struct->pQueuePriorities) {
+ pQueuePriorities = new float[in_struct->queueCount];
+ memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
+ }
+}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo() :
+ pQueuePriorities(nullptr)
+{}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ queueFamilyIndex = src.queueFamilyIndex;
+ queueCount = src.queueCount;
+ pQueuePriorities = nullptr;
+ if (src.pQueuePriorities) {
+ pQueuePriorities = new float[src.queueCount];
+ memcpy ((void *)pQueuePriorities, (void *)src.pQueuePriorities, sizeof(float)*src.queueCount);
+ }
+}
+
+safe_VkDeviceQueueCreateInfo::~safe_VkDeviceQueueCreateInfo()
+{
+ if (pQueuePriorities)
+ delete[] pQueuePriorities;
+}
+
+void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ queueFamilyIndex = in_struct->queueFamilyIndex;
+ queueCount = in_struct->queueCount;
+ pQueuePriorities = nullptr;
+ if (in_struct->pQueuePriorities) {
+ pQueuePriorities = new float[in_struct->queueCount];
+ memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
+ }
+}
+
+void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ queueFamilyIndex = src->queueFamilyIndex;
+ queueCount = src->queueCount;
+ pQueuePriorities = nullptr;
+ if (src->pQueuePriorities) {
+ pQueuePriorities = new float[src->queueCount];
+ memcpy ((void *)pQueuePriorities, (void *)src->pQueuePriorities, sizeof(float)*src->queueCount);
+ }
+}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ queueCreateInfoCount(in_struct->queueCreateInfoCount),
+ pQueueCreateInfos(nullptr),
+ enabledLayerCount(in_struct->enabledLayerCount),
+ ppEnabledLayerNames(in_struct->ppEnabledLayerNames),
+ enabledExtensionCount(in_struct->enabledExtensionCount),
+ ppEnabledExtensionNames(in_struct->ppEnabledExtensionNames),
+ pEnabledFeatures(nullptr)
+{
+ if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
+ pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+ for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+ pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
+ }
+ }
+ if (in_struct->pEnabledFeatures) {
+ pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
+ }
+}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo() :
+ pQueueCreateInfos(nullptr),
+ pEnabledFeatures(nullptr)
+{}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ queueCreateInfoCount = src.queueCreateInfoCount;
+ pQueueCreateInfos = nullptr;
+ enabledLayerCount = src.enabledLayerCount;
+ ppEnabledLayerNames = src.ppEnabledLayerNames;
+ enabledExtensionCount = src.enabledExtensionCount;
+ ppEnabledExtensionNames = src.ppEnabledExtensionNames;
+ pEnabledFeatures = nullptr;
+ if (queueCreateInfoCount && src.pQueueCreateInfos) {
+ pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+ for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+ pQueueCreateInfos[i].initialize(&src.pQueueCreateInfos[i]);
+ }
+ }
+ if (src.pEnabledFeatures) {
+ pEnabledFeatures = new VkPhysicalDeviceFeatures(*src.pEnabledFeatures);
+ }
+}
+
+safe_VkDeviceCreateInfo::~safe_VkDeviceCreateInfo()
+{
+ if (pQueueCreateInfos)
+ delete[] pQueueCreateInfos;
+ if (pEnabledFeatures)
+ delete pEnabledFeatures;
+}
+
+void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ queueCreateInfoCount = in_struct->queueCreateInfoCount;
+ pQueueCreateInfos = nullptr;
+ enabledLayerCount = in_struct->enabledLayerCount;
+ ppEnabledLayerNames = in_struct->ppEnabledLayerNames;
+ enabledExtensionCount = in_struct->enabledExtensionCount;
+ ppEnabledExtensionNames = in_struct->ppEnabledExtensionNames;
+ pEnabledFeatures = nullptr;
+ if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
+ pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+ for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+ pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
+ }
+ }
+ if (in_struct->pEnabledFeatures) {
+ pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
+ }
+}
+
+void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ queueCreateInfoCount = src->queueCreateInfoCount;
+ pQueueCreateInfos = nullptr;
+ enabledLayerCount = src->enabledLayerCount;
+ ppEnabledLayerNames = src->ppEnabledLayerNames;
+ enabledExtensionCount = src->enabledExtensionCount;
+ ppEnabledExtensionNames = src->ppEnabledExtensionNames;
+ pEnabledFeatures = nullptr;
+ if (queueCreateInfoCount && src->pQueueCreateInfos) {
+ pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+ for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+ pQueueCreateInfos[i].initialize(&src->pQueueCreateInfos[i]);
+ }
+ }
+ if (src->pEnabledFeatures) {
+ pEnabledFeatures = new VkPhysicalDeviceFeatures(*src->pEnabledFeatures);
+ }
+}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ waitSemaphoreCount(in_struct->waitSemaphoreCount),
+ pWaitSemaphores(nullptr),
+ pWaitDstStageMask(nullptr),
+ commandBufferCount(in_struct->commandBufferCount),
+ pCommandBuffers(nullptr),
+ signalSemaphoreCount(in_struct->signalSemaphoreCount),
+ pSignalSemaphores(nullptr)
+{
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (in_struct->pWaitDstStageMask) {
+ pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
+ memcpy ((void *)pWaitDstStageMask, (void *)in_struct->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*in_struct->waitSemaphoreCount);
+ }
+ if (in_struct->pCommandBuffers) {
+ pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
+ memcpy ((void *)pCommandBuffers, (void *)in_struct->pCommandBuffers, sizeof(VkCommandBuffer)*in_struct->commandBufferCount);
+ }
+ if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo() :
+ pWaitSemaphores(nullptr),
+ pWaitDstStageMask(nullptr),
+ pCommandBuffers(nullptr),
+ pSignalSemaphores(nullptr)
+{}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ waitSemaphoreCount = src.waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ pWaitDstStageMask = nullptr;
+ commandBufferCount = src.commandBufferCount;
+ pCommandBuffers = nullptr;
+ signalSemaphoreCount = src.signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && src.pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src.pWaitSemaphores[i];
+ }
+ }
+ if (src.pWaitDstStageMask) {
+ pWaitDstStageMask = new VkPipelineStageFlags[src.waitSemaphoreCount];
+ memcpy ((void *)pWaitDstStageMask, (void *)src.pWaitDstStageMask, sizeof(VkPipelineStageFlags)*src.waitSemaphoreCount);
+ }
+ if (src.pCommandBuffers) {
+ pCommandBuffers = new VkCommandBuffer[src.commandBufferCount];
+ memcpy ((void *)pCommandBuffers, (void *)src.pCommandBuffers, sizeof(VkCommandBuffer)*src.commandBufferCount);
+ }
+ if (signalSemaphoreCount && src.pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = src.pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkSubmitInfo::~safe_VkSubmitInfo()
+{
+ if (pWaitSemaphores)
+ delete[] pWaitSemaphores;
+ if (pWaitDstStageMask)
+ delete[] pWaitDstStageMask;
+ if (pCommandBuffers)
+ delete[] pCommandBuffers;
+ if (pSignalSemaphores)
+ delete[] pSignalSemaphores;
+}
+
+void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ waitSemaphoreCount = in_struct->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ pWaitDstStageMask = nullptr;
+ commandBufferCount = in_struct->commandBufferCount;
+ pCommandBuffers = nullptr;
+ signalSemaphoreCount = in_struct->signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (in_struct->pWaitDstStageMask) {
+ pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
+ memcpy ((void *)pWaitDstStageMask, (void *)in_struct->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*in_struct->waitSemaphoreCount);
+ }
+ if (in_struct->pCommandBuffers) {
+ pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
+ memcpy ((void *)pCommandBuffers, (void *)in_struct->pCommandBuffers, sizeof(VkCommandBuffer)*in_struct->commandBufferCount);
+ }
+ if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+ }
+ }
+}
+
+void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ waitSemaphoreCount = src->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ pWaitDstStageMask = nullptr;
+ commandBufferCount = src->commandBufferCount;
+ pCommandBuffers = nullptr;
+ signalSemaphoreCount = src->signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && src->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src->pWaitSemaphores[i];
+ }
+ }
+ if (src->pWaitDstStageMask) {
+ pWaitDstStageMask = new VkPipelineStageFlags[src->waitSemaphoreCount];
+ memcpy ((void *)pWaitDstStageMask, (void *)src->pWaitDstStageMask, sizeof(VkPipelineStageFlags)*src->waitSemaphoreCount);
+ }
+ if (src->pCommandBuffers) {
+ pCommandBuffers = new VkCommandBuffer[src->commandBufferCount];
+ memcpy ((void *)pCommandBuffers, (void *)src->pCommandBuffers, sizeof(VkCommandBuffer)*src->commandBufferCount);
+ }
+ if (signalSemaphoreCount && src->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = src->pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ allocationSize(in_struct->allocationSize),
+ memoryTypeIndex(in_struct->memoryTypeIndex)
+{
+}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo()
+{}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ allocationSize = src.allocationSize;
+ memoryTypeIndex = src.memoryTypeIndex;
+}
+
+safe_VkMemoryAllocateInfo::~safe_VkMemoryAllocateInfo()
+{
+}
+
+void safe_VkMemoryAllocateInfo::initialize(const VkMemoryAllocateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ allocationSize = in_struct->allocationSize;
+ memoryTypeIndex = in_struct->memoryTypeIndex;
+}
+
+void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ allocationSize = src->allocationSize;
+ memoryTypeIndex = src->memoryTypeIndex;
+}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memory(in_struct->memory),
+ offset(in_struct->offset),
+ size(in_struct->size)
+{
+}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange()
+{}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memory = src.memory;
+ offset = src.offset;
+ size = src.size;
+}
+
+safe_VkMappedMemoryRange::~safe_VkMappedMemoryRange()
+{
+}
+
+void safe_VkMappedMemoryRange::initialize(const VkMappedMemoryRange* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memory = in_struct->memory;
+ offset = in_struct->offset;
+ size = in_struct->size;
+}
+
+void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memory = src->memory;
+ offset = src->offset;
+ size = src->size;
+}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct) :
+ buffer(in_struct->buffer),
+ bindCount(in_struct->bindCount),
+ pBinds(nullptr)
+{
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() :
+ pBinds(nullptr)
+{}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src)
+{
+ buffer = src.buffer;
+ bindCount = src.bindCount;
+ pBinds = nullptr;
+ if (bindCount && src.pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src.pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo()
+{
+ if (pBinds)
+ delete[] pBinds;
+}
+
+void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct)
+{
+ buffer = in_struct->buffer;
+ bindCount = in_struct->bindCount;
+ pBinds = nullptr;
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* src)
+{
+ buffer = src->buffer;
+ bindCount = src->bindCount;
+ pBinds = nullptr;
+ if (bindCount && src->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src->pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct) :
+ image(in_struct->image),
+ bindCount(in_struct->bindCount),
+ pBinds(nullptr)
+{
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() :
+ pBinds(nullptr)
+{}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src)
+{
+ image = src.image;
+ bindCount = src.bindCount;
+ pBinds = nullptr;
+ if (bindCount && src.pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src.pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo()
+{
+ if (pBinds)
+ delete[] pBinds;
+}
+
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct)
+{
+ image = in_struct->image;
+ bindCount = in_struct->bindCount;
+ pBinds = nullptr;
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src)
+{
+ image = src->image;
+ bindCount = src->bindCount;
+ pBinds = nullptr;
+ if (bindCount && src->pBinds) {
+ pBinds = new VkSparseMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src->pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct) :
+ image(in_struct->image),
+ bindCount(in_struct->bindCount),
+ pBinds(nullptr)
+{
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseImageMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() :
+ pBinds(nullptr)
+{}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src)
+{
+ image = src.image;
+ bindCount = src.bindCount;
+ pBinds = nullptr;
+ if (bindCount && src.pBinds) {
+ pBinds = new VkSparseImageMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src.pBinds[i];
+ }
+ }
+}
+
+safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo()
+{
+ if (pBinds)
+ delete[] pBinds;
+}
+
+void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct)
+{
+ image = in_struct->image;
+ bindCount = in_struct->bindCount;
+ pBinds = nullptr;
+ if (bindCount && in_struct->pBinds) {
+ pBinds = new VkSparseImageMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = in_struct->pBinds[i];
+ }
+ }
+}
+
+void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* src)
+{
+ image = src->image;
+ bindCount = src->bindCount;
+ pBinds = nullptr;
+ if (bindCount && src->pBinds) {
+ pBinds = new VkSparseImageMemoryBind[bindCount];
+ for (uint32_t i=0; i<bindCount; ++i) {
+ pBinds[i] = src->pBinds[i];
+ }
+ }
+}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ waitSemaphoreCount(in_struct->waitSemaphoreCount),
+ pWaitSemaphores(nullptr),
+ bufferBindCount(in_struct->bufferBindCount),
+ pBufferBinds(nullptr),
+ imageOpaqueBindCount(in_struct->imageOpaqueBindCount),
+ pImageOpaqueBinds(nullptr),
+ imageBindCount(in_struct->imageBindCount),
+ pImageBinds(nullptr),
+ signalSemaphoreCount(in_struct->signalSemaphoreCount),
+ pSignalSemaphores(nullptr)
+{
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (bufferBindCount && in_struct->pBufferBinds) {
+ pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+ for (uint32_t i=0; i<bufferBindCount; ++i) {
+ pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+ }
+ }
+ if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+ pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+ for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+ pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+ }
+ }
+ if (imageBindCount && in_struct->pImageBinds) {
+ pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+ for (uint32_t i=0; i<imageBindCount; ++i) {
+ pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
+ }
+ }
+ if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo() :
+ pWaitSemaphores(nullptr),
+ pBufferBinds(nullptr),
+ pImageOpaqueBinds(nullptr),
+ pImageBinds(nullptr),
+ pSignalSemaphores(nullptr)
+{}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ waitSemaphoreCount = src.waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ bufferBindCount = src.bufferBindCount;
+ pBufferBinds = nullptr;
+ imageOpaqueBindCount = src.imageOpaqueBindCount;
+ pImageOpaqueBinds = nullptr;
+ imageBindCount = src.imageBindCount;
+ pImageBinds = nullptr;
+ signalSemaphoreCount = src.signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && src.pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src.pWaitSemaphores[i];
+ }
+ }
+ if (bufferBindCount && src.pBufferBinds) {
+ pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+ for (uint32_t i=0; i<bufferBindCount; ++i) {
+ pBufferBinds[i].initialize(&src.pBufferBinds[i]);
+ }
+ }
+ if (imageOpaqueBindCount && src.pImageOpaqueBinds) {
+ pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+ for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+ pImageOpaqueBinds[i].initialize(&src.pImageOpaqueBinds[i]);
+ }
+ }
+ if (imageBindCount && src.pImageBinds) {
+ pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+ for (uint32_t i=0; i<imageBindCount; ++i) {
+ pImageBinds[i].initialize(&src.pImageBinds[i]);
+ }
+ }
+ if (signalSemaphoreCount && src.pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = src.pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkBindSparseInfo::~safe_VkBindSparseInfo()
+{
+ if (pWaitSemaphores)
+ delete[] pWaitSemaphores;
+ if (pBufferBinds)
+ delete[] pBufferBinds;
+ if (pImageOpaqueBinds)
+ delete[] pImageOpaqueBinds;
+ if (pImageBinds)
+ delete[] pImageBinds;
+ if (pSignalSemaphores)
+ delete[] pSignalSemaphores;
+}
+
+void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ waitSemaphoreCount = in_struct->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ bufferBindCount = in_struct->bufferBindCount;
+ pBufferBinds = nullptr;
+ imageOpaqueBindCount = in_struct->imageOpaqueBindCount;
+ pImageOpaqueBinds = nullptr;
+ imageBindCount = in_struct->imageBindCount;
+ pImageBinds = nullptr;
+ signalSemaphoreCount = in_struct->signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (bufferBindCount && in_struct->pBufferBinds) {
+ pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+ for (uint32_t i=0; i<bufferBindCount; ++i) {
+ pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+ }
+ }
+ if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+ pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+ for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+ pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+ }
+ }
+ if (imageBindCount && in_struct->pImageBinds) {
+ pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+ for (uint32_t i=0; i<imageBindCount; ++i) {
+ pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
+ }
+ }
+ if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+ }
+ }
+}
+
+void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ waitSemaphoreCount = src->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ bufferBindCount = src->bufferBindCount;
+ pBufferBinds = nullptr;
+ imageOpaqueBindCount = src->imageOpaqueBindCount;
+ pImageOpaqueBinds = nullptr;
+ imageBindCount = src->imageBindCount;
+ pImageBinds = nullptr;
+ signalSemaphoreCount = src->signalSemaphoreCount;
+ pSignalSemaphores = nullptr;
+ if (waitSemaphoreCount && src->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src->pWaitSemaphores[i];
+ }
+ }
+ if (bufferBindCount && src->pBufferBinds) {
+ pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+ for (uint32_t i=0; i<bufferBindCount; ++i) {
+ pBufferBinds[i].initialize(&src->pBufferBinds[i]);
+ }
+ }
+ if (imageOpaqueBindCount && src->pImageOpaqueBinds) {
+ pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+ for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+ pImageOpaqueBinds[i].initialize(&src->pImageOpaqueBinds[i]);
+ }
+ }
+ if (imageBindCount && src->pImageBinds) {
+ pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+ for (uint32_t i=0; i<imageBindCount; ++i) {
+ pImageBinds[i].initialize(&src->pImageBinds[i]);
+ }
+ }
+ if (signalSemaphoreCount && src->pSignalSemaphores) {
+ pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+ for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+ pSignalSemaphores[i] = src->pSignalSemaphores[i];
+ }
+ }
+}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags)
+{
+}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo()
+{}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+}
+
+safe_VkFenceCreateInfo::~safe_VkFenceCreateInfo()
+{
+}
+
+void safe_VkFenceCreateInfo::initialize(const VkFenceCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+}
+
+void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags)
+{
+}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo()
+{}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+}
+
+safe_VkSemaphoreCreateInfo::~safe_VkSemaphoreCreateInfo()
+{
+}
+
+void safe_VkSemaphoreCreateInfo::initialize(const VkSemaphoreCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+}
+
+void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags)
+{
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo()
+{}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+}
+
+safe_VkEventCreateInfo::~safe_VkEventCreateInfo()
+{
+}
+
+void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+}
+
+void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ queryType(in_struct->queryType),
+ queryCount(in_struct->queryCount),
+ pipelineStatistics(in_struct->pipelineStatistics)
+{
+}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo()
+{}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ queryType = src.queryType;
+ queryCount = src.queryCount;
+ pipelineStatistics = src.pipelineStatistics;
+}
+
+safe_VkQueryPoolCreateInfo::~safe_VkQueryPoolCreateInfo()
+{
+}
+
+void safe_VkQueryPoolCreateInfo::initialize(const VkQueryPoolCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ queryType = in_struct->queryType;
+ queryCount = in_struct->queryCount;
+ pipelineStatistics = in_struct->pipelineStatistics;
+}
+
+void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ queryType = src->queryType;
+ queryCount = src->queryCount;
+ pipelineStatistics = src->pipelineStatistics;
+}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ size(in_struct->size),
+ usage(in_struct->usage),
+ sharingMode(in_struct->sharingMode),
+ queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
+ pQueueFamilyIndices(nullptr)
+{
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo() :
+ pQueueFamilyIndices(nullptr)
+{}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ size = src.size;
+ usage = src.usage;
+ sharingMode = src.sharingMode;
+ queueFamilyIndexCount = src.queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ if (src.pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
+ }
+}
+
+safe_VkBufferCreateInfo::~safe_VkBufferCreateInfo()
+{
+ if (pQueueFamilyIndices)
+ delete[] pQueueFamilyIndices;
+}
+
+void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ size = in_struct->size;
+ usage = in_struct->usage;
+ sharingMode = in_struct->sharingMode;
+ queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ size = src->size;
+ usage = src->usage;
+ sharingMode = src->sharingMode;
+ queueFamilyIndexCount = src->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ if (src->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
+ }
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ buffer(in_struct->buffer),
+ format(in_struct->format),
+ offset(in_struct->offset),
+ range(in_struct->range)
+{
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo()
+{}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ buffer = src.buffer;
+ format = src.format;
+ offset = src.offset;
+ range = src.range;
+}
+
+safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo()
+{
+}
+
+void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ buffer = in_struct->buffer;
+ format = in_struct->format;
+ offset = in_struct->offset;
+ range = in_struct->range;
+}
+
+void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ buffer = src->buffer;
+ format = src->format;
+ offset = src->offset;
+ range = src->range;
+}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ imageType(in_struct->imageType),
+ format(in_struct->format),
+ extent(in_struct->extent),
+ mipLevels(in_struct->mipLevels),
+ arrayLayers(in_struct->arrayLayers),
+ samples(in_struct->samples),
+ tiling(in_struct->tiling),
+ usage(in_struct->usage),
+ sharingMode(in_struct->sharingMode),
+ queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
+ pQueueFamilyIndices(nullptr),
+ initialLayout(in_struct->initialLayout)
+{
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo() :
+ pQueueFamilyIndices(nullptr)
+{}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ imageType = src.imageType;
+ format = src.format;
+ extent = src.extent;
+ mipLevels = src.mipLevels;
+ arrayLayers = src.arrayLayers;
+ samples = src.samples;
+ tiling = src.tiling;
+ usage = src.usage;
+ sharingMode = src.sharingMode;
+ queueFamilyIndexCount = src.queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ initialLayout = src.initialLayout;
+ if (src.pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
+ }
+}
+
+safe_VkImageCreateInfo::~safe_VkImageCreateInfo()
+{
+ if (pQueueFamilyIndices)
+ delete[] pQueueFamilyIndices;
+}
+
+void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ imageType = in_struct->imageType;
+ format = in_struct->format;
+ extent = in_struct->extent;
+ mipLevels = in_struct->mipLevels;
+ arrayLayers = in_struct->arrayLayers;
+ samples = in_struct->samples;
+ tiling = in_struct->tiling;
+ usage = in_struct->usage;
+ sharingMode = in_struct->sharingMode;
+ queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ initialLayout = in_struct->initialLayout;
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ imageType = src->imageType;
+ format = src->format;
+ extent = src->extent;
+ mipLevels = src->mipLevels;
+ arrayLayers = src->arrayLayers;
+ samples = src->samples;
+ tiling = src->tiling;
+ usage = src->usage;
+ sharingMode = src->sharingMode;
+ queueFamilyIndexCount = src->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ initialLayout = src->initialLayout;
+ if (src->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
+ }
+}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ image(in_struct->image),
+ viewType(in_struct->viewType),
+ format(in_struct->format),
+ components(in_struct->components),
+ subresourceRange(in_struct->subresourceRange)
+{
+}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo()
+{}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ image = src.image;
+ viewType = src.viewType;
+ format = src.format;
+ components = src.components;
+ subresourceRange = src.subresourceRange;
+}
+
+safe_VkImageViewCreateInfo::~safe_VkImageViewCreateInfo()
+{
+}
+
+void safe_VkImageViewCreateInfo::initialize(const VkImageViewCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ image = in_struct->image;
+ viewType = in_struct->viewType;
+ format = in_struct->format;
+ components = in_struct->components;
+ subresourceRange = in_struct->subresourceRange;
+}
+
+void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ image = src->image;
+ viewType = src->viewType;
+ format = src->format;
+ components = src->components;
+ subresourceRange = src->subresourceRange;
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ codeSize(in_struct->codeSize),
+ pCode(nullptr)
+{
+ if (in_struct->pCode) {
+ pCode = new uint32_t(*in_struct->pCode);
+ }
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo() :
+ pCode(nullptr)
+{}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ codeSize = src.codeSize;
+ pCode = nullptr;
+ if (src.pCode) {
+ pCode = new uint32_t(*src.pCode);
+ }
+}
+
+safe_VkShaderModuleCreateInfo::~safe_VkShaderModuleCreateInfo()
+{
+ if (pCode)
+ delete pCode;
+}
+
+void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ codeSize = in_struct->codeSize;
+ pCode = nullptr;
+ if (in_struct->pCode) {
+ pCode = new uint32_t(*in_struct->pCode);
+ }
+}
+
+void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ codeSize = src->codeSize;
+ pCode = nullptr;
+ if (src->pCode) {
+ pCode = new uint32_t(*src->pCode);
+ }
+}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ initialDataSize(in_struct->initialDataSize),
+ pInitialData(in_struct->pInitialData)
+{
+}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo()
+{}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ initialDataSize = src.initialDataSize;
+ pInitialData = src.pInitialData;
+}
+
+safe_VkPipelineCacheCreateInfo::~safe_VkPipelineCacheCreateInfo()
+{
+}
+
+void safe_VkPipelineCacheCreateInfo::initialize(const VkPipelineCacheCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ initialDataSize = in_struct->initialDataSize;
+ pInitialData = in_struct->pInitialData;
+}
+
+void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ initialDataSize = src->initialDataSize;
+ pInitialData = src->pInitialData;
+}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct) :
+ mapEntryCount(in_struct->mapEntryCount),
+ pMapEntries(nullptr),
+ dataSize(in_struct->dataSize),
+ pData(in_struct->pData)
+{
+ if (in_struct->pMapEntries) {
+ pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
+ memcpy ((void *)pMapEntries, (void *)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry)*in_struct->mapEntryCount);
+ }
+}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo() :
+ pMapEntries(nullptr)
+{}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src)
+{
+ mapEntryCount = src.mapEntryCount;
+ pMapEntries = nullptr;
+ dataSize = src.dataSize;
+ pData = src.pData;
+ if (src.pMapEntries) {
+ pMapEntries = new VkSpecializationMapEntry[src.mapEntryCount];
+ memcpy ((void *)pMapEntries, (void *)src.pMapEntries, sizeof(VkSpecializationMapEntry)*src.mapEntryCount);
+ }
+}
+
+safe_VkSpecializationInfo::~safe_VkSpecializationInfo()
+{
+ if (pMapEntries)
+ delete[] pMapEntries;
+}
+
+void safe_VkSpecializationInfo::initialize(const VkSpecializationInfo* in_struct)
+{
+ mapEntryCount = in_struct->mapEntryCount;
+ pMapEntries = nullptr;
+ dataSize = in_struct->dataSize;
+ pData = in_struct->pData;
+ if (in_struct->pMapEntries) {
+ pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
+ memcpy ((void *)pMapEntries, (void *)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry)*in_struct->mapEntryCount);
+ }
+}
+
+void safe_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* src)
+{
+ mapEntryCount = src->mapEntryCount;
+ pMapEntries = nullptr;
+ dataSize = src->dataSize;
+ pData = src->pData;
+ if (src->pMapEntries) {
+ pMapEntries = new VkSpecializationMapEntry[src->mapEntryCount];
+ memcpy ((void *)pMapEntries, (void *)src->pMapEntries, sizeof(VkSpecializationMapEntry)*src->mapEntryCount);
+ }
+}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ stage(in_struct->stage),
+ module(in_struct->module),
+ pName(in_struct->pName)
+{
+ if (in_struct->pSpecializationInfo)
+ pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+ else
+ pSpecializationInfo = NULL;
+}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo()
+{}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ stage = src.stage;
+ module = src.module;
+ pName = src.pName;
+ if (src.pSpecializationInfo)
+ pSpecializationInfo = new safe_VkSpecializationInfo(*src.pSpecializationInfo);
+ else
+ pSpecializationInfo = NULL;
+}
+
+safe_VkPipelineShaderStageCreateInfo::~safe_VkPipelineShaderStageCreateInfo()
+{
+ if (pSpecializationInfo)
+ delete pSpecializationInfo;
+}
+
+void safe_VkPipelineShaderStageCreateInfo::initialize(const VkPipelineShaderStageCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ stage = in_struct->stage;
+ module = in_struct->module;
+ pName = in_struct->pName;
+ if (in_struct->pSpecializationInfo)
+ pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+ else
+ pSpecializationInfo = NULL;
+}
+
+void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ stage = src->stage;
+ module = src->module;
+ pName = src->pName;
+ if (src->pSpecializationInfo)
+ pSpecializationInfo = new safe_VkSpecializationInfo(*src->pSpecializationInfo);
+ else
+ pSpecializationInfo = NULL;
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
+ pVertexBindingDescriptions(nullptr),
+ vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
+ pVertexAttributeDescriptions(nullptr)
+{
+ if (in_struct->pVertexBindingDescriptions) {
+ pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+ memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
+ }
+ if (in_struct->pVertexAttributeDescriptions) {
+ pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+ memcpy ((void *)pVertexAttributeDescriptions, (void *)in_struct->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*in_struct->vertexAttributeDescriptionCount);
+ }
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo() :
+ pVertexBindingDescriptions(nullptr),
+ pVertexAttributeDescriptions(nullptr)
+{}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ vertexBindingDescriptionCount = src.vertexBindingDescriptionCount;
+ pVertexBindingDescriptions = nullptr;
+ vertexAttributeDescriptionCount = src.vertexAttributeDescriptionCount;
+ pVertexAttributeDescriptions = nullptr;
+ if (src.pVertexBindingDescriptions) {
+ pVertexBindingDescriptions = new VkVertexInputBindingDescription[src.vertexBindingDescriptionCount];
+ memcpy ((void *)pVertexBindingDescriptions, (void *)src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src.vertexBindingDescriptionCount);
+ }
+ if (src.pVertexAttributeDescriptions) {
+ pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[src.vertexAttributeDescriptionCount];
+ memcpy ((void *)pVertexAttributeDescriptions, (void *)src.pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*src.vertexAttributeDescriptionCount);
+ }
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo()
+{
+ if (pVertexBindingDescriptions)
+ delete[] pVertexBindingDescriptions;
+ if (pVertexAttributeDescriptions)
+ delete[] pVertexAttributeDescriptions;
+}
+
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
+ pVertexBindingDescriptions = nullptr;
+ vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
+ pVertexAttributeDescriptions = nullptr;
+ if (in_struct->pVertexBindingDescriptions) {
+ pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+ memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
+ }
+ if (in_struct->pVertexAttributeDescriptions) {
+ pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+ memcpy ((void *)pVertexAttributeDescriptions, (void *)in_struct->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*in_struct->vertexAttributeDescriptionCount);
+ }
+}
+
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ vertexBindingDescriptionCount = src->vertexBindingDescriptionCount;
+ pVertexBindingDescriptions = nullptr;
+ vertexAttributeDescriptionCount = src->vertexAttributeDescriptionCount;
+ pVertexAttributeDescriptions = nullptr;
+ if (src->pVertexBindingDescriptions) {
+ pVertexBindingDescriptions = new VkVertexInputBindingDescription[src->vertexBindingDescriptionCount];
+ memcpy ((void *)pVertexBindingDescriptions, (void *)src->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src->vertexBindingDescriptionCount);
+ }
+ if (src->pVertexAttributeDescriptions) {
+ pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[src->vertexAttributeDescriptionCount];
+ memcpy ((void *)pVertexAttributeDescriptions, (void *)src->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription)*src->vertexAttributeDescriptionCount);
+ }
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ topology(in_struct->topology),
+ primitiveRestartEnable(in_struct->primitiveRestartEnable)
+{
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo()
+{}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ topology = src.topology;
+ primitiveRestartEnable = src.primitiveRestartEnable;
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo()
+{
+}
+
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ topology = in_struct->topology;
+ primitiveRestartEnable = in_struct->primitiveRestartEnable;
+}
+
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ topology = src->topology;
+ primitiveRestartEnable = src->primitiveRestartEnable;
+}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ patchControlPoints(in_struct->patchControlPoints)
+{
+}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo()
+{}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ patchControlPoints = src.patchControlPoints;
+}
+
+safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo()
+{
+}
+
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ patchControlPoints = in_struct->patchControlPoints;
+}
+
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ patchControlPoints = src->patchControlPoints;
+}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ viewportCount(in_struct->viewportCount),
+ pViewports(nullptr),
+ scissorCount(in_struct->scissorCount),
+ pScissors(nullptr)
+{
+ if (in_struct->pViewports) {
+ pViewports = new VkViewport[in_struct->viewportCount];
+ memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
+ }
+ if (in_struct->pScissors) {
+ pScissors = new VkRect2D[in_struct->scissorCount];
+ memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);
+ }
+}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo() :
+ pViewports(nullptr),
+ pScissors(nullptr)
+{}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ viewportCount = src.viewportCount;
+ pViewports = nullptr;
+ scissorCount = src.scissorCount;
+ pScissors = nullptr;
+ if (src.pViewports) {
+ pViewports = new VkViewport[src.viewportCount];
+ memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);
+ }
+ if (src.pScissors) {
+ pScissors = new VkRect2D[src.scissorCount];
+ memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);
+ }
+}
+
+safe_VkPipelineViewportStateCreateInfo::~safe_VkPipelineViewportStateCreateInfo()
+{
+ if (pViewports)
+ delete[] pViewports;
+ if (pScissors)
+ delete[] pScissors;
+}
+
+void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewportStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ viewportCount = in_struct->viewportCount;
+ pViewports = nullptr;
+ scissorCount = in_struct->scissorCount;
+ pScissors = nullptr;
+ if (in_struct->pViewports) {
+ pViewports = new VkViewport[in_struct->viewportCount];
+ memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
+ }
+ if (in_struct->pScissors) {
+ pScissors = new VkRect2D[in_struct->scissorCount];
+ memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);
+ }
+}
+
+void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ viewportCount = src->viewportCount;
+ pViewports = nullptr;
+ scissorCount = src->scissorCount;
+ pScissors = nullptr;
+ if (src->pViewports) {
+ pViewports = new VkViewport[src->viewportCount];
+ memcpy ((void *)pViewports, (void *)src->pViewports, sizeof(VkViewport)*src->viewportCount);
+ }
+ if (src->pScissors) {
+ pScissors = new VkRect2D[src->scissorCount];
+ memcpy ((void *)pScissors, (void *)src->pScissors, sizeof(VkRect2D)*src->scissorCount);
+ }
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ depthClampEnable(in_struct->depthClampEnable),
+ rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
+ polygonMode(in_struct->polygonMode),
+ cullMode(in_struct->cullMode),
+ frontFace(in_struct->frontFace),
+ depthBiasEnable(in_struct->depthBiasEnable),
+ depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
+ depthBiasClamp(in_struct->depthBiasClamp),
+ depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
+ lineWidth(in_struct->lineWidth)
+{
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo()
+{}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ depthClampEnable = src.depthClampEnable;
+ rasterizerDiscardEnable = src.rasterizerDiscardEnable;
+ polygonMode = src.polygonMode;
+ cullMode = src.cullMode;
+ frontFace = src.frontFace;
+ depthBiasEnable = src.depthBiasEnable;
+ depthBiasConstantFactor = src.depthBiasConstantFactor;
+ depthBiasClamp = src.depthBiasClamp;
+ depthBiasSlopeFactor = src.depthBiasSlopeFactor;
+ lineWidth = src.lineWidth;
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo()
+{
+}
+
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ depthClampEnable = in_struct->depthClampEnable;
+ rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
+ polygonMode = in_struct->polygonMode;
+ cullMode = in_struct->cullMode;
+ frontFace = in_struct->frontFace;
+ depthBiasEnable = in_struct->depthBiasEnable;
+ depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
+ depthBiasClamp = in_struct->depthBiasClamp;
+ depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
+ lineWidth = in_struct->lineWidth;
+}
+
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ depthClampEnable = src->depthClampEnable;
+ rasterizerDiscardEnable = src->rasterizerDiscardEnable;
+ polygonMode = src->polygonMode;
+ cullMode = src->cullMode;
+ frontFace = src->frontFace;
+ depthBiasEnable = src->depthBiasEnable;
+ depthBiasConstantFactor = src->depthBiasConstantFactor;
+ depthBiasClamp = src->depthBiasClamp;
+ depthBiasSlopeFactor = src->depthBiasSlopeFactor;
+ lineWidth = src->lineWidth;
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ rasterizationSamples(in_struct->rasterizationSamples),
+ sampleShadingEnable(in_struct->sampleShadingEnable),
+ minSampleShading(in_struct->minSampleShading),
+ pSampleMask(nullptr),
+ alphaToCoverageEnable(in_struct->alphaToCoverageEnable),
+ alphaToOneEnable(in_struct->alphaToOneEnable)
+{
+ if (in_struct->pSampleMask) {
+ pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
+ }
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo() :
+ pSampleMask(nullptr)
+{}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ rasterizationSamples = src.rasterizationSamples;
+ sampleShadingEnable = src.sampleShadingEnable;
+ minSampleShading = src.minSampleShading;
+ pSampleMask = nullptr;
+ alphaToCoverageEnable = src.alphaToCoverageEnable;
+ alphaToOneEnable = src.alphaToOneEnable;
+ if (src.pSampleMask) {
+ pSampleMask = new VkSampleMask(*src.pSampleMask);
+ }
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::~safe_VkPipelineMultisampleStateCreateInfo()
+{
+ if (pSampleMask)
+ delete pSampleMask;
+}
+
+void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMultisampleStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ rasterizationSamples = in_struct->rasterizationSamples;
+ sampleShadingEnable = in_struct->sampleShadingEnable;
+ minSampleShading = in_struct->minSampleShading;
+ pSampleMask = nullptr;
+ alphaToCoverageEnable = in_struct->alphaToCoverageEnable;
+ alphaToOneEnable = in_struct->alphaToOneEnable;
+ if (in_struct->pSampleMask) {
+ pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
+ }
+}
+
+void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ rasterizationSamples = src->rasterizationSamples;
+ sampleShadingEnable = src->sampleShadingEnable;
+ minSampleShading = src->minSampleShading;
+ pSampleMask = nullptr;
+ alphaToCoverageEnable = src->alphaToCoverageEnable;
+ alphaToOneEnable = src->alphaToOneEnable;
+ if (src->pSampleMask) {
+ pSampleMask = new VkSampleMask(*src->pSampleMask);
+ }
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ depthTestEnable(in_struct->depthTestEnable),
+ depthWriteEnable(in_struct->depthWriteEnable),
+ depthCompareOp(in_struct->depthCompareOp),
+ depthBoundsTestEnable(in_struct->depthBoundsTestEnable),
+ stencilTestEnable(in_struct->stencilTestEnable),
+ front(in_struct->front),
+ back(in_struct->back),
+ minDepthBounds(in_struct->minDepthBounds),
+ maxDepthBounds(in_struct->maxDepthBounds)
+{
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo()
+{}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ depthTestEnable = src.depthTestEnable;
+ depthWriteEnable = src.depthWriteEnable;
+ depthCompareOp = src.depthCompareOp;
+ depthBoundsTestEnable = src.depthBoundsTestEnable;
+ stencilTestEnable = src.stencilTestEnable;
+ front = src.front;
+ back = src.back;
+ minDepthBounds = src.minDepthBounds;
+ maxDepthBounds = src.maxDepthBounds;
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo()
+{
+}
+
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ depthTestEnable = in_struct->depthTestEnable;
+ depthWriteEnable = in_struct->depthWriteEnable;
+ depthCompareOp = in_struct->depthCompareOp;
+ depthBoundsTestEnable = in_struct->depthBoundsTestEnable;
+ stencilTestEnable = in_struct->stencilTestEnable;
+ front = in_struct->front;
+ back = in_struct->back;
+ minDepthBounds = in_struct->minDepthBounds;
+ maxDepthBounds = in_struct->maxDepthBounds;
+}
+
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ depthTestEnable = src->depthTestEnable;
+ depthWriteEnable = src->depthWriteEnable;
+ depthCompareOp = src->depthCompareOp;
+ depthBoundsTestEnable = src->depthBoundsTestEnable;
+ stencilTestEnable = src->stencilTestEnable;
+ front = src->front;
+ back = src->back;
+ minDepthBounds = src->minDepthBounds;
+ maxDepthBounds = src->maxDepthBounds;
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ logicOpEnable(in_struct->logicOpEnable),
+ logicOp(in_struct->logicOp),
+ attachmentCount(in_struct->attachmentCount),
+ pAttachments(nullptr)
+{
+ if (in_struct->pAttachments) {
+ pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
+ }
+ for (uint32_t i=0; i<4; ++i) {
+ blendConstants[i] = in_struct->blendConstants[i];
+ }
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo() :
+ pAttachments(nullptr)
+{}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ logicOpEnable = src.logicOpEnable;
+ logicOp = src.logicOp;
+ attachmentCount = src.attachmentCount;
+ pAttachments = nullptr;
+ if (src.pAttachments) {
+ pAttachments = new VkPipelineColorBlendAttachmentState[src.attachmentCount];
+ memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src.attachmentCount);
+ }
+ for (uint32_t i=0; i<4; ++i) {
+ blendConstants[i] = src.blendConstants[i];
+ }
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo()
+{
+ if (pAttachments)
+ delete[] pAttachments;
+}
+
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ logicOpEnable = in_struct->logicOpEnable;
+ logicOp = in_struct->logicOp;
+ attachmentCount = in_struct->attachmentCount;
+ pAttachments = nullptr;
+ if (in_struct->pAttachments) {
+ pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
+ }
+ for (uint32_t i=0; i<4; ++i) {
+ blendConstants[i] = in_struct->blendConstants[i];
+ }
+}
+
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ logicOpEnable = src->logicOpEnable;
+ logicOp = src->logicOp;
+ attachmentCount = src->attachmentCount;
+ pAttachments = nullptr;
+ if (src->pAttachments) {
+ pAttachments = new VkPipelineColorBlendAttachmentState[src->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src->attachmentCount);
+ }
+ for (uint32_t i=0; i<4; ++i) {
+ blendConstants[i] = src->blendConstants[i];
+ }
+}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ dynamicStateCount(in_struct->dynamicStateCount),
+ pDynamicStates(nullptr)
+{
+ if (in_struct->pDynamicStates) {
+ pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+ memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
+ }
+}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo() :
+ pDynamicStates(nullptr)
+{}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ dynamicStateCount = src.dynamicStateCount;
+ pDynamicStates = nullptr;
+ if (src.pDynamicStates) {
+ pDynamicStates = new VkDynamicState[src.dynamicStateCount];
+ memcpy ((void *)pDynamicStates, (void *)src.pDynamicStates, sizeof(VkDynamicState)*src.dynamicStateCount);
+ }
+}
+
+safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo()
+{
+ if (pDynamicStates)
+ delete[] pDynamicStates;
+}
+
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ dynamicStateCount = in_struct->dynamicStateCount;
+ pDynamicStates = nullptr;
+ if (in_struct->pDynamicStates) {
+ pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+ memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
+ }
+}
+
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ dynamicStateCount = src->dynamicStateCount;
+ pDynamicStates = nullptr;
+ if (src->pDynamicStates) {
+ pDynamicStates = new VkDynamicState[src->dynamicStateCount];
+ memcpy ((void *)pDynamicStates, (void *)src->pDynamicStates, sizeof(VkDynamicState)*src->dynamicStateCount);
+ }
+}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ stageCount(in_struct->stageCount),
+ pStages(nullptr),
+ layout(in_struct->layout),
+ renderPass(in_struct->renderPass),
+ subpass(in_struct->subpass),
+ basePipelineHandle(in_struct->basePipelineHandle),
+ basePipelineIndex(in_struct->basePipelineIndex)
+{
+ if (stageCount && in_struct->pStages) {
+ pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+ for (uint32_t i=0; i<stageCount; ++i) {
+ pStages[i].initialize(&in_struct->pStages[i]);
+ }
+ }
+ if (in_struct->pVertexInputState)
+ pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+ else
+ pVertexInputState = NULL;
+ if (in_struct->pInputAssemblyState)
+ pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
+ else
+ pInputAssemblyState = NULL;
+ if (in_struct->pTessellationState)
+ pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+ else
+ pTessellationState = NULL;
+ if (in_struct->pViewportState)
+ pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState);
+ else
+ pViewportState = NULL;
+ if (in_struct->pRasterizationState)
+ pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+ else
+ pRasterizationState = NULL;
+ if (in_struct->pMultisampleState)
+ pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
+ else
+ pMultisampleState = NULL;
+ if (in_struct->pDepthStencilState)
+ pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
+ else
+ pDepthStencilState = NULL;
+ if (in_struct->pColorBlendState)
+ pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+ else
+ pColorBlendState = NULL;
+ if (in_struct->pDynamicState)
+ pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+ else
+ pDynamicState = NULL;
+}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo() :
+ pStages(nullptr)
+{}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ stageCount = src.stageCount;
+ pStages = nullptr;
+ layout = src.layout;
+ renderPass = src.renderPass;
+ subpass = src.subpass;
+ basePipelineHandle = src.basePipelineHandle;
+ basePipelineIndex = src.basePipelineIndex;
+ if (stageCount && src.pStages) {
+ pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+ for (uint32_t i=0; i<stageCount; ++i) {
+ pStages[i].initialize(&src.pStages[i]);
+ }
+ }
+ if (src.pVertexInputState)
+ pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);
+ else
+ pVertexInputState = NULL;
+ if (src.pInputAssemblyState)
+ pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);
+ else
+ pInputAssemblyState = NULL;
+ if (src.pTessellationState)
+ pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);
+ else
+ pTessellationState = NULL;
+ if (src.pViewportState)
+ pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);
+ else
+ pViewportState = NULL;
+ if (src.pRasterizationState)
+ pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);
+ else
+ pRasterizationState = NULL;
+ if (src.pMultisampleState)
+ pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);
+ else
+ pMultisampleState = NULL;
+ if (src.pDepthStencilState)
+ pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);
+ else
+ pDepthStencilState = NULL;
+ if (src.pColorBlendState)
+ pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);
+ else
+ pColorBlendState = NULL;
+ if (src.pDynamicState)
+ pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);
+ else
+ pDynamicState = NULL;
+}
+
+safe_VkGraphicsPipelineCreateInfo::~safe_VkGraphicsPipelineCreateInfo()
+{
+ if (pStages)
+ delete[] pStages;
+ if (pVertexInputState)
+ delete pVertexInputState;
+ if (pInputAssemblyState)
+ delete pInputAssemblyState;
+ if (pTessellationState)
+ delete pTessellationState;
+ if (pViewportState)
+ delete pViewportState;
+ if (pRasterizationState)
+ delete pRasterizationState;
+ if (pMultisampleState)
+ delete pMultisampleState;
+ if (pDepthStencilState)
+ delete pDepthStencilState;
+ if (pColorBlendState)
+ delete pColorBlendState;
+ if (pDynamicState)
+ delete pDynamicState;
+}
+
+void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ stageCount = in_struct->stageCount;
+ pStages = nullptr;
+ layout = in_struct->layout;
+ renderPass = in_struct->renderPass;
+ subpass = in_struct->subpass;
+ basePipelineHandle = in_struct->basePipelineHandle;
+ basePipelineIndex = in_struct->basePipelineIndex;
+ if (stageCount && in_struct->pStages) {
+ pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+ for (uint32_t i=0; i<stageCount; ++i) {
+ pStages[i].initialize(&in_struct->pStages[i]);
+ }
+ }
+ if (in_struct->pVertexInputState)
+ pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+ else
+ pVertexInputState = NULL;
+ if (in_struct->pInputAssemblyState)
+ pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
+ else
+ pInputAssemblyState = NULL;
+ if (in_struct->pTessellationState)
+ pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+ else
+ pTessellationState = NULL;
+ if (in_struct->pViewportState)
+ pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState);
+ else
+ pViewportState = NULL;
+ if (in_struct->pRasterizationState)
+ pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+ else
+ pRasterizationState = NULL;
+ if (in_struct->pMultisampleState)
+ pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
+ else
+ pMultisampleState = NULL;
+ if (in_struct->pDepthStencilState)
+ pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
+ else
+ pDepthStencilState = NULL;
+ if (in_struct->pColorBlendState)
+ pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+ else
+ pColorBlendState = NULL;
+ if (in_struct->pDynamicState)
+ pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+ else
+ pDynamicState = NULL;
+}
+
+void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ stageCount = src->stageCount;
+ pStages = nullptr;
+ layout = src->layout;
+ renderPass = src->renderPass;
+ subpass = src->subpass;
+ basePipelineHandle = src->basePipelineHandle;
+ basePipelineIndex = src->basePipelineIndex;
+ if (stageCount && src->pStages) {
+ pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+ for (uint32_t i=0; i<stageCount; ++i) {
+ pStages[i].initialize(&src->pStages[i]);
+ }
+ }
+ if (src->pVertexInputState)
+ pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src->pVertexInputState);
+ else
+ pVertexInputState = NULL;
+ if (src->pInputAssemblyState)
+ pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src->pInputAssemblyState);
+ else
+ pInputAssemblyState = NULL;
+ if (src->pTessellationState)
+ pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src->pTessellationState);
+ else
+ pTessellationState = NULL;
+ if (src->pViewportState)
+ pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src->pViewportState);
+ else
+ pViewportState = NULL;
+ if (src->pRasterizationState)
+ pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src->pRasterizationState);
+ else
+ pRasterizationState = NULL;
+ if (src->pMultisampleState)
+ pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src->pMultisampleState);
+ else
+ pMultisampleState = NULL;
+ if (src->pDepthStencilState)
+ pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src->pDepthStencilState);
+ else
+ pDepthStencilState = NULL;
+ if (src->pColorBlendState)
+ pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src->pColorBlendState);
+ else
+ pColorBlendState = NULL;
+ if (src->pDynamicState)
+ pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src->pDynamicState);
+ else
+ pDynamicState = NULL;
+}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ stage(&in_struct->stage),
+ layout(in_struct->layout),
+ basePipelineHandle(in_struct->basePipelineHandle),
+ basePipelineIndex(in_struct->basePipelineIndex)
+{
+}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo()
+{}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ stage.initialize(&src.stage);
+ layout = src.layout;
+ basePipelineHandle = src.basePipelineHandle;
+ basePipelineIndex = src.basePipelineIndex;
+}
+
+safe_VkComputePipelineCreateInfo::~safe_VkComputePipelineCreateInfo()
+{
+}
+
+void safe_VkComputePipelineCreateInfo::initialize(const VkComputePipelineCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ stage.initialize(&in_struct->stage);
+ layout = in_struct->layout;
+ basePipelineHandle = in_struct->basePipelineHandle;
+ basePipelineIndex = in_struct->basePipelineIndex;
+}
+
+void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ stage.initialize(&src->stage);
+ layout = src->layout;
+ basePipelineHandle = src->basePipelineHandle;
+ basePipelineIndex = src->basePipelineIndex;
+}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ setLayoutCount(in_struct->setLayoutCount),
+ pSetLayouts(nullptr),
+ pushConstantRangeCount(in_struct->pushConstantRangeCount),
+ pPushConstantRanges(nullptr)
+{
+ if (setLayoutCount && in_struct->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+ for (uint32_t i=0; i<setLayoutCount; ++i) {
+ pSetLayouts[i] = in_struct->pSetLayouts[i];
+ }
+ }
+ if (in_struct->pPushConstantRanges) {
+ pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+ memcpy ((void *)pPushConstantRanges, (void *)in_struct->pPushConstantRanges, sizeof(VkPushConstantRange)*in_struct->pushConstantRangeCount);
+ }
+}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo() :
+ pSetLayouts(nullptr),
+ pPushConstantRanges(nullptr)
+{}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ setLayoutCount = src.setLayoutCount;
+ pSetLayouts = nullptr;
+ pushConstantRangeCount = src.pushConstantRangeCount;
+ pPushConstantRanges = nullptr;
+ if (setLayoutCount && src.pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+ for (uint32_t i=0; i<setLayoutCount; ++i) {
+ pSetLayouts[i] = src.pSetLayouts[i];
+ }
+ }
+ if (src.pPushConstantRanges) {
+ pPushConstantRanges = new VkPushConstantRange[src.pushConstantRangeCount];
+ memcpy ((void *)pPushConstantRanges, (void *)src.pPushConstantRanges, sizeof(VkPushConstantRange)*src.pushConstantRangeCount);
+ }
+}
+
+safe_VkPipelineLayoutCreateInfo::~safe_VkPipelineLayoutCreateInfo()
+{
+ if (pSetLayouts)
+ delete[] pSetLayouts;
+ if (pPushConstantRanges)
+ delete[] pPushConstantRanges;
+}
+
+void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ setLayoutCount = in_struct->setLayoutCount;
+ pSetLayouts = nullptr;
+ pushConstantRangeCount = in_struct->pushConstantRangeCount;
+ pPushConstantRanges = nullptr;
+ if (setLayoutCount && in_struct->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+ for (uint32_t i=0; i<setLayoutCount; ++i) {
+ pSetLayouts[i] = in_struct->pSetLayouts[i];
+ }
+ }
+ if (in_struct->pPushConstantRanges) {
+ pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+ memcpy ((void *)pPushConstantRanges, (void *)in_struct->pPushConstantRanges, sizeof(VkPushConstantRange)*in_struct->pushConstantRangeCount);
+ }
+}
+
+void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ setLayoutCount = src->setLayoutCount;
+ pSetLayouts = nullptr;
+ pushConstantRangeCount = src->pushConstantRangeCount;
+ pPushConstantRanges = nullptr;
+ if (setLayoutCount && src->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+ for (uint32_t i=0; i<setLayoutCount; ++i) {
+ pSetLayouts[i] = src->pSetLayouts[i];
+ }
+ }
+ if (src->pPushConstantRanges) {
+ pPushConstantRanges = new VkPushConstantRange[src->pushConstantRangeCount];
+ memcpy ((void *)pPushConstantRanges, (void *)src->pPushConstantRanges, sizeof(VkPushConstantRange)*src->pushConstantRangeCount);
+ }
+}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ magFilter(in_struct->magFilter),
+ minFilter(in_struct->minFilter),
+ mipmapMode(in_struct->mipmapMode),
+ addressModeU(in_struct->addressModeU),
+ addressModeV(in_struct->addressModeV),
+ addressModeW(in_struct->addressModeW),
+ mipLodBias(in_struct->mipLodBias),
+ anisotropyEnable(in_struct->anisotropyEnable),
+ maxAnisotropy(in_struct->maxAnisotropy),
+ compareEnable(in_struct->compareEnable),
+ compareOp(in_struct->compareOp),
+ minLod(in_struct->minLod),
+ maxLod(in_struct->maxLod),
+ borderColor(in_struct->borderColor),
+ unnormalizedCoordinates(in_struct->unnormalizedCoordinates)
+{
+}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo()
+{}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ magFilter = src.magFilter;
+ minFilter = src.minFilter;
+ mipmapMode = src.mipmapMode;
+ addressModeU = src.addressModeU;
+ addressModeV = src.addressModeV;
+ addressModeW = src.addressModeW;
+ mipLodBias = src.mipLodBias;
+ anisotropyEnable = src.anisotropyEnable;
+ maxAnisotropy = src.maxAnisotropy;
+ compareEnable = src.compareEnable;
+ compareOp = src.compareOp;
+ minLod = src.minLod;
+ maxLod = src.maxLod;
+ borderColor = src.borderColor;
+ unnormalizedCoordinates = src.unnormalizedCoordinates;
+}
+
+safe_VkSamplerCreateInfo::~safe_VkSamplerCreateInfo()
+{
+}
+
+void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ magFilter = in_struct->magFilter;
+ minFilter = in_struct->minFilter;
+ mipmapMode = in_struct->mipmapMode;
+ addressModeU = in_struct->addressModeU;
+ addressModeV = in_struct->addressModeV;
+ addressModeW = in_struct->addressModeW;
+ mipLodBias = in_struct->mipLodBias;
+ anisotropyEnable = in_struct->anisotropyEnable;
+ maxAnisotropy = in_struct->maxAnisotropy;
+ compareEnable = in_struct->compareEnable;
+ compareOp = in_struct->compareOp;
+ minLod = in_struct->minLod;
+ maxLod = in_struct->maxLod;
+ borderColor = in_struct->borderColor;
+ unnormalizedCoordinates = in_struct->unnormalizedCoordinates;
+}
+
+void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ magFilter = src->magFilter;
+ minFilter = src->minFilter;
+ mipmapMode = src->mipmapMode;
+ addressModeU = src->addressModeU;
+ addressModeV = src->addressModeV;
+ addressModeW = src->addressModeW;
+ mipLodBias = src->mipLodBias;
+ anisotropyEnable = src->anisotropyEnable;
+ maxAnisotropy = src->maxAnisotropy;
+ compareEnable = src->compareEnable;
+ compareOp = src->compareOp;
+ minLod = src->minLod;
+ maxLod = src->maxLod;
+ borderColor = src->borderColor;
+ unnormalizedCoordinates = src->unnormalizedCoordinates;
+}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct) :
+ binding(in_struct->binding),
+ descriptorType(in_struct->descriptorType),
+ descriptorCount(in_struct->descriptorCount),
+ stageFlags(in_struct->stageFlags),
+ pImmutableSamplers(nullptr)
+{
+ if (descriptorCount && in_struct->pImmutableSamplers) {
+ pImmutableSamplers = new VkSampler[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+ }
+ }
+}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding() :
+ pImmutableSamplers(nullptr)
+{}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src)
+{
+ binding = src.binding;
+ descriptorType = src.descriptorType;
+ descriptorCount = src.descriptorCount;
+ stageFlags = src.stageFlags;
+ pImmutableSamplers = nullptr;
+ if (descriptorCount && src.pImmutableSamplers) {
+ pImmutableSamplers = new VkSampler[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImmutableSamplers[i] = src.pImmutableSamplers[i];
+ }
+ }
+}
+
+safe_VkDescriptorSetLayoutBinding::~safe_VkDescriptorSetLayoutBinding()
+{
+ if (pImmutableSamplers)
+ delete[] pImmutableSamplers;
+}
+
+void safe_VkDescriptorSetLayoutBinding::initialize(const VkDescriptorSetLayoutBinding* in_struct)
+{
+ binding = in_struct->binding;
+ descriptorType = in_struct->descriptorType;
+ descriptorCount = in_struct->descriptorCount;
+ stageFlags = in_struct->stageFlags;
+ pImmutableSamplers = nullptr;
+ if (descriptorCount && in_struct->pImmutableSamplers) {
+ pImmutableSamplers = new VkSampler[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+ }
+ }
+}
+
+void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLayoutBinding* src)
+{
+ binding = src->binding;
+ descriptorType = src->descriptorType;
+ descriptorCount = src->descriptorCount;
+ stageFlags = src->stageFlags;
+ pImmutableSamplers = nullptr;
+ if (descriptorCount && src->pImmutableSamplers) {
+ pImmutableSamplers = new VkSampler[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImmutableSamplers[i] = src->pImmutableSamplers[i];
+ }
+ }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ bindingCount(in_struct->bindingCount),
+ pBindings(nullptr)
+{
+ if (bindingCount && in_struct->pBindings) {
+ pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+ for (uint32_t i=0; i<bindingCount; ++i) {
+ pBindings[i].initialize(&in_struct->pBindings[i]);
+ }
+ }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo() :
+ pBindings(nullptr)
+{}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ bindingCount = src.bindingCount;
+ pBindings = nullptr;
+ if (bindingCount && src.pBindings) {
+ pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+ for (uint32_t i=0; i<bindingCount; ++i) {
+ pBindings[i].initialize(&src.pBindings[i]);
+ }
+ }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::~safe_VkDescriptorSetLayoutCreateInfo()
+{
+ if (pBindings)
+ delete[] pBindings;
+}
+
+void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayoutCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ bindingCount = in_struct->bindingCount;
+ pBindings = nullptr;
+ if (bindingCount && in_struct->pBindings) {
+ pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+ for (uint32_t i=0; i<bindingCount; ++i) {
+ pBindings[i].initialize(&in_struct->pBindings[i]);
+ }
+ }
+}
+
+void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ bindingCount = src->bindingCount;
+ pBindings = nullptr;
+ if (bindingCount && src->pBindings) {
+ pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+ for (uint32_t i=0; i<bindingCount; ++i) {
+ pBindings[i].initialize(&src->pBindings[i]);
+ }
+ }
+}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ maxSets(in_struct->maxSets),
+ poolSizeCount(in_struct->poolSizeCount),
+ pPoolSizes(nullptr)
+{
+ if (in_struct->pPoolSizes) {
+ pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
+ memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
+ }
+}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo() :
+ pPoolSizes(nullptr)
+{}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ maxSets = src.maxSets;
+ poolSizeCount = src.poolSizeCount;
+ pPoolSizes = nullptr;
+ if (src.pPoolSizes) {
+ pPoolSizes = new VkDescriptorPoolSize[src.poolSizeCount];
+ memcpy ((void *)pPoolSizes, (void *)src.pPoolSizes, sizeof(VkDescriptorPoolSize)*src.poolSizeCount);
+ }
+}
+
+safe_VkDescriptorPoolCreateInfo::~safe_VkDescriptorPoolCreateInfo()
+{
+ if (pPoolSizes)
+ delete[] pPoolSizes;
+}
+
+void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ maxSets = in_struct->maxSets;
+ poolSizeCount = in_struct->poolSizeCount;
+ pPoolSizes = nullptr;
+ if (in_struct->pPoolSizes) {
+ pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
+ memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
+ }
+}
+
+void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ maxSets = src->maxSets;
+ poolSizeCount = src->poolSizeCount;
+ pPoolSizes = nullptr;
+ if (src->pPoolSizes) {
+ pPoolSizes = new VkDescriptorPoolSize[src->poolSizeCount];
+ memcpy ((void *)pPoolSizes, (void *)src->pPoolSizes, sizeof(VkDescriptorPoolSize)*src->poolSizeCount);
+ }
+}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ descriptorPool(in_struct->descriptorPool),
+ descriptorSetCount(in_struct->descriptorSetCount),
+ pSetLayouts(nullptr)
+{
+ if (descriptorSetCount && in_struct->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+ for (uint32_t i=0; i<descriptorSetCount; ++i) {
+ pSetLayouts[i] = in_struct->pSetLayouts[i];
+ }
+ }
+}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo() :
+ pSetLayouts(nullptr)
+{}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ descriptorPool = src.descriptorPool;
+ descriptorSetCount = src.descriptorSetCount;
+ pSetLayouts = nullptr;
+ if (descriptorSetCount && src.pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+ for (uint32_t i=0; i<descriptorSetCount; ++i) {
+ pSetLayouts[i] = src.pSetLayouts[i];
+ }
+ }
+}
+
+safe_VkDescriptorSetAllocateInfo::~safe_VkDescriptorSetAllocateInfo()
+{
+ if (pSetLayouts)
+ delete[] pSetLayouts;
+}
+
+void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ descriptorPool = in_struct->descriptorPool;
+ descriptorSetCount = in_struct->descriptorSetCount;
+ pSetLayouts = nullptr;
+ if (descriptorSetCount && in_struct->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+ for (uint32_t i=0; i<descriptorSetCount; ++i) {
+ pSetLayouts[i] = in_struct->pSetLayouts[i];
+ }
+ }
+}
+
+void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ descriptorPool = src->descriptorPool;
+ descriptorSetCount = src->descriptorSetCount;
+ pSetLayouts = nullptr;
+ if (descriptorSetCount && src->pSetLayouts) {
+ pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+ for (uint32_t i=0; i<descriptorSetCount; ++i) {
+ pSetLayouts[i] = src->pSetLayouts[i];
+ }
+ }
+}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ dstSet(in_struct->dstSet),
+ dstBinding(in_struct->dstBinding),
+ dstArrayElement(in_struct->dstArrayElement),
+ descriptorCount(in_struct->descriptorCount),
+ descriptorType(in_struct->descriptorType),
+ pImageInfo(nullptr),
+ pBufferInfo(nullptr),
+ pTexelBufferView(nullptr)
+{
+ switch (descriptorType) {
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ if (descriptorCount && in_struct->pImageInfo) {
+ pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImageInfo[i] = in_struct->pImageInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ if (descriptorCount && in_struct->pBufferInfo) {
+ pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pBufferInfo[i] = in_struct->pBufferInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ if (descriptorCount && in_struct->pTexelBufferView) {
+ pTexelBufferView = new VkBufferView[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet() :
+ pImageInfo(nullptr),
+ pBufferInfo(nullptr),
+ pTexelBufferView(nullptr)
+{}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ dstSet = src.dstSet;
+ dstBinding = src.dstBinding;
+ dstArrayElement = src.dstArrayElement;
+ descriptorCount = src.descriptorCount;
+ descriptorType = src.descriptorType;
+ pImageInfo = nullptr;
+ pBufferInfo = nullptr;
+ pTexelBufferView = nullptr;
+ switch (descriptorType) {
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ if (descriptorCount && src.pImageInfo) {
+ pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImageInfo[i] = src.pImageInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ if (descriptorCount && src.pBufferInfo) {
+ pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pBufferInfo[i] = src.pBufferInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ if (descriptorCount && src.pTexelBufferView) {
+ pTexelBufferView = new VkBufferView[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pTexelBufferView[i] = src.pTexelBufferView[i];
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+safe_VkWriteDescriptorSet::~safe_VkWriteDescriptorSet()
+{
+ if (pImageInfo)
+ delete[] pImageInfo;
+ if (pBufferInfo)
+ delete[] pBufferInfo;
+ if (pTexelBufferView)
+ delete[] pTexelBufferView;
+}
+
+void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ dstSet = in_struct->dstSet;
+ dstBinding = in_struct->dstBinding;
+ dstArrayElement = in_struct->dstArrayElement;
+ descriptorCount = in_struct->descriptorCount;
+ descriptorType = in_struct->descriptorType;
+ pImageInfo = nullptr;
+ pBufferInfo = nullptr;
+ pTexelBufferView = nullptr;
+ switch (descriptorType) {
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ if (descriptorCount && in_struct->pImageInfo) {
+ pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImageInfo[i] = in_struct->pImageInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ if (descriptorCount && in_struct->pBufferInfo) {
+ pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pBufferInfo[i] = in_struct->pBufferInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ if (descriptorCount && in_struct->pTexelBufferView) {
+ pTexelBufferView = new VkBufferView[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ dstSet = src->dstSet;
+ dstBinding = src->dstBinding;
+ dstArrayElement = src->dstArrayElement;
+ descriptorCount = src->descriptorCount;
+ descriptorType = src->descriptorType;
+ pImageInfo = nullptr;
+ pBufferInfo = nullptr;
+ pTexelBufferView = nullptr;
+ switch (descriptorType) {
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ if (descriptorCount && src->pImageInfo) {
+ pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pImageInfo[i] = src->pImageInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ if (descriptorCount && src->pBufferInfo) {
+ pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pBufferInfo[i] = src->pBufferInfo[i];
+ }
+ }
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ if (descriptorCount && src->pTexelBufferView) {
+ pTexelBufferView = new VkBufferView[descriptorCount];
+ for (uint32_t i=0; i<descriptorCount; ++i) {
+ pTexelBufferView[i] = src->pTexelBufferView[i];
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcSet(in_struct->srcSet),
+ srcBinding(in_struct->srcBinding),
+ srcArrayElement(in_struct->srcArrayElement),
+ dstSet(in_struct->dstSet),
+ dstBinding(in_struct->dstBinding),
+ dstArrayElement(in_struct->dstArrayElement),
+ descriptorCount(in_struct->descriptorCount)
+{
+}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet()
+{}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcSet = src.srcSet;
+ srcBinding = src.srcBinding;
+ srcArrayElement = src.srcArrayElement;
+ dstSet = src.dstSet;
+ dstBinding = src.dstBinding;
+ dstArrayElement = src.dstArrayElement;
+ descriptorCount = src.descriptorCount;
+}
+
+safe_VkCopyDescriptorSet::~safe_VkCopyDescriptorSet()
+{
+}
+
+void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcSet = in_struct->srcSet;
+ srcBinding = in_struct->srcBinding;
+ srcArrayElement = in_struct->srcArrayElement;
+ dstSet = in_struct->dstSet;
+ dstBinding = in_struct->dstBinding;
+ dstArrayElement = in_struct->dstArrayElement;
+ descriptorCount = in_struct->descriptorCount;
+}
+
+void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcSet = src->srcSet;
+ srcBinding = src->srcBinding;
+ srcArrayElement = src->srcArrayElement;
+ dstSet = src->dstSet;
+ dstBinding = src->dstBinding;
+ dstArrayElement = src->dstArrayElement;
+ descriptorCount = src->descriptorCount;
+}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ renderPass(in_struct->renderPass),
+ attachmentCount(in_struct->attachmentCount),
+ pAttachments(nullptr),
+ width(in_struct->width),
+ height(in_struct->height),
+ layers(in_struct->layers)
+{
+ if (attachmentCount && in_struct->pAttachments) {
+ pAttachments = new VkImageView[attachmentCount];
+ for (uint32_t i=0; i<attachmentCount; ++i) {
+ pAttachments[i] = in_struct->pAttachments[i];
+ }
+ }
+}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo() :
+ pAttachments(nullptr)
+{}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ renderPass = src.renderPass;
+ attachmentCount = src.attachmentCount;
+ pAttachments = nullptr;
+ width = src.width;
+ height = src.height;
+ layers = src.layers;
+ if (attachmentCount && src.pAttachments) {
+ pAttachments = new VkImageView[attachmentCount];
+ for (uint32_t i=0; i<attachmentCount; ++i) {
+ pAttachments[i] = src.pAttachments[i];
+ }
+ }
+}
+
+safe_VkFramebufferCreateInfo::~safe_VkFramebufferCreateInfo()
+{
+ if (pAttachments)
+ delete[] pAttachments;
+}
+
+void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ renderPass = in_struct->renderPass;
+ attachmentCount = in_struct->attachmentCount;
+ pAttachments = nullptr;
+ width = in_struct->width;
+ height = in_struct->height;
+ layers = in_struct->layers;
+ if (attachmentCount && in_struct->pAttachments) {
+ pAttachments = new VkImageView[attachmentCount];
+ for (uint32_t i=0; i<attachmentCount; ++i) {
+ pAttachments[i] = in_struct->pAttachments[i];
+ }
+ }
+}
+
+void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ renderPass = src->renderPass;
+ attachmentCount = src->attachmentCount;
+ pAttachments = nullptr;
+ width = src->width;
+ height = src->height;
+ layers = src->layers;
+ if (attachmentCount && src->pAttachments) {
+ pAttachments = new VkImageView[attachmentCount];
+ for (uint32_t i=0; i<attachmentCount; ++i) {
+ pAttachments[i] = src->pAttachments[i];
+ }
+ }
+}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription(const VkSubpassDescription* in_struct) :
+ flags(in_struct->flags),
+ pipelineBindPoint(in_struct->pipelineBindPoint),
+ inputAttachmentCount(in_struct->inputAttachmentCount),
+ pInputAttachments(nullptr),
+ colorAttachmentCount(in_struct->colorAttachmentCount),
+ pColorAttachments(nullptr),
+ pResolveAttachments(nullptr),
+ pDepthStencilAttachment(nullptr),
+ preserveAttachmentCount(in_struct->preserveAttachmentCount),
+ pPreserveAttachments(nullptr)
+{
+ if (in_struct->pInputAttachments) {
+ pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
+ memcpy ((void *)pInputAttachments, (void *)in_struct->pInputAttachments, sizeof(VkAttachmentReference)*in_struct->inputAttachmentCount);
+ }
+ if (in_struct->pColorAttachments) {
+ pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+ memcpy ((void *)pColorAttachments, (void *)in_struct->pColorAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
+ }
+ if (in_struct->pResolveAttachments) {
+ pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+ memcpy ((void *)pResolveAttachments, (void *)in_struct->pResolveAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
+ }
+ if (in_struct->pDepthStencilAttachment) {
+ pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
+ }
+ if (in_struct->pPreserveAttachments) {
+ pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+ memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
+ }
+}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription() :
+ pInputAttachments(nullptr),
+ pColorAttachments(nullptr),
+ pResolveAttachments(nullptr),
+ pDepthStencilAttachment(nullptr),
+ pPreserveAttachments(nullptr)
+{}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription(const safe_VkSubpassDescription& src)
+{
+ flags = src.flags;
+ pipelineBindPoint = src.pipelineBindPoint;
+ inputAttachmentCount = src.inputAttachmentCount;
+ pInputAttachments = nullptr;
+ colorAttachmentCount = src.colorAttachmentCount;
+ pColorAttachments = nullptr;
+ pResolveAttachments = nullptr;
+ pDepthStencilAttachment = nullptr;
+ preserveAttachmentCount = src.preserveAttachmentCount;
+ pPreserveAttachments = nullptr;
+ if (src.pInputAttachments) {
+ pInputAttachments = new VkAttachmentReference[src.inputAttachmentCount];
+ memcpy ((void *)pInputAttachments, (void *)src.pInputAttachments, sizeof(VkAttachmentReference)*src.inputAttachmentCount);
+ }
+ if (src.pColorAttachments) {
+ pColorAttachments = new VkAttachmentReference[src.colorAttachmentCount];
+ memcpy ((void *)pColorAttachments, (void *)src.pColorAttachments, sizeof(VkAttachmentReference)*src.colorAttachmentCount);
+ }
+ if (src.pResolveAttachments) {
+ pResolveAttachments = new VkAttachmentReference[src.colorAttachmentCount];
+ memcpy ((void *)pResolveAttachments, (void *)src.pResolveAttachments, sizeof(VkAttachmentReference)*src.colorAttachmentCount);
+ }
+ if (src.pDepthStencilAttachment) {
+ pDepthStencilAttachment = new VkAttachmentReference(*src.pDepthStencilAttachment);
+ }
+ if (src.pPreserveAttachments) {
+ pPreserveAttachments = new uint32_t[src.preserveAttachmentCount];
+ memcpy ((void *)pPreserveAttachments, (void *)src.pPreserveAttachments, sizeof(uint32_t)*src.preserveAttachmentCount);
+ }
+}
+
+safe_VkSubpassDescription::~safe_VkSubpassDescription()
+{
+ if (pInputAttachments)
+ delete[] pInputAttachments;
+ if (pColorAttachments)
+ delete[] pColorAttachments;
+ if (pResolveAttachments)
+ delete[] pResolveAttachments;
+ if (pDepthStencilAttachment)
+ delete pDepthStencilAttachment;
+ if (pPreserveAttachments)
+ delete[] pPreserveAttachments;
+}
+
+void safe_VkSubpassDescription::initialize(const VkSubpassDescription* in_struct)
+{
+ flags = in_struct->flags;
+ pipelineBindPoint = in_struct->pipelineBindPoint;
+ inputAttachmentCount = in_struct->inputAttachmentCount;
+ pInputAttachments = nullptr;
+ colorAttachmentCount = in_struct->colorAttachmentCount;
+ pColorAttachments = nullptr;
+ pResolveAttachments = nullptr;
+ pDepthStencilAttachment = nullptr;
+ preserveAttachmentCount = in_struct->preserveAttachmentCount;
+ pPreserveAttachments = nullptr;
+ if (in_struct->pInputAttachments) {
+ pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
+ memcpy ((void *)pInputAttachments, (void *)in_struct->pInputAttachments, sizeof(VkAttachmentReference)*in_struct->inputAttachmentCount);
+ }
+ if (in_struct->pColorAttachments) {
+ pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+ memcpy ((void *)pColorAttachments, (void *)in_struct->pColorAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
+ }
+ if (in_struct->pResolveAttachments) {
+ pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+ memcpy ((void *)pResolveAttachments, (void *)in_struct->pResolveAttachments, sizeof(VkAttachmentReference)*in_struct->colorAttachmentCount);
+ }
+ if (in_struct->pDepthStencilAttachment) {
+ pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
+ }
+ if (in_struct->pPreserveAttachments) {
+ pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+ memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
+ }
+}
+
+void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* src)
+{
+ flags = src->flags;
+ pipelineBindPoint = src->pipelineBindPoint;
+ inputAttachmentCount = src->inputAttachmentCount;
+ pInputAttachments = nullptr;
+ colorAttachmentCount = src->colorAttachmentCount;
+ pColorAttachments = nullptr;
+ pResolveAttachments = nullptr;
+ pDepthStencilAttachment = nullptr;
+ preserveAttachmentCount = src->preserveAttachmentCount;
+ pPreserveAttachments = nullptr;
+ if (src->pInputAttachments) {
+ pInputAttachments = new VkAttachmentReference[src->inputAttachmentCount];
+ memcpy ((void *)pInputAttachments, (void *)src->pInputAttachments, sizeof(VkAttachmentReference)*src->inputAttachmentCount);
+ }
+ if (src->pColorAttachments) {
+ pColorAttachments = new VkAttachmentReference[src->colorAttachmentCount];
+ memcpy ((void *)pColorAttachments, (void *)src->pColorAttachments, sizeof(VkAttachmentReference)*src->colorAttachmentCount);
+ }
+ if (src->pResolveAttachments) {
+ pResolveAttachments = new VkAttachmentReference[src->colorAttachmentCount];
+ memcpy ((void *)pResolveAttachments, (void *)src->pResolveAttachments, sizeof(VkAttachmentReference)*src->colorAttachmentCount);
+ }
+ if (src->pDepthStencilAttachment) {
+ pDepthStencilAttachment = new VkAttachmentReference(*src->pDepthStencilAttachment);
+ }
+ if (src->pPreserveAttachments) {
+ pPreserveAttachments = new uint32_t[src->preserveAttachmentCount];
+ memcpy ((void *)pPreserveAttachments, (void *)src->pPreserveAttachments, sizeof(uint32_t)*src->preserveAttachmentCount);
+ }
+}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ attachmentCount(in_struct->attachmentCount),
+ pAttachments(nullptr),
+ subpassCount(in_struct->subpassCount),
+ pSubpasses(nullptr),
+ dependencyCount(in_struct->dependencyCount),
+ pDependencies(nullptr)
+{
+ if (in_struct->pAttachments) {
+ pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
+ }
+ if (subpassCount && in_struct->pSubpasses) {
+ pSubpasses = new safe_VkSubpassDescription[subpassCount];
+ for (uint32_t i=0; i<subpassCount; ++i) {
+ pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+ }
+ }
+ if (in_struct->pDependencies) {
+ pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
+ memcpy ((void *)pDependencies, (void *)in_struct->pDependencies, sizeof(VkSubpassDependency)*in_struct->dependencyCount);
+ }
+}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo() :
+ pAttachments(nullptr),
+ pSubpasses(nullptr),
+ pDependencies(nullptr)
+{}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ attachmentCount = src.attachmentCount;
+ pAttachments = nullptr;
+ subpassCount = src.subpassCount;
+ pSubpasses = nullptr;
+ dependencyCount = src.dependencyCount;
+ pDependencies = nullptr;
+ if (src.pAttachments) {
+ pAttachments = new VkAttachmentDescription[src.attachmentCount];
+ memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkAttachmentDescription)*src.attachmentCount);
+ }
+ if (subpassCount && src.pSubpasses) {
+ pSubpasses = new safe_VkSubpassDescription[subpassCount];
+ for (uint32_t i=0; i<subpassCount; ++i) {
+ pSubpasses[i].initialize(&src.pSubpasses[i]);
+ }
+ }
+ if (src.pDependencies) {
+ pDependencies = new VkSubpassDependency[src.dependencyCount];
+ memcpy ((void *)pDependencies, (void *)src.pDependencies, sizeof(VkSubpassDependency)*src.dependencyCount);
+ }
+}
+
+safe_VkRenderPassCreateInfo::~safe_VkRenderPassCreateInfo()
+{
+ if (pAttachments)
+ delete[] pAttachments;
+ if (pSubpasses)
+ delete[] pSubpasses;
+ if (pDependencies)
+ delete[] pDependencies;
+}
+
+void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ attachmentCount = in_struct->attachmentCount;
+ pAttachments = nullptr;
+ subpassCount = in_struct->subpassCount;
+ pSubpasses = nullptr;
+ dependencyCount = in_struct->dependencyCount;
+ pDependencies = nullptr;
+ if (in_struct->pAttachments) {
+ pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
+ }
+ if (subpassCount && in_struct->pSubpasses) {
+ pSubpasses = new safe_VkSubpassDescription[subpassCount];
+ for (uint32_t i=0; i<subpassCount; ++i) {
+ pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+ }
+ }
+ if (in_struct->pDependencies) {
+ pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
+ memcpy ((void *)pDependencies, (void *)in_struct->pDependencies, sizeof(VkSubpassDependency)*in_struct->dependencyCount);
+ }
+}
+
+void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ attachmentCount = src->attachmentCount;
+ pAttachments = nullptr;
+ subpassCount = src->subpassCount;
+ pSubpasses = nullptr;
+ dependencyCount = src->dependencyCount;
+ pDependencies = nullptr;
+ if (src->pAttachments) {
+ pAttachments = new VkAttachmentDescription[src->attachmentCount];
+ memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkAttachmentDescription)*src->attachmentCount);
+ }
+ if (subpassCount && src->pSubpasses) {
+ pSubpasses = new safe_VkSubpassDescription[subpassCount];
+ for (uint32_t i=0; i<subpassCount; ++i) {
+ pSubpasses[i].initialize(&src->pSubpasses[i]);
+ }
+ }
+ if (src->pDependencies) {
+ pDependencies = new VkSubpassDependency[src->dependencyCount];
+ memcpy ((void *)pDependencies, (void *)src->pDependencies, sizeof(VkSubpassDependency)*src->dependencyCount);
+ }
+}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ queueFamilyIndex(in_struct->queueFamilyIndex)
+{
+}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo()
+{}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ queueFamilyIndex = src.queueFamilyIndex;
+}
+
+safe_VkCommandPoolCreateInfo::~safe_VkCommandPoolCreateInfo()
+{
+}
+
+void safe_VkCommandPoolCreateInfo::initialize(const VkCommandPoolCreateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ queueFamilyIndex = in_struct->queueFamilyIndex;
+}
+
+void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ queueFamilyIndex = src->queueFamilyIndex;
+}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ commandPool(in_struct->commandPool),
+ level(in_struct->level),
+ commandBufferCount(in_struct->commandBufferCount)
+{
+}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo()
+{}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ commandPool = src.commandPool;
+ level = src.level;
+ commandBufferCount = src.commandBufferCount;
+}
+
+safe_VkCommandBufferAllocateInfo::~safe_VkCommandBufferAllocateInfo()
+{
+}
+
+void safe_VkCommandBufferAllocateInfo::initialize(const VkCommandBufferAllocateInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ commandPool = in_struct->commandPool;
+ level = in_struct->level;
+ commandBufferCount = in_struct->commandBufferCount;
+}
+
+void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ commandPool = src->commandPool;
+ level = src->level;
+ commandBufferCount = src->commandBufferCount;
+}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ renderPass(in_struct->renderPass),
+ subpass(in_struct->subpass),
+ framebuffer(in_struct->framebuffer),
+ occlusionQueryEnable(in_struct->occlusionQueryEnable),
+ queryFlags(in_struct->queryFlags),
+ pipelineStatistics(in_struct->pipelineStatistics)
+{
+}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo()
+{}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ renderPass = src.renderPass;
+ subpass = src.subpass;
+ framebuffer = src.framebuffer;
+ occlusionQueryEnable = src.occlusionQueryEnable;
+ queryFlags = src.queryFlags;
+ pipelineStatistics = src.pipelineStatistics;
+}
+
+safe_VkCommandBufferInheritanceInfo::~safe_VkCommandBufferInheritanceInfo()
+{
+}
+
+void safe_VkCommandBufferInheritanceInfo::initialize(const VkCommandBufferInheritanceInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ renderPass = in_struct->renderPass;
+ subpass = in_struct->subpass;
+ framebuffer = in_struct->framebuffer;
+ occlusionQueryEnable = in_struct->occlusionQueryEnable;
+ queryFlags = in_struct->queryFlags;
+ pipelineStatistics = in_struct->pipelineStatistics;
+}
+
+void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ renderPass = src->renderPass;
+ subpass = src->subpass;
+ framebuffer = src->framebuffer;
+ occlusionQueryEnable = src->occlusionQueryEnable;
+ queryFlags = src->queryFlags;
+ pipelineStatistics = src->pipelineStatistics;
+}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags)
+{
+ if (in_struct->pInheritanceInfo)
+ pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+ else
+ pInheritanceInfo = NULL;
+}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo()
+{}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ if (src.pInheritanceInfo)
+ pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src.pInheritanceInfo);
+ else
+ pInheritanceInfo = NULL;
+}
+
+safe_VkCommandBufferBeginInfo::~safe_VkCommandBufferBeginInfo()
+{
+ if (pInheritanceInfo)
+ delete pInheritanceInfo;
+}
+
+void safe_VkCommandBufferBeginInfo::initialize(const VkCommandBufferBeginInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ if (in_struct->pInheritanceInfo)
+ pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+ else
+ pInheritanceInfo = NULL;
+}
+
+void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ if (src->pInheritanceInfo)
+ pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src->pInheritanceInfo);
+ else
+ pInheritanceInfo = NULL;
+}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcAccessMask(in_struct->srcAccessMask),
+ dstAccessMask(in_struct->dstAccessMask)
+{
+}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier()
+{}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcAccessMask = src.srcAccessMask;
+ dstAccessMask = src.dstAccessMask;
+}
+
+safe_VkMemoryBarrier::~safe_VkMemoryBarrier()
+{
+}
+
+void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcAccessMask = in_struct->srcAccessMask;
+ dstAccessMask = in_struct->dstAccessMask;
+}
+
+void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcAccessMask = src->srcAccessMask;
+ dstAccessMask = src->dstAccessMask;
+}
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcAccessMask(in_struct->srcAccessMask),
+ dstAccessMask(in_struct->dstAccessMask),
+ srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+ dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+ buffer(in_struct->buffer),
+ offset(in_struct->offset),
+ size(in_struct->size)
+{
+}
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier()
+{}
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcAccessMask = src.srcAccessMask;
+ dstAccessMask = src.dstAccessMask;
+ srcQueueFamilyIndex = src.srcQueueFamilyIndex;
+ dstQueueFamilyIndex = src.dstQueueFamilyIndex;
+ buffer = src.buffer;
+ offset = src.offset;
+ size = src.size;
+}
+
+safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier()
+{
+}
+
+void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcAccessMask = in_struct->srcAccessMask;
+ dstAccessMask = in_struct->dstAccessMask;
+ srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+ dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+ buffer = in_struct->buffer;
+ offset = in_struct->offset;
+ size = in_struct->size;
+}
+
+void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcAccessMask = src->srcAccessMask;
+ dstAccessMask = src->dstAccessMask;
+ srcQueueFamilyIndex = src->srcQueueFamilyIndex;
+ dstQueueFamilyIndex = src->dstQueueFamilyIndex;
+ buffer = src->buffer;
+ offset = src->offset;
+ size = src->size;
+}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcAccessMask(in_struct->srcAccessMask),
+ dstAccessMask(in_struct->dstAccessMask),
+ oldLayout(in_struct->oldLayout),
+ newLayout(in_struct->newLayout),
+ srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+ dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+ image(in_struct->image),
+ subresourceRange(in_struct->subresourceRange)
+{
+}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier()
+{}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcAccessMask = src.srcAccessMask;
+ dstAccessMask = src.dstAccessMask;
+ oldLayout = src.oldLayout;
+ newLayout = src.newLayout;
+ srcQueueFamilyIndex = src.srcQueueFamilyIndex;
+ dstQueueFamilyIndex = src.dstQueueFamilyIndex;
+ image = src.image;
+ subresourceRange = src.subresourceRange;
+}
+
+safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier()
+{
+}
+
+void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcAccessMask = in_struct->srcAccessMask;
+ dstAccessMask = in_struct->dstAccessMask;
+ oldLayout = in_struct->oldLayout;
+ newLayout = in_struct->newLayout;
+ srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+ dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+ image = in_struct->image;
+ subresourceRange = in_struct->subresourceRange;
+}
+
+void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcAccessMask = src->srcAccessMask;
+ dstAccessMask = src->dstAccessMask;
+ oldLayout = src->oldLayout;
+ newLayout = src->newLayout;
+ srcQueueFamilyIndex = src->srcQueueFamilyIndex;
+ dstQueueFamilyIndex = src->dstQueueFamilyIndex;
+ image = src->image;
+ subresourceRange = src->subresourceRange;
+}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ renderPass(in_struct->renderPass),
+ framebuffer(in_struct->framebuffer),
+ renderArea(in_struct->renderArea),
+ clearValueCount(in_struct->clearValueCount),
+ pClearValues(nullptr)
+{
+ if (in_struct->pClearValues) {
+ pClearValues = new VkClearValue[in_struct->clearValueCount];
+ memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
+ }
+}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo() :
+ pClearValues(nullptr)
+{}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ renderPass = src.renderPass;
+ framebuffer = src.framebuffer;
+ renderArea = src.renderArea;
+ clearValueCount = src.clearValueCount;
+ pClearValues = nullptr;
+ if (src.pClearValues) {
+ pClearValues = new VkClearValue[src.clearValueCount];
+ memcpy ((void *)pClearValues, (void *)src.pClearValues, sizeof(VkClearValue)*src.clearValueCount);
+ }
+}
+
+safe_VkRenderPassBeginInfo::~safe_VkRenderPassBeginInfo()
+{
+ if (pClearValues)
+ delete[] pClearValues;
+}
+
+void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ renderPass = in_struct->renderPass;
+ framebuffer = in_struct->framebuffer;
+ renderArea = in_struct->renderArea;
+ clearValueCount = in_struct->clearValueCount;
+ pClearValues = nullptr;
+ if (in_struct->pClearValues) {
+ pClearValues = new VkClearValue[in_struct->clearValueCount];
+ memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
+ }
+}
+
+void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ renderPass = src->renderPass;
+ framebuffer = src->framebuffer;
+ renderArea = src->renderArea;
+ clearValueCount = src->clearValueCount;
+ pClearValues = nullptr;
+ if (src->pClearValues) {
+ pClearValues = new VkClearValue[src->clearValueCount];
+ memcpy ((void *)pClearValues, (void *)src->pClearValues, sizeof(VkClearValue)*src->clearValueCount);
+ }
+}
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ surface(in_struct->surface),
+ minImageCount(in_struct->minImageCount),
+ imageFormat(in_struct->imageFormat),
+ imageColorSpace(in_struct->imageColorSpace),
+ imageExtent(in_struct->imageExtent),
+ imageArrayLayers(in_struct->imageArrayLayers),
+ imageUsage(in_struct->imageUsage),
+ imageSharingMode(in_struct->imageSharingMode),
+ queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
+ pQueueFamilyIndices(nullptr),
+ preTransform(in_struct->preTransform),
+ compositeAlpha(in_struct->compositeAlpha),
+ presentMode(in_struct->presentMode),
+ clipped(in_struct->clipped),
+ oldSwapchain(in_struct->oldSwapchain)
+{
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR() :
+ pQueueFamilyIndices(nullptr)
+{}
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ surface = src.surface;
+ minImageCount = src.minImageCount;
+ imageFormat = src.imageFormat;
+ imageColorSpace = src.imageColorSpace;
+ imageExtent = src.imageExtent;
+ imageArrayLayers = src.imageArrayLayers;
+ imageUsage = src.imageUsage;
+ imageSharingMode = src.imageSharingMode;
+ queueFamilyIndexCount = src.queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ preTransform = src.preTransform;
+ compositeAlpha = src.compositeAlpha;
+ presentMode = src.presentMode;
+ clipped = src.clipped;
+ oldSwapchain = src.oldSwapchain;
+ if (src.pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
+ }
+}
+
+safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR()
+{
+ if (pQueueFamilyIndices)
+ delete[] pQueueFamilyIndices;
+}
+
+void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ surface = in_struct->surface;
+ minImageCount = in_struct->minImageCount;
+ imageFormat = in_struct->imageFormat;
+ imageColorSpace = in_struct->imageColorSpace;
+ imageExtent = in_struct->imageExtent;
+ imageArrayLayers = in_struct->imageArrayLayers;
+ imageUsage = in_struct->imageUsage;
+ imageSharingMode = in_struct->imageSharingMode;
+ queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ preTransform = in_struct->preTransform;
+ compositeAlpha = in_struct->compositeAlpha;
+ presentMode = in_struct->presentMode;
+ clipped = in_struct->clipped;
+ oldSwapchain = in_struct->oldSwapchain;
+ if (in_struct->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
+ }
+}
+
+void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ surface = src->surface;
+ minImageCount = src->minImageCount;
+ imageFormat = src->imageFormat;
+ imageColorSpace = src->imageColorSpace;
+ imageExtent = src->imageExtent;
+ imageArrayLayers = src->imageArrayLayers;
+ imageUsage = src->imageUsage;
+ imageSharingMode = src->imageSharingMode;
+ queueFamilyIndexCount = src->queueFamilyIndexCount;
+ pQueueFamilyIndices = nullptr;
+ preTransform = src->preTransform;
+ compositeAlpha = src->compositeAlpha;
+ presentMode = src->presentMode;
+ clipped = src->clipped;
+ oldSwapchain = src->oldSwapchain;
+ if (src->pQueueFamilyIndices) {
+ pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
+ memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
+ }
+}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ waitSemaphoreCount(in_struct->waitSemaphoreCount),
+ pWaitSemaphores(nullptr),
+ swapchainCount(in_struct->swapchainCount),
+ pSwapchains(nullptr),
+ pImageIndices(nullptr),
+ pResults(nullptr)
+{
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (swapchainCount && in_struct->pSwapchains) {
+ pSwapchains = new VkSwapchainKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pSwapchains[i] = in_struct->pSwapchains[i];
+ }
+ }
+ if (in_struct->pImageIndices) {
+ pImageIndices = new uint32_t[in_struct->swapchainCount];
+ memcpy ((void *)pImageIndices, (void *)in_struct->pImageIndices, sizeof(uint32_t)*in_struct->swapchainCount);
+ }
+ if (in_struct->pResults) {
+ pResults = new VkResult[in_struct->swapchainCount];
+ memcpy ((void *)pResults, (void *)in_struct->pResults, sizeof(VkResult)*in_struct->swapchainCount);
+ }
+}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR() :
+ pWaitSemaphores(nullptr),
+ pSwapchains(nullptr),
+ pImageIndices(nullptr),
+ pResults(nullptr)
+{}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ waitSemaphoreCount = src.waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ swapchainCount = src.swapchainCount;
+ pSwapchains = nullptr;
+ pImageIndices = nullptr;
+ pResults = nullptr;
+ if (waitSemaphoreCount && src.pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src.pWaitSemaphores[i];
+ }
+ }
+ if (swapchainCount && src.pSwapchains) {
+ pSwapchains = new VkSwapchainKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pSwapchains[i] = src.pSwapchains[i];
+ }
+ }
+ if (src.pImageIndices) {
+ pImageIndices = new uint32_t[src.swapchainCount];
+ memcpy ((void *)pImageIndices, (void *)src.pImageIndices, sizeof(uint32_t)*src.swapchainCount);
+ }
+ if (src.pResults) {
+ pResults = new VkResult[src.swapchainCount];
+ memcpy ((void *)pResults, (void *)src.pResults, sizeof(VkResult)*src.swapchainCount);
+ }
+}
+
+safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR()
+{
+ if (pWaitSemaphores)
+ delete[] pWaitSemaphores;
+ if (pSwapchains)
+ delete[] pSwapchains;
+ if (pImageIndices)
+ delete[] pImageIndices;
+ if (pResults)
+ delete[] pResults;
+}
+
+void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ waitSemaphoreCount = in_struct->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ swapchainCount = in_struct->swapchainCount;
+ pSwapchains = nullptr;
+ pImageIndices = nullptr;
+ pResults = nullptr;
+ if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+ }
+ }
+ if (swapchainCount && in_struct->pSwapchains) {
+ pSwapchains = new VkSwapchainKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pSwapchains[i] = in_struct->pSwapchains[i];
+ }
+ }
+ if (in_struct->pImageIndices) {
+ pImageIndices = new uint32_t[in_struct->swapchainCount];
+ memcpy ((void *)pImageIndices, (void *)in_struct->pImageIndices, sizeof(uint32_t)*in_struct->swapchainCount);
+ }
+ if (in_struct->pResults) {
+ pResults = new VkResult[in_struct->swapchainCount];
+ memcpy ((void *)pResults, (void *)in_struct->pResults, sizeof(VkResult)*in_struct->swapchainCount);
+ }
+}
+
+void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ waitSemaphoreCount = src->waitSemaphoreCount;
+ pWaitSemaphores = nullptr;
+ swapchainCount = src->swapchainCount;
+ pSwapchains = nullptr;
+ pImageIndices = nullptr;
+ pResults = nullptr;
+ if (waitSemaphoreCount && src->pWaitSemaphores) {
+ pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+ for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+ pWaitSemaphores[i] = src->pWaitSemaphores[i];
+ }
+ }
+ if (swapchainCount && src->pSwapchains) {
+ pSwapchains = new VkSwapchainKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pSwapchains[i] = src->pSwapchains[i];
+ }
+ }
+ if (src->pImageIndices) {
+ pImageIndices = new uint32_t[src->swapchainCount];
+ memcpy ((void *)pImageIndices, (void *)src->pImageIndices, sizeof(uint32_t)*src->swapchainCount);
+ }
+ if (src->pResults) {
+ pResults = new VkResult[src->swapchainCount];
+ memcpy ((void *)pResults, (void *)src->pResults, sizeof(VkResult)*src->swapchainCount);
+ }
+}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct) :
+ display(in_struct->display),
+ displayName(in_struct->displayName),
+ physicalDimensions(in_struct->physicalDimensions),
+ physicalResolution(in_struct->physicalResolution),
+ supportedTransforms(in_struct->supportedTransforms),
+ planeReorderPossible(in_struct->planeReorderPossible),
+ persistentContent(in_struct->persistentContent)
+{
+}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR()
+{}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src)
+{
+ display = src.display;
+ displayName = src.displayName;
+ physicalDimensions = src.physicalDimensions;
+ physicalResolution = src.physicalResolution;
+ supportedTransforms = src.supportedTransforms;
+ planeReorderPossible = src.planeReorderPossible;
+ persistentContent = src.persistentContent;
+}
+
+safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR()
+{
+}
+
+void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct)
+{
+ display = in_struct->display;
+ displayName = in_struct->displayName;
+ physicalDimensions = in_struct->physicalDimensions;
+ physicalResolution = in_struct->physicalResolution;
+ supportedTransforms = in_struct->supportedTransforms;
+ planeReorderPossible = in_struct->planeReorderPossible;
+ persistentContent = in_struct->persistentContent;
+}
+
+void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* src)
+{
+ display = src->display;
+ displayName = src->displayName;
+ physicalDimensions = src->physicalDimensions;
+ physicalResolution = src->physicalResolution;
+ supportedTransforms = src->supportedTransforms;
+ planeReorderPossible = src->planeReorderPossible;
+ persistentContent = src->persistentContent;
+}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ parameters(in_struct->parameters)
+{
+}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR()
+{}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ parameters = src.parameters;
+}
+
+safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR()
+{
+}
+
+void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ parameters = in_struct->parameters;
+}
+
+void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ parameters = src->parameters;
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ displayMode(in_struct->displayMode),
+ planeIndex(in_struct->planeIndex),
+ planeStackIndex(in_struct->planeStackIndex),
+ transform(in_struct->transform),
+ globalAlpha(in_struct->globalAlpha),
+ alphaMode(in_struct->alphaMode),
+ imageExtent(in_struct->imageExtent)
+{
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR()
+{}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ displayMode = src.displayMode;
+ planeIndex = src.planeIndex;
+ planeStackIndex = src.planeStackIndex;
+ transform = src.transform;
+ globalAlpha = src.globalAlpha;
+ alphaMode = src.alphaMode;
+ imageExtent = src.imageExtent;
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR()
+{
+}
+
+void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ displayMode = in_struct->displayMode;
+ planeIndex = in_struct->planeIndex;
+ planeStackIndex = in_struct->planeStackIndex;
+ transform = in_struct->transform;
+ globalAlpha = in_struct->globalAlpha;
+ alphaMode = in_struct->alphaMode;
+ imageExtent = in_struct->imageExtent;
+}
+
+void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ displayMode = src->displayMode;
+ planeIndex = src->planeIndex;
+ planeStackIndex = src->planeStackIndex;
+ transform = src->transform;
+ globalAlpha = src->globalAlpha;
+ alphaMode = src->alphaMode;
+ imageExtent = src->imageExtent;
+}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcRect(in_struct->srcRect),
+ dstRect(in_struct->dstRect),
+ persistent(in_struct->persistent)
+{
+}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR()
+{}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcRect = src.srcRect;
+ dstRect = src.dstRect;
+ persistent = src.persistent;
+}
+
+safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR()
+{
+}
+
+void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcRect = in_struct->srcRect;
+ dstRect = in_struct->dstRect;
+ persistent = in_struct->persistent;
+}
+
+void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcRect = src->srcRect;
+ dstRect = src->dstRect;
+ persistent = src->persistent;
+}
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+
+
+safe_VkMagmaSurfaceCreateInfoKHR::safe_VkMagmaSurfaceCreateInfoKHR(const VkMagmaSurfaceCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ imagePipeHandle(in_struct->imagePipeHandle),
+ width(in_struct->width),
+ height(in_struct->height)
+{
+}
+
+safe_VkMagmaSurfaceCreateInfoKHR::safe_VkMagmaSurfaceCreateInfoKHR()
+{}
+
+safe_VkMagmaSurfaceCreateInfoKHR::safe_VkMagmaSurfaceCreateInfoKHR(const safe_VkMagmaSurfaceCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ imagePipeHandle = src.imagePipeHandle;
+ width = src.width;
+ height = src.height;
+}
+
+safe_VkMagmaSurfaceCreateInfoKHR::~safe_VkMagmaSurfaceCreateInfoKHR()
+{
+}
+
+void safe_VkMagmaSurfaceCreateInfoKHR::initialize(const VkMagmaSurfaceCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ imagePipeHandle = in_struct->imagePipeHandle;
+ width = in_struct->width;
+ height = in_struct->height;
+}
+
+void safe_VkMagmaSurfaceCreateInfoKHR::initialize(const safe_VkMagmaSurfaceCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ imagePipeHandle = src->imagePipeHandle;
+ width = src->width;
+ height = src->height;
+}
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+
+safe_VkPhysicalDeviceFeatures2KHR::safe_VkPhysicalDeviceFeatures2KHR(const VkPhysicalDeviceFeatures2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ features(in_struct->features)
+{
+}
+
+safe_VkPhysicalDeviceFeatures2KHR::safe_VkPhysicalDeviceFeatures2KHR()
+{}
+
+safe_VkPhysicalDeviceFeatures2KHR::safe_VkPhysicalDeviceFeatures2KHR(const safe_VkPhysicalDeviceFeatures2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ features = src.features;
+}
+
+safe_VkPhysicalDeviceFeatures2KHR::~safe_VkPhysicalDeviceFeatures2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceFeatures2KHR::initialize(const VkPhysicalDeviceFeatures2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ features = in_struct->features;
+}
+
+void safe_VkPhysicalDeviceFeatures2KHR::initialize(const safe_VkPhysicalDeviceFeatures2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ features = src->features;
+}
+
+safe_VkPhysicalDeviceProperties2KHR::safe_VkPhysicalDeviceProperties2KHR(const VkPhysicalDeviceProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ properties(in_struct->properties)
+{
+}
+
+safe_VkPhysicalDeviceProperties2KHR::safe_VkPhysicalDeviceProperties2KHR()
+{}
+
+safe_VkPhysicalDeviceProperties2KHR::safe_VkPhysicalDeviceProperties2KHR(const safe_VkPhysicalDeviceProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ properties = src.properties;
+}
+
+safe_VkPhysicalDeviceProperties2KHR::~safe_VkPhysicalDeviceProperties2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceProperties2KHR::initialize(const VkPhysicalDeviceProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ properties = in_struct->properties;
+}
+
+void safe_VkPhysicalDeviceProperties2KHR::initialize(const safe_VkPhysicalDeviceProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ properties = src->properties;
+}
+
+safe_VkFormatProperties2KHR::safe_VkFormatProperties2KHR(const VkFormatProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ formatProperties(in_struct->formatProperties)
+{
+}
+
+safe_VkFormatProperties2KHR::safe_VkFormatProperties2KHR()
+{}
+
+safe_VkFormatProperties2KHR::safe_VkFormatProperties2KHR(const safe_VkFormatProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ formatProperties = src.formatProperties;
+}
+
+safe_VkFormatProperties2KHR::~safe_VkFormatProperties2KHR()
+{
+}
+
+void safe_VkFormatProperties2KHR::initialize(const VkFormatProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ formatProperties = in_struct->formatProperties;
+}
+
+void safe_VkFormatProperties2KHR::initialize(const safe_VkFormatProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ formatProperties = src->formatProperties;
+}
+
+safe_VkImageFormatProperties2KHR::safe_VkImageFormatProperties2KHR(const VkImageFormatProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ imageFormatProperties(in_struct->imageFormatProperties)
+{
+}
+
+safe_VkImageFormatProperties2KHR::safe_VkImageFormatProperties2KHR()
+{}
+
+safe_VkImageFormatProperties2KHR::safe_VkImageFormatProperties2KHR(const safe_VkImageFormatProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ imageFormatProperties = src.imageFormatProperties;
+}
+
+safe_VkImageFormatProperties2KHR::~safe_VkImageFormatProperties2KHR()
+{
+}
+
+void safe_VkImageFormatProperties2KHR::initialize(const VkImageFormatProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ imageFormatProperties = in_struct->imageFormatProperties;
+}
+
+void safe_VkImageFormatProperties2KHR::initialize(const safe_VkImageFormatProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ imageFormatProperties = src->imageFormatProperties;
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2KHR::safe_VkPhysicalDeviceImageFormatInfo2KHR(const VkPhysicalDeviceImageFormatInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ format(in_struct->format),
+ type(in_struct->type),
+ tiling(in_struct->tiling),
+ usage(in_struct->usage),
+ flags(in_struct->flags)
+{
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2KHR::safe_VkPhysicalDeviceImageFormatInfo2KHR()
+{}
+
+safe_VkPhysicalDeviceImageFormatInfo2KHR::safe_VkPhysicalDeviceImageFormatInfo2KHR(const safe_VkPhysicalDeviceImageFormatInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ format = src.format;
+ type = src.type;
+ tiling = src.tiling;
+ usage = src.usage;
+ flags = src.flags;
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2KHR::~safe_VkPhysicalDeviceImageFormatInfo2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceImageFormatInfo2KHR::initialize(const VkPhysicalDeviceImageFormatInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ format = in_struct->format;
+ type = in_struct->type;
+ tiling = in_struct->tiling;
+ usage = in_struct->usage;
+ flags = in_struct->flags;
+}
+
+void safe_VkPhysicalDeviceImageFormatInfo2KHR::initialize(const safe_VkPhysicalDeviceImageFormatInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ format = src->format;
+ type = src->type;
+ tiling = src->tiling;
+ usage = src->usage;
+ flags = src->flags;
+}
+
+safe_VkQueueFamilyProperties2KHR::safe_VkQueueFamilyProperties2KHR(const VkQueueFamilyProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ queueFamilyProperties(in_struct->queueFamilyProperties)
+{
+}
+
+safe_VkQueueFamilyProperties2KHR::safe_VkQueueFamilyProperties2KHR()
+{}
+
+safe_VkQueueFamilyProperties2KHR::safe_VkQueueFamilyProperties2KHR(const safe_VkQueueFamilyProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ queueFamilyProperties = src.queueFamilyProperties;
+}
+
+safe_VkQueueFamilyProperties2KHR::~safe_VkQueueFamilyProperties2KHR()
+{
+}
+
+void safe_VkQueueFamilyProperties2KHR::initialize(const VkQueueFamilyProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ queueFamilyProperties = in_struct->queueFamilyProperties;
+}
+
+void safe_VkQueueFamilyProperties2KHR::initialize(const safe_VkQueueFamilyProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ queueFamilyProperties = src->queueFamilyProperties;
+}
+
+safe_VkPhysicalDeviceMemoryProperties2KHR::safe_VkPhysicalDeviceMemoryProperties2KHR(const VkPhysicalDeviceMemoryProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryProperties(in_struct->memoryProperties)
+{
+}
+
+safe_VkPhysicalDeviceMemoryProperties2KHR::safe_VkPhysicalDeviceMemoryProperties2KHR()
+{}
+
+safe_VkPhysicalDeviceMemoryProperties2KHR::safe_VkPhysicalDeviceMemoryProperties2KHR(const safe_VkPhysicalDeviceMemoryProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryProperties = src.memoryProperties;
+}
+
+safe_VkPhysicalDeviceMemoryProperties2KHR::~safe_VkPhysicalDeviceMemoryProperties2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceMemoryProperties2KHR::initialize(const VkPhysicalDeviceMemoryProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryProperties = in_struct->memoryProperties;
+}
+
+void safe_VkPhysicalDeviceMemoryProperties2KHR::initialize(const safe_VkPhysicalDeviceMemoryProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryProperties = src->memoryProperties;
+}
+
+safe_VkSparseImageFormatProperties2KHR::safe_VkSparseImageFormatProperties2KHR(const VkSparseImageFormatProperties2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ properties(in_struct->properties)
+{
+}
+
+safe_VkSparseImageFormatProperties2KHR::safe_VkSparseImageFormatProperties2KHR()
+{}
+
+safe_VkSparseImageFormatProperties2KHR::safe_VkSparseImageFormatProperties2KHR(const safe_VkSparseImageFormatProperties2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ properties = src.properties;
+}
+
+safe_VkSparseImageFormatProperties2KHR::~safe_VkSparseImageFormatProperties2KHR()
+{
+}
+
+void safe_VkSparseImageFormatProperties2KHR::initialize(const VkSparseImageFormatProperties2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ properties = in_struct->properties;
+}
+
+void safe_VkSparseImageFormatProperties2KHR::initialize(const safe_VkSparseImageFormatProperties2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ properties = src->properties;
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::safe_VkPhysicalDeviceSparseImageFormatInfo2KHR(const VkPhysicalDeviceSparseImageFormatInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ format(in_struct->format),
+ type(in_struct->type),
+ samples(in_struct->samples),
+ usage(in_struct->usage),
+ tiling(in_struct->tiling)
+{
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::safe_VkPhysicalDeviceSparseImageFormatInfo2KHR()
+{}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::safe_VkPhysicalDeviceSparseImageFormatInfo2KHR(const safe_VkPhysicalDeviceSparseImageFormatInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ format = src.format;
+ type = src.type;
+ samples = src.samples;
+ usage = src.usage;
+ tiling = src.tiling;
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::~safe_VkPhysicalDeviceSparseImageFormatInfo2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::initialize(const VkPhysicalDeviceSparseImageFormatInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ format = in_struct->format;
+ type = in_struct->type;
+ samples = in_struct->samples;
+ usage = in_struct->usage;
+ tiling = in_struct->tiling;
+}
+
+void safe_VkPhysicalDeviceSparseImageFormatInfo2KHR::initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ format = src->format;
+ type = src->type;
+ samples = src->samples;
+ usage = src->usage;
+ tiling = src->tiling;
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfoKHR::safe_VkPhysicalDeviceExternalImageFormatInfoKHR(const VkPhysicalDeviceExternalImageFormatInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfoKHR::safe_VkPhysicalDeviceExternalImageFormatInfoKHR()
+{}
+
+safe_VkPhysicalDeviceExternalImageFormatInfoKHR::safe_VkPhysicalDeviceExternalImageFormatInfoKHR(const safe_VkPhysicalDeviceExternalImageFormatInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfoKHR::~safe_VkPhysicalDeviceExternalImageFormatInfoKHR()
+{
+}
+
+void safe_VkPhysicalDeviceExternalImageFormatInfoKHR::initialize(const VkPhysicalDeviceExternalImageFormatInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkPhysicalDeviceExternalImageFormatInfoKHR::initialize(const safe_VkPhysicalDeviceExternalImageFormatInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+}
+
+safe_VkExternalImageFormatPropertiesKHR::safe_VkExternalImageFormatPropertiesKHR(const VkExternalImageFormatPropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ externalMemoryProperties(in_struct->externalMemoryProperties)
+{
+}
+
+safe_VkExternalImageFormatPropertiesKHR::safe_VkExternalImageFormatPropertiesKHR()
+{}
+
+safe_VkExternalImageFormatPropertiesKHR::safe_VkExternalImageFormatPropertiesKHR(const safe_VkExternalImageFormatPropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ externalMemoryProperties = src.externalMemoryProperties;
+}
+
+safe_VkExternalImageFormatPropertiesKHR::~safe_VkExternalImageFormatPropertiesKHR()
+{
+}
+
+void safe_VkExternalImageFormatPropertiesKHR::initialize(const VkExternalImageFormatPropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ externalMemoryProperties = in_struct->externalMemoryProperties;
+}
+
+void safe_VkExternalImageFormatPropertiesKHR::initialize(const safe_VkExternalImageFormatPropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ externalMemoryProperties = src->externalMemoryProperties;
+}
+
+safe_VkPhysicalDeviceExternalBufferInfoKHR::safe_VkPhysicalDeviceExternalBufferInfoKHR(const VkPhysicalDeviceExternalBufferInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ usage(in_struct->usage),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkPhysicalDeviceExternalBufferInfoKHR::safe_VkPhysicalDeviceExternalBufferInfoKHR()
+{}
+
+safe_VkPhysicalDeviceExternalBufferInfoKHR::safe_VkPhysicalDeviceExternalBufferInfoKHR(const safe_VkPhysicalDeviceExternalBufferInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ usage = src.usage;
+ handleType = src.handleType;
+}
+
+safe_VkPhysicalDeviceExternalBufferInfoKHR::~safe_VkPhysicalDeviceExternalBufferInfoKHR()
+{
+}
+
+void safe_VkPhysicalDeviceExternalBufferInfoKHR::initialize(const VkPhysicalDeviceExternalBufferInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ usage = in_struct->usage;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkPhysicalDeviceExternalBufferInfoKHR::initialize(const safe_VkPhysicalDeviceExternalBufferInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ usage = src->usage;
+ handleType = src->handleType;
+}
+
+safe_VkExternalBufferPropertiesKHR::safe_VkExternalBufferPropertiesKHR(const VkExternalBufferPropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ externalMemoryProperties(in_struct->externalMemoryProperties)
+{
+}
+
+safe_VkExternalBufferPropertiesKHR::safe_VkExternalBufferPropertiesKHR()
+{}
+
+safe_VkExternalBufferPropertiesKHR::safe_VkExternalBufferPropertiesKHR(const safe_VkExternalBufferPropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ externalMemoryProperties = src.externalMemoryProperties;
+}
+
+safe_VkExternalBufferPropertiesKHR::~safe_VkExternalBufferPropertiesKHR()
+{
+}
+
+void safe_VkExternalBufferPropertiesKHR::initialize(const VkExternalBufferPropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ externalMemoryProperties = in_struct->externalMemoryProperties;
+}
+
+void safe_VkExternalBufferPropertiesKHR::initialize(const safe_VkExternalBufferPropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ externalMemoryProperties = src->externalMemoryProperties;
+}
+
+safe_VkPhysicalDeviceIDPropertiesKHR::safe_VkPhysicalDeviceIDPropertiesKHR(const VkPhysicalDeviceIDPropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ deviceNodeMask(in_struct->deviceNodeMask),
+ deviceLUIDValid(in_struct->deviceLUIDValid)
+{
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ deviceUUID[i] = in_struct->deviceUUID[i];
+ }
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ driverUUID[i] = in_struct->driverUUID[i];
+ }
+ for (uint32_t i=0; i<VK_LUID_SIZE_KHR; ++i) {
+ deviceLUID[i] = in_struct->deviceLUID[i];
+ }
+}
+
+safe_VkPhysicalDeviceIDPropertiesKHR::safe_VkPhysicalDeviceIDPropertiesKHR()
+{}
+
+safe_VkPhysicalDeviceIDPropertiesKHR::safe_VkPhysicalDeviceIDPropertiesKHR(const safe_VkPhysicalDeviceIDPropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ deviceNodeMask = src.deviceNodeMask;
+ deviceLUIDValid = src.deviceLUIDValid;
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ deviceUUID[i] = src.deviceUUID[i];
+ }
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ driverUUID[i] = src.driverUUID[i];
+ }
+ for (uint32_t i=0; i<VK_LUID_SIZE_KHR; ++i) {
+ deviceLUID[i] = src.deviceLUID[i];
+ }
+}
+
+safe_VkPhysicalDeviceIDPropertiesKHR::~safe_VkPhysicalDeviceIDPropertiesKHR()
+{
+}
+
+void safe_VkPhysicalDeviceIDPropertiesKHR::initialize(const VkPhysicalDeviceIDPropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ deviceNodeMask = in_struct->deviceNodeMask;
+ deviceLUIDValid = in_struct->deviceLUIDValid;
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ deviceUUID[i] = in_struct->deviceUUID[i];
+ }
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ driverUUID[i] = in_struct->driverUUID[i];
+ }
+ for (uint32_t i=0; i<VK_LUID_SIZE_KHR; ++i) {
+ deviceLUID[i] = in_struct->deviceLUID[i];
+ }
+}
+
+void safe_VkPhysicalDeviceIDPropertiesKHR::initialize(const safe_VkPhysicalDeviceIDPropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ deviceNodeMask = src->deviceNodeMask;
+ deviceLUIDValid = src->deviceLUIDValid;
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ deviceUUID[i] = src->deviceUUID[i];
+ }
+ for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+ driverUUID[i] = src->driverUUID[i];
+ }
+ for (uint32_t i=0; i<VK_LUID_SIZE_KHR; ++i) {
+ deviceLUID[i] = src->deviceLUID[i];
+ }
+}
+
+safe_VkExternalMemoryImageCreateInfoKHR::safe_VkExternalMemoryImageCreateInfoKHR(const VkExternalMemoryImageCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExternalMemoryImageCreateInfoKHR::safe_VkExternalMemoryImageCreateInfoKHR()
+{}
+
+safe_VkExternalMemoryImageCreateInfoKHR::safe_VkExternalMemoryImageCreateInfoKHR(const safe_VkExternalMemoryImageCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExternalMemoryImageCreateInfoKHR::~safe_VkExternalMemoryImageCreateInfoKHR()
+{
+}
+
+void safe_VkExternalMemoryImageCreateInfoKHR::initialize(const VkExternalMemoryImageCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExternalMemoryImageCreateInfoKHR::initialize(const safe_VkExternalMemoryImageCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+
+safe_VkExternalMemoryBufferCreateInfoKHR::safe_VkExternalMemoryBufferCreateInfoKHR(const VkExternalMemoryBufferCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExternalMemoryBufferCreateInfoKHR::safe_VkExternalMemoryBufferCreateInfoKHR()
+{}
+
+safe_VkExternalMemoryBufferCreateInfoKHR::safe_VkExternalMemoryBufferCreateInfoKHR(const safe_VkExternalMemoryBufferCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExternalMemoryBufferCreateInfoKHR::~safe_VkExternalMemoryBufferCreateInfoKHR()
+{
+}
+
+void safe_VkExternalMemoryBufferCreateInfoKHR::initialize(const VkExternalMemoryBufferCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExternalMemoryBufferCreateInfoKHR::initialize(const safe_VkExternalMemoryBufferCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+
+safe_VkExportMemoryAllocateInfoKHR::safe_VkExportMemoryAllocateInfoKHR(const VkExportMemoryAllocateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExportMemoryAllocateInfoKHR::safe_VkExportMemoryAllocateInfoKHR()
+{}
+
+safe_VkExportMemoryAllocateInfoKHR::safe_VkExportMemoryAllocateInfoKHR(const safe_VkExportMemoryAllocateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExportMemoryAllocateInfoKHR::~safe_VkExportMemoryAllocateInfoKHR()
+{
+}
+
+void safe_VkExportMemoryAllocateInfoKHR::initialize(const VkExportMemoryAllocateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExportMemoryAllocateInfoKHR::initialize(const safe_VkExportMemoryAllocateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle),
+ name(in_struct->name)
+{
+}
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR()
+{}
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+ handle = src.handle;
+ name = src.name;
+}
+
+safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR()
+{
+}
+
+void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+ name = in_struct->name;
+}
+
+void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+ handle = src->handle;
+ name = src->name;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pAttributes(nullptr),
+ dwAccess(in_struct->dwAccess),
+ name(in_struct->name)
+{
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR() :
+ pAttributes(nullptr)
+{}
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pAttributes = nullptr;
+ dwAccess = src.dwAccess;
+ name = src.name;
+ if (src.pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
+ }
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR()
+{
+ if (pAttributes)
+ delete pAttributes;
+}
+
+void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pAttributes = nullptr;
+ dwAccess = in_struct->dwAccess;
+ name = in_struct->name;
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pAttributes = nullptr;
+ dwAccess = src->dwAccess;
+ name = src->name;
+ if (src->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryTypeBits(in_struct->memoryTypeBits)
+{
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR()
+{}
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryTypeBits = src.memoryTypeBits;
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR()
+{
+}
+
+void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryTypeBits = in_struct->memoryTypeBits;
+}
+
+void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryTypeBits = src->memoryTypeBits;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memory(in_struct->memory),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR()
+{}
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memory = src.memory;
+ handleType = src.handleType;
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR()
+{
+}
+
+void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memory = in_struct->memory;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memory = src->memory;
+ handleType = src->handleType;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType),
+ fd(in_struct->fd)
+{
+}
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR()
+{}
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+ fd = src.fd;
+}
+
+safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR()
+{
+}
+
+void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+ fd = in_struct->fd;
+}
+
+void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+ fd = src->fd;
+}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryTypeBits(in_struct->memoryTypeBits)
+{
+}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR()
+{}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryTypeBits = src.memoryTypeBits;
+}
+
+safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR()
+{
+}
+
+void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryTypeBits = in_struct->memoryTypeBits;
+}
+
+void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryTypeBits = src->memoryTypeBits;
+}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memory(in_struct->memory),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR()
+{}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memory = src.memory;
+ handleType = src.handleType;
+}
+
+safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR()
+{
+}
+
+void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memory = in_struct->memory;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memory = src->memory;
+ handleType = src->handleType;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ acquireCount(in_struct->acquireCount),
+ pAcquireSyncs(nullptr),
+ pAcquireKeys(nullptr),
+ pAcquireTimeouts(nullptr),
+ releaseCount(in_struct->releaseCount),
+ pReleaseSyncs(nullptr),
+ pReleaseKeys(nullptr)
+{
+ if (acquireCount && in_struct->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+ }
+ }
+ if (in_struct->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
+ }
+ if (in_struct->pAcquireTimeouts) {
+ pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireTimeouts, (void *)in_struct->pAcquireTimeouts, sizeof(uint32_t)*in_struct->acquireCount);
+ }
+ if (releaseCount && in_struct->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+ }
+ }
+ if (in_struct->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[in_struct->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
+ }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() :
+ pAcquireSyncs(nullptr),
+ pAcquireKeys(nullptr),
+ pAcquireTimeouts(nullptr),
+ pReleaseSyncs(nullptr),
+ pReleaseKeys(nullptr)
+{}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ acquireCount = src.acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeouts = nullptr;
+ releaseCount = src.releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && src.pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = src.pAcquireSyncs[i];
+ }
+ }
+ if (src.pAcquireKeys) {
+ pAcquireKeys = new uint64_t[src.acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)src.pAcquireKeys, sizeof(uint64_t)*src.acquireCount);
+ }
+ if (src.pAcquireTimeouts) {
+ pAcquireTimeouts = new uint32_t[src.acquireCount];
+ memcpy ((void *)pAcquireTimeouts, (void *)src.pAcquireTimeouts, sizeof(uint32_t)*src.acquireCount);
+ }
+ if (releaseCount && src.pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = src.pReleaseSyncs[i];
+ }
+ }
+ if (src.pReleaseKeys) {
+ pReleaseKeys = new uint64_t[src.releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)src.pReleaseKeys, sizeof(uint64_t)*src.releaseCount);
+ }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR()
+{
+ if (pAcquireSyncs)
+ delete[] pAcquireSyncs;
+ if (pAcquireKeys)
+ delete[] pAcquireKeys;
+ if (pAcquireTimeouts)
+ delete[] pAcquireTimeouts;
+ if (pReleaseSyncs)
+ delete[] pReleaseSyncs;
+ if (pReleaseKeys)
+ delete[] pReleaseKeys;
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ acquireCount = in_struct->acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeouts = nullptr;
+ releaseCount = in_struct->releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && in_struct->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+ }
+ }
+ if (in_struct->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
+ }
+ if (in_struct->pAcquireTimeouts) {
+ pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireTimeouts, (void *)in_struct->pAcquireTimeouts, sizeof(uint32_t)*in_struct->acquireCount);
+ }
+ if (releaseCount && in_struct->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+ }
+ }
+ if (in_struct->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[in_struct->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
+ }
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ acquireCount = src->acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeouts = nullptr;
+ releaseCount = src->releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && src->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = src->pAcquireSyncs[i];
+ }
+ }
+ if (src->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[src->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)src->pAcquireKeys, sizeof(uint64_t)*src->acquireCount);
+ }
+ if (src->pAcquireTimeouts) {
+ pAcquireTimeouts = new uint32_t[src->acquireCount];
+ memcpy ((void *)pAcquireTimeouts, (void *)src->pAcquireTimeouts, sizeof(uint32_t)*src->acquireCount);
+ }
+ if (releaseCount && src->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = src->pReleaseSyncs[i];
+ }
+ }
+ if (src->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[src->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)src->pReleaseKeys, sizeof(uint64_t)*src->releaseCount);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::safe_VkPhysicalDeviceExternalSemaphoreInfoKHR(const VkPhysicalDeviceExternalSemaphoreInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::safe_VkPhysicalDeviceExternalSemaphoreInfoKHR()
+{}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::safe_VkPhysicalDeviceExternalSemaphoreInfoKHR(const safe_VkPhysicalDeviceExternalSemaphoreInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::~safe_VkPhysicalDeviceExternalSemaphoreInfoKHR()
+{
+}
+
+void safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::initialize(const VkPhysicalDeviceExternalSemaphoreInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkPhysicalDeviceExternalSemaphoreInfoKHR::initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+}
+
+safe_VkExternalSemaphorePropertiesKHR::safe_VkExternalSemaphorePropertiesKHR(const VkExternalSemaphorePropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
+ compatibleHandleTypes(in_struct->compatibleHandleTypes),
+ externalSemaphoreFeatures(in_struct->externalSemaphoreFeatures)
+{
+}
+
+safe_VkExternalSemaphorePropertiesKHR::safe_VkExternalSemaphorePropertiesKHR()
+{}
+
+safe_VkExternalSemaphorePropertiesKHR::safe_VkExternalSemaphorePropertiesKHR(const safe_VkExternalSemaphorePropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
+ compatibleHandleTypes = src.compatibleHandleTypes;
+ externalSemaphoreFeatures = src.externalSemaphoreFeatures;
+}
+
+safe_VkExternalSemaphorePropertiesKHR::~safe_VkExternalSemaphorePropertiesKHR()
+{
+}
+
+void safe_VkExternalSemaphorePropertiesKHR::initialize(const VkExternalSemaphorePropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
+ compatibleHandleTypes = in_struct->compatibleHandleTypes;
+ externalSemaphoreFeatures = in_struct->externalSemaphoreFeatures;
+}
+
+void safe_VkExternalSemaphorePropertiesKHR::initialize(const safe_VkExternalSemaphorePropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ exportFromImportedHandleTypes = src->exportFromImportedHandleTypes;
+ compatibleHandleTypes = src->compatibleHandleTypes;
+ externalSemaphoreFeatures = src->externalSemaphoreFeatures;
+}
+
+safe_VkExportSemaphoreCreateInfoKHR::safe_VkExportSemaphoreCreateInfoKHR(const VkExportSemaphoreCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExportSemaphoreCreateInfoKHR::safe_VkExportSemaphoreCreateInfoKHR()
+{}
+
+safe_VkExportSemaphoreCreateInfoKHR::safe_VkExportSemaphoreCreateInfoKHR(const safe_VkExportSemaphoreCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExportSemaphoreCreateInfoKHR::~safe_VkExportSemaphoreCreateInfoKHR()
+{
+}
+
+void safe_VkExportSemaphoreCreateInfoKHR::initialize(const VkExportSemaphoreCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExportSemaphoreCreateInfoKHR::initialize(const safe_VkExportSemaphoreCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle),
+ name(in_struct->name)
+{
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR()
+{}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ flags = src.flags;
+ handleType = src.handleType;
+ handle = src.handle;
+ name = src.name;
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR()
+{
+}
+
+void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+ name = in_struct->name;
+}
+
+void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ flags = src->flags;
+ handleType = src->handleType;
+ handle = src->handle;
+ name = src->name;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pAttributes(nullptr),
+ dwAccess(in_struct->dwAccess),
+ name(in_struct->name)
+{
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() :
+ pAttributes(nullptr)
+{}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pAttributes = nullptr;
+ dwAccess = src.dwAccess;
+ name = src.name;
+ if (src.pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
+ }
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR()
+{
+ if (pAttributes)
+ delete pAttributes;
+}
+
+void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pAttributes = nullptr;
+ dwAccess = in_struct->dwAccess;
+ name = in_struct->name;
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pAttributes = nullptr;
+ dwAccess = src->dwAccess;
+ name = src->name;
+ if (src->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount),
+ pWaitSemaphoreValues(nullptr),
+ signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount),
+ pSignalSemaphoreValues(nullptr)
+{
+ if (in_struct->pWaitSemaphoreValues) {
+ pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
+ memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
+ }
+ if (in_struct->pSignalSemaphoreValues) {
+ pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
+ memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValuesCount);
+ }
+}
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() :
+ pWaitSemaphoreValues(nullptr),
+ pSignalSemaphoreValues(nullptr)
+{}
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ waitSemaphoreValuesCount = src.waitSemaphoreValuesCount;
+ pWaitSemaphoreValues = nullptr;
+ signalSemaphoreValuesCount = src.signalSemaphoreValuesCount;
+ pSignalSemaphoreValues = nullptr;
+ if (src.pWaitSemaphoreValues) {
+ pWaitSemaphoreValues = new uint64_t[src.waitSemaphoreValuesCount];
+ memcpy ((void *)pWaitSemaphoreValues, (void *)src.pWaitSemaphoreValues, sizeof(uint64_t)*src.waitSemaphoreValuesCount);
+ }
+ if (src.pSignalSemaphoreValues) {
+ pSignalSemaphoreValues = new uint64_t[src.signalSemaphoreValuesCount];
+ memcpy ((void *)pSignalSemaphoreValues, (void *)src.pSignalSemaphoreValues, sizeof(uint64_t)*src.signalSemaphoreValuesCount);
+ }
+}
+
+safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR()
+{
+ if (pWaitSemaphoreValues)
+ delete[] pWaitSemaphoreValues;
+ if (pSignalSemaphoreValues)
+ delete[] pSignalSemaphoreValues;
+}
+
+void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount;
+ pWaitSemaphoreValues = nullptr;
+ signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount;
+ pSignalSemaphoreValues = nullptr;
+ if (in_struct->pWaitSemaphoreValues) {
+ pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
+ memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
+ }
+ if (in_struct->pSignalSemaphoreValues) {
+ pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
+ memcpy ((void *)pSignalSemaphoreValues, (void *)in_struct->pSignalSemaphoreValues, sizeof(uint64_t)*in_struct->signalSemaphoreValuesCount);
+ }
+}
+
+void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ waitSemaphoreValuesCount = src->waitSemaphoreValuesCount;
+ pWaitSemaphoreValues = nullptr;
+ signalSemaphoreValuesCount = src->signalSemaphoreValuesCount;
+ pSignalSemaphoreValues = nullptr;
+ if (src->pWaitSemaphoreValues) {
+ pWaitSemaphoreValues = new uint64_t[src->waitSemaphoreValuesCount];
+ memcpy ((void *)pWaitSemaphoreValues, (void *)src->pWaitSemaphoreValues, sizeof(uint64_t)*src->waitSemaphoreValuesCount);
+ }
+ if (src->pSignalSemaphoreValues) {
+ pSignalSemaphoreValues = new uint64_t[src->signalSemaphoreValuesCount];
+ memcpy ((void *)pSignalSemaphoreValues, (void *)src->pSignalSemaphoreValues, sizeof(uint64_t)*src->signalSemaphoreValuesCount);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR()
+{}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ handleType = src.handleType;
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR()
+{
+}
+
+void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ handleType = src->handleType;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ fd(in_struct->fd)
+{
+}
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR()
+{}
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ flags = src.flags;
+ handleType = src.handleType;
+ fd = src.fd;
+}
+
+safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR()
+{
+}
+
+void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ fd = in_struct->fd;
+}
+
+void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ flags = src->flags;
+ handleType = src->handleType;
+ fd = src->fd;
+}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR()
+{}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ handleType = src.handleType;
+}
+
+safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR()
+{
+}
+
+void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ handleType = src->handleType;
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ maxPushDescriptors(in_struct->maxPushDescriptors)
+{
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
+{}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ maxPushDescriptors = src.maxPushDescriptors;
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
+{
+}
+
+void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ maxPushDescriptors = in_struct->maxPushDescriptors;
+}
+
+void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ maxPushDescriptors = src->maxPushDescriptors;
+}
+
+safe_VkPhysicalDevice16BitStorageFeaturesKHR::safe_VkPhysicalDevice16BitStorageFeaturesKHR(const VkPhysicalDevice16BitStorageFeaturesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
+ uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
+ storagePushConstant16(in_struct->storagePushConstant16),
+ storageInputOutput16(in_struct->storageInputOutput16)
+{
+}
+
+safe_VkPhysicalDevice16BitStorageFeaturesKHR::safe_VkPhysicalDevice16BitStorageFeaturesKHR()
+{}
+
+safe_VkPhysicalDevice16BitStorageFeaturesKHR::safe_VkPhysicalDevice16BitStorageFeaturesKHR(const safe_VkPhysicalDevice16BitStorageFeaturesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ storageBuffer16BitAccess = src.storageBuffer16BitAccess;
+ uniformAndStorageBuffer16BitAccess = src.uniformAndStorageBuffer16BitAccess;
+ storagePushConstant16 = src.storagePushConstant16;
+ storageInputOutput16 = src.storageInputOutput16;
+}
+
+safe_VkPhysicalDevice16BitStorageFeaturesKHR::~safe_VkPhysicalDevice16BitStorageFeaturesKHR()
+{
+}
+
+void safe_VkPhysicalDevice16BitStorageFeaturesKHR::initialize(const VkPhysicalDevice16BitStorageFeaturesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
+ uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
+ storagePushConstant16 = in_struct->storagePushConstant16;
+ storageInputOutput16 = in_struct->storageInputOutput16;
+}
+
+void safe_VkPhysicalDevice16BitStorageFeaturesKHR::initialize(const safe_VkPhysicalDevice16BitStorageFeaturesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ storageBuffer16BitAccess = src->storageBuffer16BitAccess;
+ uniformAndStorageBuffer16BitAccess = src->uniformAndStorageBuffer16BitAccess;
+ storagePushConstant16 = src->storagePushConstant16;
+ storageInputOutput16 = src->storageInputOutput16;
+}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct) :
+ rectangleCount(in_struct->rectangleCount),
+ pRectangles(nullptr)
+{
+ if (in_struct->pRectangles) {
+ pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
+ memcpy ((void *)pRectangles, (void *)in_struct->pRectangles, sizeof(VkRectLayerKHR)*in_struct->rectangleCount);
+ }
+}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() :
+ pRectangles(nullptr)
+{}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& src)
+{
+ rectangleCount = src.rectangleCount;
+ pRectangles = nullptr;
+ if (src.pRectangles) {
+ pRectangles = new VkRectLayerKHR[src.rectangleCount];
+ memcpy ((void *)pRectangles, (void *)src.pRectangles, sizeof(VkRectLayerKHR)*src.rectangleCount);
+ }
+}
+
+safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR()
+{
+ if (pRectangles)
+ delete[] pRectangles;
+}
+
+void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct)
+{
+ rectangleCount = in_struct->rectangleCount;
+ pRectangles = nullptr;
+ if (in_struct->pRectangles) {
+ pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
+ memcpy ((void *)pRectangles, (void *)in_struct->pRectangles, sizeof(VkRectLayerKHR)*in_struct->rectangleCount);
+ }
+}
+
+void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* src)
+{
+ rectangleCount = src->rectangleCount;
+ pRectangles = nullptr;
+ if (src->pRectangles) {
+ pRectangles = new VkRectLayerKHR[src->rectangleCount];
+ memcpy ((void *)pRectangles, (void *)src->pRectangles, sizeof(VkRectLayerKHR)*src->rectangleCount);
+ }
+}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchainCount(in_struct->swapchainCount),
+ pRegions(nullptr)
+{
+ if (swapchainCount && in_struct->pRegions) {
+ pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pRegions[i].initialize(&in_struct->pRegions[i]);
+ }
+ }
+}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() :
+ pRegions(nullptr)
+{}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchainCount = src.swapchainCount;
+ pRegions = nullptr;
+ if (swapchainCount && src.pRegions) {
+ pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pRegions[i].initialize(&src.pRegions[i]);
+ }
+ }
+}
+
+safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR()
+{
+ if (pRegions)
+ delete[] pRegions;
+}
+
+void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchainCount = in_struct->swapchainCount;
+ pRegions = nullptr;
+ if (swapchainCount && in_struct->pRegions) {
+ pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pRegions[i].initialize(&in_struct->pRegions[i]);
+ }
+ }
+}
+
+void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchainCount = src->swapchainCount;
+ pRegions = nullptr;
+ if (swapchainCount && src->pRegions) {
+ pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+ for (uint32_t i=0; i<swapchainCount; ++i) {
+ pRegions[i].initialize(&src->pRegions[i]);
+ }
+ }
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfoKHR::safe_VkDescriptorUpdateTemplateCreateInfoKHR(const VkDescriptorUpdateTemplateCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ descriptorUpdateEntryCount(in_struct->descriptorUpdateEntryCount),
+ pDescriptorUpdateEntries(nullptr),
+ templateType(in_struct->templateType),
+ descriptorSetLayout(in_struct->descriptorSetLayout),
+ pipelineBindPoint(in_struct->pipelineBindPoint),
+ pipelineLayout(in_struct->pipelineLayout),
+ set(in_struct->set)
+{
+ if (in_struct->pDescriptorUpdateEntries) {
+ pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntryKHR[in_struct->descriptorUpdateEntryCount];
+ memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntryKHR)*in_struct->descriptorUpdateEntryCount);
+ }
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfoKHR::safe_VkDescriptorUpdateTemplateCreateInfoKHR() :
+ pDescriptorUpdateEntries(nullptr)
+{}
+
+safe_VkDescriptorUpdateTemplateCreateInfoKHR::safe_VkDescriptorUpdateTemplateCreateInfoKHR(const safe_VkDescriptorUpdateTemplateCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ descriptorUpdateEntryCount = src.descriptorUpdateEntryCount;
+ pDescriptorUpdateEntries = nullptr;
+ templateType = src.templateType;
+ descriptorSetLayout = src.descriptorSetLayout;
+ pipelineBindPoint = src.pipelineBindPoint;
+ pipelineLayout = src.pipelineLayout;
+ set = src.set;
+ if (src.pDescriptorUpdateEntries) {
+ pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntryKHR[src.descriptorUpdateEntryCount];
+ memcpy ((void *)pDescriptorUpdateEntries, (void *)src.pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntryKHR)*src.descriptorUpdateEntryCount);
+ }
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfoKHR::~safe_VkDescriptorUpdateTemplateCreateInfoKHR()
+{
+ if (pDescriptorUpdateEntries)
+ delete[] pDescriptorUpdateEntries;
+}
+
+void safe_VkDescriptorUpdateTemplateCreateInfoKHR::initialize(const VkDescriptorUpdateTemplateCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ descriptorUpdateEntryCount = in_struct->descriptorUpdateEntryCount;
+ pDescriptorUpdateEntries = nullptr;
+ templateType = in_struct->templateType;
+ descriptorSetLayout = in_struct->descriptorSetLayout;
+ pipelineBindPoint = in_struct->pipelineBindPoint;
+ pipelineLayout = in_struct->pipelineLayout;
+ set = in_struct->set;
+ if (in_struct->pDescriptorUpdateEntries) {
+ pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntryKHR[in_struct->descriptorUpdateEntryCount];
+ memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntryKHR)*in_struct->descriptorUpdateEntryCount);
+ }
+}
+
+void safe_VkDescriptorUpdateTemplateCreateInfoKHR::initialize(const safe_VkDescriptorUpdateTemplateCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ descriptorUpdateEntryCount = src->descriptorUpdateEntryCount;
+ pDescriptorUpdateEntries = nullptr;
+ templateType = src->templateType;
+ descriptorSetLayout = src->descriptorSetLayout;
+ pipelineBindPoint = src->pipelineBindPoint;
+ pipelineLayout = src->pipelineLayout;
+ set = src->set;
+ if (src->pDescriptorUpdateEntries) {
+ pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntryKHR[src->descriptorUpdateEntryCount];
+ memcpy ((void *)pDescriptorUpdateEntries, (void *)src->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntryKHR)*src->descriptorUpdateEntryCount);
+ }
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags)
+{
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR()
+{}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ sharedPresentSupportedUsageFlags = src.sharedPresentSupportedUsageFlags;
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR()
+{
+}
+
+void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags;
+}
+
+void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ sharedPresentSupportedUsageFlags = src->sharedPresentSupportedUsageFlags;
+}
+
+safe_VkPhysicalDeviceExternalFenceInfoKHR::safe_VkPhysicalDeviceExternalFenceInfoKHR(const VkPhysicalDeviceExternalFenceInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkPhysicalDeviceExternalFenceInfoKHR::safe_VkPhysicalDeviceExternalFenceInfoKHR()
+{}
+
+safe_VkPhysicalDeviceExternalFenceInfoKHR::safe_VkPhysicalDeviceExternalFenceInfoKHR(const safe_VkPhysicalDeviceExternalFenceInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+}
+
+safe_VkPhysicalDeviceExternalFenceInfoKHR::~safe_VkPhysicalDeviceExternalFenceInfoKHR()
+{
+}
+
+void safe_VkPhysicalDeviceExternalFenceInfoKHR::initialize(const VkPhysicalDeviceExternalFenceInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkPhysicalDeviceExternalFenceInfoKHR::initialize(const safe_VkPhysicalDeviceExternalFenceInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+}
+
+safe_VkExternalFencePropertiesKHR::safe_VkExternalFencePropertiesKHR(const VkExternalFencePropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
+ compatibleHandleTypes(in_struct->compatibleHandleTypes),
+ externalFenceFeatures(in_struct->externalFenceFeatures)
+{
+}
+
+safe_VkExternalFencePropertiesKHR::safe_VkExternalFencePropertiesKHR()
+{}
+
+safe_VkExternalFencePropertiesKHR::safe_VkExternalFencePropertiesKHR(const safe_VkExternalFencePropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
+ compatibleHandleTypes = src.compatibleHandleTypes;
+ externalFenceFeatures = src.externalFenceFeatures;
+}
+
+safe_VkExternalFencePropertiesKHR::~safe_VkExternalFencePropertiesKHR()
+{
+}
+
+void safe_VkExternalFencePropertiesKHR::initialize(const VkExternalFencePropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
+ compatibleHandleTypes = in_struct->compatibleHandleTypes;
+ externalFenceFeatures = in_struct->externalFenceFeatures;
+}
+
+void safe_VkExternalFencePropertiesKHR::initialize(const safe_VkExternalFencePropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ exportFromImportedHandleTypes = src->exportFromImportedHandleTypes;
+ compatibleHandleTypes = src->compatibleHandleTypes;
+ externalFenceFeatures = src->externalFenceFeatures;
+}
+
+safe_VkExportFenceCreateInfoKHR::safe_VkExportFenceCreateInfoKHR(const VkExportFenceCreateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExportFenceCreateInfoKHR::safe_VkExportFenceCreateInfoKHR()
+{}
+
+safe_VkExportFenceCreateInfoKHR::safe_VkExportFenceCreateInfoKHR(const safe_VkExportFenceCreateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExportFenceCreateInfoKHR::~safe_VkExportFenceCreateInfoKHR()
+{
+}
+
+void safe_VkExportFenceCreateInfoKHR::initialize(const VkExportFenceCreateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExportFenceCreateInfoKHR::initialize(const safe_VkExportFenceCreateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ fence(in_struct->fence),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle),
+ name(in_struct->name)
+{
+}
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR()
+{}
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ fence = src.fence;
+ flags = src.flags;
+ handleType = src.handleType;
+ handle = src.handle;
+ name = src.name;
+}
+
+safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR()
+{
+}
+
+void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ fence = in_struct->fence;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+ name = in_struct->name;
+}
+
+void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ fence = src->fence;
+ flags = src->flags;
+ handleType = src->handleType;
+ handle = src->handle;
+ name = src->name;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pAttributes(nullptr),
+ dwAccess(in_struct->dwAccess),
+ name(in_struct->name)
+{
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR() :
+ pAttributes(nullptr)
+{}
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pAttributes = nullptr;
+ dwAccess = src.dwAccess;
+ name = src.name;
+ if (src.pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
+ }
+}
+
+safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR()
+{
+ if (pAttributes)
+ delete pAttributes;
+}
+
+void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pAttributes = nullptr;
+ dwAccess = in_struct->dwAccess;
+ name = in_struct->name;
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pAttributes = nullptr;
+ dwAccess = src->dwAccess;
+ name = src->name;
+ if (src->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ fence(in_struct->fence),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR()
+{}
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ fence = src.fence;
+ handleType = src.handleType;
+}
+
+safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR()
+{
+}
+
+void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ fence = in_struct->fence;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ fence = src->fence;
+ handleType = src->handleType;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ fence(in_struct->fence),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ fd(in_struct->fd)
+{
+}
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR()
+{}
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ fence = src.fence;
+ flags = src.flags;
+ handleType = src.handleType;
+ fd = src.fd;
+}
+
+safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR()
+{
+}
+
+void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ fence = in_struct->fence;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ fd = in_struct->fd;
+}
+
+void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ fence = src->fence;
+ flags = src->flags;
+ handleType = src->handleType;
+ fd = src->fd;
+}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ fence(in_struct->fence),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR()
+{}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ fence = src.fence;
+ handleType = src.handleType;
+}
+
+safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR()
+{
+}
+
+void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ fence = in_struct->fence;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ fence = src->fence;
+ handleType = src->handleType;
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ surface(in_struct->surface)
+{
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR()
+{}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ surface = src.surface;
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR()
+{
+}
+
+void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ surface = in_struct->surface;
+}
+
+void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ surface = src->surface;
+}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ surfaceCapabilities(in_struct->surfaceCapabilities)
+{
+}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR()
+{}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ surfaceCapabilities = src.surfaceCapabilities;
+}
+
+safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR()
+{
+}
+
+void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ surfaceCapabilities = in_struct->surfaceCapabilities;
+}
+
+void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ surfaceCapabilities = src->surfaceCapabilities;
+}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ surfaceFormat(in_struct->surfaceFormat)
+{
+}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR()
+{}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ surfaceFormat = src.surfaceFormat;
+}
+
+safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR()
+{
+}
+
+void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ surfaceFormat = in_struct->surfaceFormat;
+}
+
+void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ surfaceFormat = src->surfaceFormat;
+}
+
+safe_VkPhysicalDeviceVariablePointerFeaturesKHR::safe_VkPhysicalDeviceVariablePointerFeaturesKHR(const VkPhysicalDeviceVariablePointerFeaturesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
+ variablePointers(in_struct->variablePointers)
+{
+}
+
+safe_VkPhysicalDeviceVariablePointerFeaturesKHR::safe_VkPhysicalDeviceVariablePointerFeaturesKHR()
+{}
+
+safe_VkPhysicalDeviceVariablePointerFeaturesKHR::safe_VkPhysicalDeviceVariablePointerFeaturesKHR(const safe_VkPhysicalDeviceVariablePointerFeaturesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ variablePointersStorageBuffer = src.variablePointersStorageBuffer;
+ variablePointers = src.variablePointers;
+}
+
+safe_VkPhysicalDeviceVariablePointerFeaturesKHR::~safe_VkPhysicalDeviceVariablePointerFeaturesKHR()
+{
+}
+
+void safe_VkPhysicalDeviceVariablePointerFeaturesKHR::initialize(const VkPhysicalDeviceVariablePointerFeaturesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
+ variablePointers = in_struct->variablePointers;
+}
+
+void safe_VkPhysicalDeviceVariablePointerFeaturesKHR::initialize(const safe_VkPhysicalDeviceVariablePointerFeaturesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ variablePointersStorageBuffer = src->variablePointersStorageBuffer;
+ variablePointers = src->variablePointers;
+}
+
+safe_VkMemoryDedicatedRequirementsKHR::safe_VkMemoryDedicatedRequirementsKHR(const VkMemoryDedicatedRequirementsKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ prefersDedicatedAllocation(in_struct->prefersDedicatedAllocation),
+ requiresDedicatedAllocation(in_struct->requiresDedicatedAllocation)
+{
+}
+
+safe_VkMemoryDedicatedRequirementsKHR::safe_VkMemoryDedicatedRequirementsKHR()
+{}
+
+safe_VkMemoryDedicatedRequirementsKHR::safe_VkMemoryDedicatedRequirementsKHR(const safe_VkMemoryDedicatedRequirementsKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ prefersDedicatedAllocation = src.prefersDedicatedAllocation;
+ requiresDedicatedAllocation = src.requiresDedicatedAllocation;
+}
+
+safe_VkMemoryDedicatedRequirementsKHR::~safe_VkMemoryDedicatedRequirementsKHR()
+{
+}
+
+void safe_VkMemoryDedicatedRequirementsKHR::initialize(const VkMemoryDedicatedRequirementsKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ prefersDedicatedAllocation = in_struct->prefersDedicatedAllocation;
+ requiresDedicatedAllocation = in_struct->requiresDedicatedAllocation;
+}
+
+void safe_VkMemoryDedicatedRequirementsKHR::initialize(const safe_VkMemoryDedicatedRequirementsKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ prefersDedicatedAllocation = src->prefersDedicatedAllocation;
+ requiresDedicatedAllocation = src->requiresDedicatedAllocation;
+}
+
+safe_VkMemoryDedicatedAllocateInfoKHR::safe_VkMemoryDedicatedAllocateInfoKHR(const VkMemoryDedicatedAllocateInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ image(in_struct->image),
+ buffer(in_struct->buffer)
+{
+}
+
+safe_VkMemoryDedicatedAllocateInfoKHR::safe_VkMemoryDedicatedAllocateInfoKHR()
+{}
+
+safe_VkMemoryDedicatedAllocateInfoKHR::safe_VkMemoryDedicatedAllocateInfoKHR(const safe_VkMemoryDedicatedAllocateInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ image = src.image;
+ buffer = src.buffer;
+}
+
+safe_VkMemoryDedicatedAllocateInfoKHR::~safe_VkMemoryDedicatedAllocateInfoKHR()
+{
+}
+
+void safe_VkMemoryDedicatedAllocateInfoKHR::initialize(const VkMemoryDedicatedAllocateInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ image = in_struct->image;
+ buffer = in_struct->buffer;
+}
+
+void safe_VkMemoryDedicatedAllocateInfoKHR::initialize(const safe_VkMemoryDedicatedAllocateInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ image = src->image;
+ buffer = src->buffer;
+}
+
+safe_VkBufferMemoryRequirementsInfo2KHR::safe_VkBufferMemoryRequirementsInfo2KHR(const VkBufferMemoryRequirementsInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ buffer(in_struct->buffer)
+{
+}
+
+safe_VkBufferMemoryRequirementsInfo2KHR::safe_VkBufferMemoryRequirementsInfo2KHR()
+{}
+
+safe_VkBufferMemoryRequirementsInfo2KHR::safe_VkBufferMemoryRequirementsInfo2KHR(const safe_VkBufferMemoryRequirementsInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ buffer = src.buffer;
+}
+
+safe_VkBufferMemoryRequirementsInfo2KHR::~safe_VkBufferMemoryRequirementsInfo2KHR()
+{
+}
+
+void safe_VkBufferMemoryRequirementsInfo2KHR::initialize(const VkBufferMemoryRequirementsInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ buffer = in_struct->buffer;
+}
+
+void safe_VkBufferMemoryRequirementsInfo2KHR::initialize(const safe_VkBufferMemoryRequirementsInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ buffer = src->buffer;
+}
+
+safe_VkImageMemoryRequirementsInfo2KHR::safe_VkImageMemoryRequirementsInfo2KHR(const VkImageMemoryRequirementsInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ image(in_struct->image)
+{
+}
+
+safe_VkImageMemoryRequirementsInfo2KHR::safe_VkImageMemoryRequirementsInfo2KHR()
+{}
+
+safe_VkImageMemoryRequirementsInfo2KHR::safe_VkImageMemoryRequirementsInfo2KHR(const safe_VkImageMemoryRequirementsInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ image = src.image;
+}
+
+safe_VkImageMemoryRequirementsInfo2KHR::~safe_VkImageMemoryRequirementsInfo2KHR()
+{
+}
+
+void safe_VkImageMemoryRequirementsInfo2KHR::initialize(const VkImageMemoryRequirementsInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ image = in_struct->image;
+}
+
+void safe_VkImageMemoryRequirementsInfo2KHR::initialize(const safe_VkImageMemoryRequirementsInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ image = src->image;
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2KHR::safe_VkImageSparseMemoryRequirementsInfo2KHR(const VkImageSparseMemoryRequirementsInfo2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ image(in_struct->image)
+{
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2KHR::safe_VkImageSparseMemoryRequirementsInfo2KHR()
+{}
+
+safe_VkImageSparseMemoryRequirementsInfo2KHR::safe_VkImageSparseMemoryRequirementsInfo2KHR(const safe_VkImageSparseMemoryRequirementsInfo2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ image = src.image;
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2KHR::~safe_VkImageSparseMemoryRequirementsInfo2KHR()
+{
+}
+
+void safe_VkImageSparseMemoryRequirementsInfo2KHR::initialize(const VkImageSparseMemoryRequirementsInfo2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ image = in_struct->image;
+}
+
+void safe_VkImageSparseMemoryRequirementsInfo2KHR::initialize(const safe_VkImageSparseMemoryRequirementsInfo2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ image = src->image;
+}
+
+safe_VkMemoryRequirements2KHR::safe_VkMemoryRequirements2KHR(const VkMemoryRequirements2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryRequirements(in_struct->memoryRequirements)
+{
+}
+
+safe_VkMemoryRequirements2KHR::safe_VkMemoryRequirements2KHR()
+{}
+
+safe_VkMemoryRequirements2KHR::safe_VkMemoryRequirements2KHR(const safe_VkMemoryRequirements2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryRequirements = src.memoryRequirements;
+}
+
+safe_VkMemoryRequirements2KHR::~safe_VkMemoryRequirements2KHR()
+{
+}
+
+void safe_VkMemoryRequirements2KHR::initialize(const VkMemoryRequirements2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryRequirements = in_struct->memoryRequirements;
+}
+
+void safe_VkMemoryRequirements2KHR::initialize(const safe_VkMemoryRequirements2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryRequirements = src->memoryRequirements;
+}
+
+safe_VkSparseImageMemoryRequirements2KHR::safe_VkSparseImageMemoryRequirements2KHR(const VkSparseImageMemoryRequirements2KHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryRequirements(in_struct->memoryRequirements)
+{
+}
+
+safe_VkSparseImageMemoryRequirements2KHR::safe_VkSparseImageMemoryRequirements2KHR()
+{}
+
+safe_VkSparseImageMemoryRequirements2KHR::safe_VkSparseImageMemoryRequirements2KHR(const safe_VkSparseImageMemoryRequirements2KHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryRequirements = src.memoryRequirements;
+}
+
+safe_VkSparseImageMemoryRequirements2KHR::~safe_VkSparseImageMemoryRequirements2KHR()
+{
+}
+
+void safe_VkSparseImageMemoryRequirements2KHR::initialize(const VkSparseImageMemoryRequirements2KHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryRequirements = in_struct->memoryRequirements;
+}
+
+void safe_VkSparseImageMemoryRequirements2KHR::initialize(const safe_VkSparseImageMemoryRequirements2KHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryRequirements = src->memoryRequirements;
+}
+
+safe_VkImportMemoryFuchsiaHandleInfoKHR::safe_VkImportMemoryFuchsiaHandleInfoKHR(const VkImportMemoryFuchsiaHandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle)
+{
+}
+
+safe_VkImportMemoryFuchsiaHandleInfoKHR::safe_VkImportMemoryFuchsiaHandleInfoKHR()
+{}
+
+safe_VkImportMemoryFuchsiaHandleInfoKHR::safe_VkImportMemoryFuchsiaHandleInfoKHR(const safe_VkImportMemoryFuchsiaHandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+ handle = src.handle;
+}
+
+safe_VkImportMemoryFuchsiaHandleInfoKHR::~safe_VkImportMemoryFuchsiaHandleInfoKHR()
+{
+}
+
+void safe_VkImportMemoryFuchsiaHandleInfoKHR::initialize(const VkImportMemoryFuchsiaHandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+}
+
+void safe_VkImportMemoryFuchsiaHandleInfoKHR::initialize(const safe_VkImportMemoryFuchsiaHandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+ handle = src->handle;
+}
+
+safe_VkMemoryFuchsiaHandlePropertiesKHR::safe_VkMemoryFuchsiaHandlePropertiesKHR(const VkMemoryFuchsiaHandlePropertiesKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memoryTypeBits(in_struct->memoryTypeBits)
+{
+}
+
+safe_VkMemoryFuchsiaHandlePropertiesKHR::safe_VkMemoryFuchsiaHandlePropertiesKHR()
+{}
+
+safe_VkMemoryFuchsiaHandlePropertiesKHR::safe_VkMemoryFuchsiaHandlePropertiesKHR(const safe_VkMemoryFuchsiaHandlePropertiesKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memoryTypeBits = src.memoryTypeBits;
+}
+
+safe_VkMemoryFuchsiaHandlePropertiesKHR::~safe_VkMemoryFuchsiaHandlePropertiesKHR()
+{
+}
+
+void safe_VkMemoryFuchsiaHandlePropertiesKHR::initialize(const VkMemoryFuchsiaHandlePropertiesKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memoryTypeBits = in_struct->memoryTypeBits;
+}
+
+void safe_VkMemoryFuchsiaHandlePropertiesKHR::initialize(const safe_VkMemoryFuchsiaHandlePropertiesKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memoryTypeBits = src->memoryTypeBits;
+}
+
+safe_VkMemoryGetFuchsiaHandleInfoKHR::safe_VkMemoryGetFuchsiaHandleInfoKHR(const VkMemoryGetFuchsiaHandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ memory(in_struct->memory),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkMemoryGetFuchsiaHandleInfoKHR::safe_VkMemoryGetFuchsiaHandleInfoKHR()
+{}
+
+safe_VkMemoryGetFuchsiaHandleInfoKHR::safe_VkMemoryGetFuchsiaHandleInfoKHR(const safe_VkMemoryGetFuchsiaHandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ memory = src.memory;
+ handleType = src.handleType;
+}
+
+safe_VkMemoryGetFuchsiaHandleInfoKHR::~safe_VkMemoryGetFuchsiaHandleInfoKHR()
+{
+}
+
+void safe_VkMemoryGetFuchsiaHandleInfoKHR::initialize(const VkMemoryGetFuchsiaHandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ memory = in_struct->memory;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkMemoryGetFuchsiaHandleInfoKHR::initialize(const safe_VkMemoryGetFuchsiaHandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ memory = src->memory;
+ handleType = src->handleType;
+}
+
+safe_VkImportSemaphoreFuchsiaHandleInfoKHR::safe_VkImportSemaphoreFuchsiaHandleInfoKHR(const VkImportSemaphoreFuchsiaHandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ flags(in_struct->flags),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle)
+{
+}
+
+safe_VkImportSemaphoreFuchsiaHandleInfoKHR::safe_VkImportSemaphoreFuchsiaHandleInfoKHR()
+{}
+
+safe_VkImportSemaphoreFuchsiaHandleInfoKHR::safe_VkImportSemaphoreFuchsiaHandleInfoKHR(const safe_VkImportSemaphoreFuchsiaHandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ flags = src.flags;
+ handleType = src.handleType;
+ handle = src.handle;
+}
+
+safe_VkImportSemaphoreFuchsiaHandleInfoKHR::~safe_VkImportSemaphoreFuchsiaHandleInfoKHR()
+{
+}
+
+void safe_VkImportSemaphoreFuchsiaHandleInfoKHR::initialize(const VkImportSemaphoreFuchsiaHandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ flags = in_struct->flags;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+}
+
+void safe_VkImportSemaphoreFuchsiaHandleInfoKHR::initialize(const safe_VkImportSemaphoreFuchsiaHandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ flags = src->flags;
+ handleType = src->handleType;
+ handle = src->handle;
+}
+
+safe_VkSemaphoreGetFuchsiaHandleInfoKHR::safe_VkSemaphoreGetFuchsiaHandleInfoKHR(const VkSemaphoreGetFuchsiaHandleInfoKHR* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ semaphore(in_struct->semaphore),
+ handleType(in_struct->handleType)
+{
+}
+
+safe_VkSemaphoreGetFuchsiaHandleInfoKHR::safe_VkSemaphoreGetFuchsiaHandleInfoKHR()
+{}
+
+safe_VkSemaphoreGetFuchsiaHandleInfoKHR::safe_VkSemaphoreGetFuchsiaHandleInfoKHR(const safe_VkSemaphoreGetFuchsiaHandleInfoKHR& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ semaphore = src.semaphore;
+ handleType = src.handleType;
+}
+
+safe_VkSemaphoreGetFuchsiaHandleInfoKHR::~safe_VkSemaphoreGetFuchsiaHandleInfoKHR()
+{
+}
+
+void safe_VkSemaphoreGetFuchsiaHandleInfoKHR::initialize(const VkSemaphoreGetFuchsiaHandleInfoKHR* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ semaphore = in_struct->semaphore;
+ handleType = in_struct->handleType;
+}
+
+void safe_VkSemaphoreGetFuchsiaHandleInfoKHR::initialize(const safe_VkSemaphoreGetFuchsiaHandleInfoKHR* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ semaphore = src->semaphore;
+ handleType = src->handleType;
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ pfnCallback(in_struct->pfnCallback),
+ pUserData(in_struct->pUserData)
+{
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT()
+{}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ pfnCallback = src.pfnCallback;
+ pUserData = src.pUserData;
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::~safe_VkDebugReportCallbackCreateInfoEXT()
+{
+}
+
+void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ pfnCallback = in_struct->pfnCallback;
+ pUserData = in_struct->pUserData;
+}
+
+void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ pfnCallback = src->pfnCallback;
+ pUserData = src->pUserData;
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ rasterizationOrder(in_struct->rasterizationOrder)
+{
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD()
+{}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ rasterizationOrder = src.rasterizationOrder;
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::~safe_VkPipelineRasterizationStateRasterizationOrderAMD()
+{
+}
+
+void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ rasterizationOrder = in_struct->rasterizationOrder;
+}
+
+void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ rasterizationOrder = src->rasterizationOrder;
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ objectType(in_struct->objectType),
+ object(in_struct->object),
+ pObjectName(in_struct->pObjectName)
+{
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT()
+{}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ objectType = src.objectType;
+ object = src.object;
+ pObjectName = src.pObjectName;
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::~safe_VkDebugMarkerObjectNameInfoEXT()
+{
+}
+
+void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ objectType = in_struct->objectType;
+ object = in_struct->object;
+ pObjectName = in_struct->pObjectName;
+}
+
+void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ objectType = src->objectType;
+ object = src->object;
+ pObjectName = src->pObjectName;
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ objectType(in_struct->objectType),
+ object(in_struct->object),
+ tagName(in_struct->tagName),
+ tagSize(in_struct->tagSize),
+ pTag(in_struct->pTag)
+{
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT()
+{}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ objectType = src.objectType;
+ object = src.object;
+ tagName = src.tagName;
+ tagSize = src.tagSize;
+ pTag = src.pTag;
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::~safe_VkDebugMarkerObjectTagInfoEXT()
+{
+}
+
+void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ objectType = in_struct->objectType;
+ object = in_struct->object;
+ tagName = in_struct->tagName;
+ tagSize = in_struct->tagSize;
+ pTag = in_struct->pTag;
+}
+
+void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ objectType = src->objectType;
+ object = src->object;
+ tagName = src->tagName;
+ tagSize = src->tagSize;
+ pTag = src->pTag;
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pMarkerName(in_struct->pMarkerName)
+{
+ for (uint32_t i=0; i<4; ++i) {
+ color[i] = in_struct->color[i];
+ }
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT()
+{}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pMarkerName = src.pMarkerName;
+ for (uint32_t i=0; i<4; ++i) {
+ color[i] = src.color[i];
+ }
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::~safe_VkDebugMarkerMarkerInfoEXT()
+{
+}
+
+void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pMarkerName = in_struct->pMarkerName;
+ for (uint32_t i=0; i<4; ++i) {
+ color[i] = in_struct->color[i];
+ }
+}
+
+void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pMarkerName = src->pMarkerName;
+ for (uint32_t i=0; i<4; ++i) {
+ color[i] = src->color[i];
+ }
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ dedicatedAllocation(in_struct->dedicatedAllocation)
+{
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV()
+{}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ dedicatedAllocation = src.dedicatedAllocation;
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::~safe_VkDedicatedAllocationImageCreateInfoNV()
+{
+}
+
+void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ dedicatedAllocation = in_struct->dedicatedAllocation;
+}
+
+void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ dedicatedAllocation = src->dedicatedAllocation;
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ dedicatedAllocation(in_struct->dedicatedAllocation)
+{
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV()
+{}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ dedicatedAllocation = src.dedicatedAllocation;
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::~safe_VkDedicatedAllocationBufferCreateInfoNV()
+{
+}
+
+void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ dedicatedAllocation = in_struct->dedicatedAllocation;
+}
+
+void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ dedicatedAllocation = src->dedicatedAllocation;
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ image(in_struct->image),
+ buffer(in_struct->buffer)
+{
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV()
+{}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ image = src.image;
+ buffer = src.buffer;
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::~safe_VkDedicatedAllocationMemoryAllocateInfoNV()
+{
+}
+
+void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ image = in_struct->image;
+ buffer = in_struct->buffer;
+}
+
+void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ image = src->image;
+ buffer = src->buffer;
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ supportsTextureGatherLODBiasAMD(in_struct->supportsTextureGatherLODBiasAMD)
+{
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD()
+{}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ supportsTextureGatherLODBiasAMD = src.supportsTextureGatherLODBiasAMD;
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::~safe_VkTextureLODGatherFormatPropertiesAMD()
+{
+}
+
+void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ supportsTextureGatherLODBiasAMD = in_struct->supportsTextureGatherLODBiasAMD;
+}
+
+void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ supportsTextureGatherLODBiasAMD = src->supportsTextureGatherLODBiasAMD;
+}
+
+safe_VkRenderPassMultiviewCreateInfoKHX::safe_VkRenderPassMultiviewCreateInfoKHX(const VkRenderPassMultiviewCreateInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ subpassCount(in_struct->subpassCount),
+ pViewMasks(nullptr),
+ dependencyCount(in_struct->dependencyCount),
+ pViewOffsets(nullptr),
+ correlationMaskCount(in_struct->correlationMaskCount),
+ pCorrelationMasks(nullptr)
+{
+ if (in_struct->pViewMasks) {
+ pViewMasks = new uint32_t[in_struct->subpassCount];
+ memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
+ }
+ if (in_struct->pViewOffsets) {
+ pViewOffsets = new int32_t[in_struct->dependencyCount];
+ memcpy ((void *)pViewOffsets, (void *)in_struct->pViewOffsets, sizeof(int32_t)*in_struct->dependencyCount);
+ }
+ if (in_struct->pCorrelationMasks) {
+ pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
+ memcpy ((void *)pCorrelationMasks, (void *)in_struct->pCorrelationMasks, sizeof(uint32_t)*in_struct->correlationMaskCount);
+ }
+}
+
+safe_VkRenderPassMultiviewCreateInfoKHX::safe_VkRenderPassMultiviewCreateInfoKHX() :
+ pViewMasks(nullptr),
+ pViewOffsets(nullptr),
+ pCorrelationMasks(nullptr)
+{}
+
+safe_VkRenderPassMultiviewCreateInfoKHX::safe_VkRenderPassMultiviewCreateInfoKHX(const safe_VkRenderPassMultiviewCreateInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ subpassCount = src.subpassCount;
+ pViewMasks = nullptr;
+ dependencyCount = src.dependencyCount;
+ pViewOffsets = nullptr;
+ correlationMaskCount = src.correlationMaskCount;
+ pCorrelationMasks = nullptr;
+ if (src.pViewMasks) {
+ pViewMasks = new uint32_t[src.subpassCount];
+ memcpy ((void *)pViewMasks, (void *)src.pViewMasks, sizeof(uint32_t)*src.subpassCount);
+ }
+ if (src.pViewOffsets) {
+ pViewOffsets = new int32_t[src.dependencyCount];
+ memcpy ((void *)pViewOffsets, (void *)src.pViewOffsets, sizeof(int32_t)*src.dependencyCount);
+ }
+ if (src.pCorrelationMasks) {
+ pCorrelationMasks = new uint32_t[src.correlationMaskCount];
+ memcpy ((void *)pCorrelationMasks, (void *)src.pCorrelationMasks, sizeof(uint32_t)*src.correlationMaskCount);
+ }
+}
+
+safe_VkRenderPassMultiviewCreateInfoKHX::~safe_VkRenderPassMultiviewCreateInfoKHX()
+{
+ if (pViewMasks)
+ delete[] pViewMasks;
+ if (pViewOffsets)
+ delete[] pViewOffsets;
+ if (pCorrelationMasks)
+ delete[] pCorrelationMasks;
+}
+
+void safe_VkRenderPassMultiviewCreateInfoKHX::initialize(const VkRenderPassMultiviewCreateInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ subpassCount = in_struct->subpassCount;
+ pViewMasks = nullptr;
+ dependencyCount = in_struct->dependencyCount;
+ pViewOffsets = nullptr;
+ correlationMaskCount = in_struct->correlationMaskCount;
+ pCorrelationMasks = nullptr;
+ if (in_struct->pViewMasks) {
+ pViewMasks = new uint32_t[in_struct->subpassCount];
+ memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
+ }
+ if (in_struct->pViewOffsets) {
+ pViewOffsets = new int32_t[in_struct->dependencyCount];
+ memcpy ((void *)pViewOffsets, (void *)in_struct->pViewOffsets, sizeof(int32_t)*in_struct->dependencyCount);
+ }
+ if (in_struct->pCorrelationMasks) {
+ pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
+ memcpy ((void *)pCorrelationMasks, (void *)in_struct->pCorrelationMasks, sizeof(uint32_t)*in_struct->correlationMaskCount);
+ }
+}
+
+void safe_VkRenderPassMultiviewCreateInfoKHX::initialize(const safe_VkRenderPassMultiviewCreateInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ subpassCount = src->subpassCount;
+ pViewMasks = nullptr;
+ dependencyCount = src->dependencyCount;
+ pViewOffsets = nullptr;
+ correlationMaskCount = src->correlationMaskCount;
+ pCorrelationMasks = nullptr;
+ if (src->pViewMasks) {
+ pViewMasks = new uint32_t[src->subpassCount];
+ memcpy ((void *)pViewMasks, (void *)src->pViewMasks, sizeof(uint32_t)*src->subpassCount);
+ }
+ if (src->pViewOffsets) {
+ pViewOffsets = new int32_t[src->dependencyCount];
+ memcpy ((void *)pViewOffsets, (void *)src->pViewOffsets, sizeof(int32_t)*src->dependencyCount);
+ }
+ if (src->pCorrelationMasks) {
+ pCorrelationMasks = new uint32_t[src->correlationMaskCount];
+ memcpy ((void *)pCorrelationMasks, (void *)src->pCorrelationMasks, sizeof(uint32_t)*src->correlationMaskCount);
+ }
+}
+
+safe_VkPhysicalDeviceMultiviewFeaturesKHX::safe_VkPhysicalDeviceMultiviewFeaturesKHX(const VkPhysicalDeviceMultiviewFeaturesKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ multiview(in_struct->multiview),
+ multiviewGeometryShader(in_struct->multiviewGeometryShader),
+ multiviewTessellationShader(in_struct->multiviewTessellationShader)
+{
+}
+
+safe_VkPhysicalDeviceMultiviewFeaturesKHX::safe_VkPhysicalDeviceMultiviewFeaturesKHX()
+{}
+
+safe_VkPhysicalDeviceMultiviewFeaturesKHX::safe_VkPhysicalDeviceMultiviewFeaturesKHX(const safe_VkPhysicalDeviceMultiviewFeaturesKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ multiview = src.multiview;
+ multiviewGeometryShader = src.multiviewGeometryShader;
+ multiviewTessellationShader = src.multiviewTessellationShader;
+}
+
+safe_VkPhysicalDeviceMultiviewFeaturesKHX::~safe_VkPhysicalDeviceMultiviewFeaturesKHX()
+{
+}
+
+void safe_VkPhysicalDeviceMultiviewFeaturesKHX::initialize(const VkPhysicalDeviceMultiviewFeaturesKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ multiview = in_struct->multiview;
+ multiviewGeometryShader = in_struct->multiviewGeometryShader;
+ multiviewTessellationShader = in_struct->multiviewTessellationShader;
+}
+
+void safe_VkPhysicalDeviceMultiviewFeaturesKHX::initialize(const safe_VkPhysicalDeviceMultiviewFeaturesKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ multiview = src->multiview;
+ multiviewGeometryShader = src->multiviewGeometryShader;
+ multiviewTessellationShader = src->multiviewTessellationShader;
+}
+
+safe_VkPhysicalDeviceMultiviewPropertiesKHX::safe_VkPhysicalDeviceMultiviewPropertiesKHX(const VkPhysicalDeviceMultiviewPropertiesKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
+ maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex)
+{
+}
+
+safe_VkPhysicalDeviceMultiviewPropertiesKHX::safe_VkPhysicalDeviceMultiviewPropertiesKHX()
+{}
+
+safe_VkPhysicalDeviceMultiviewPropertiesKHX::safe_VkPhysicalDeviceMultiviewPropertiesKHX(const safe_VkPhysicalDeviceMultiviewPropertiesKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ maxMultiviewViewCount = src.maxMultiviewViewCount;
+ maxMultiviewInstanceIndex = src.maxMultiviewInstanceIndex;
+}
+
+safe_VkPhysicalDeviceMultiviewPropertiesKHX::~safe_VkPhysicalDeviceMultiviewPropertiesKHX()
+{
+}
+
+void safe_VkPhysicalDeviceMultiviewPropertiesKHX::initialize(const VkPhysicalDeviceMultiviewPropertiesKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
+ maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
+}
+
+void safe_VkPhysicalDeviceMultiviewPropertiesKHX::initialize(const safe_VkPhysicalDeviceMultiviewPropertiesKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ maxMultiviewViewCount = src->maxMultiviewViewCount;
+ maxMultiviewInstanceIndex = src->maxMultiviewInstanceIndex;
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV()
+{}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::~safe_VkExternalMemoryImageCreateInfoNV()
+{
+}
+
+void safe_VkExternalMemoryImageCreateInfoNV::initialize(const VkExternalMemoryImageCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleTypes(in_struct->handleTypes)
+{
+}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV()
+{}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleTypes = src.handleTypes;
+}
+
+safe_VkExportMemoryAllocateInfoNV::~safe_VkExportMemoryAllocateInfoNV()
+{
+}
+
+void safe_VkExportMemoryAllocateInfoNV::initialize(const VkExportMemoryAllocateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleTypes = in_struct->handleTypes;
+}
+
+void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleTypes = src->handleTypes;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ handleType(in_struct->handleType),
+ handle(in_struct->handle)
+{
+}
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV()
+{}
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ handleType = src.handleType;
+ handle = src.handle;
+}
+
+safe_VkImportMemoryWin32HandleInfoNV::~safe_VkImportMemoryWin32HandleInfoNV()
+{
+}
+
+void safe_VkImportMemoryWin32HandleInfoNV::initialize(const VkImportMemoryWin32HandleInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ handleType = in_struct->handleType;
+ handle = in_struct->handle;
+}
+
+void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ handleType = src->handleType;
+ handle = src->handle;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pAttributes(nullptr),
+ dwAccess(in_struct->dwAccess)
+{
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV() :
+ pAttributes(nullptr)
+{}
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pAttributes = nullptr;
+ dwAccess = src.dwAccess;
+ if (src.pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
+ }
+}
+
+safe_VkExportMemoryWin32HandleInfoNV::~safe_VkExportMemoryWin32HandleInfoNV()
+{
+ if (pAttributes)
+ delete pAttributes;
+}
+
+void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32HandleInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pAttributes = nullptr;
+ dwAccess = in_struct->dwAccess;
+ if (in_struct->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+ }
+}
+
+void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pAttributes = nullptr;
+ dwAccess = src->dwAccess;
+ if (src->pAttributes) {
+ pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ acquireCount(in_struct->acquireCount),
+ pAcquireSyncs(nullptr),
+ pAcquireKeys(nullptr),
+ pAcquireTimeoutMilliseconds(nullptr),
+ releaseCount(in_struct->releaseCount),
+ pReleaseSyncs(nullptr),
+ pReleaseKeys(nullptr)
+{
+ if (acquireCount && in_struct->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+ }
+ }
+ if (in_struct->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
+ }
+ if (in_struct->pAcquireTimeoutMilliseconds) {
+ pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)in_struct->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*in_struct->acquireCount);
+ }
+ if (releaseCount && in_struct->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+ }
+ }
+ if (in_struct->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[in_struct->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
+ }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV() :
+ pAcquireSyncs(nullptr),
+ pAcquireKeys(nullptr),
+ pAcquireTimeoutMilliseconds(nullptr),
+ pReleaseSyncs(nullptr),
+ pReleaseKeys(nullptr)
+{}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ acquireCount = src.acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeoutMilliseconds = nullptr;
+ releaseCount = src.releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && src.pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = src.pAcquireSyncs[i];
+ }
+ }
+ if (src.pAcquireKeys) {
+ pAcquireKeys = new uint64_t[src.acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)src.pAcquireKeys, sizeof(uint64_t)*src.acquireCount);
+ }
+ if (src.pAcquireTimeoutMilliseconds) {
+ pAcquireTimeoutMilliseconds = new uint32_t[src.acquireCount];
+ memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)src.pAcquireTimeoutMilliseconds, sizeof(uint32_t)*src.acquireCount);
+ }
+ if (releaseCount && src.pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = src.pReleaseSyncs[i];
+ }
+ }
+ if (src.pReleaseKeys) {
+ pReleaseKeys = new uint64_t[src.releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)src.pReleaseKeys, sizeof(uint64_t)*src.releaseCount);
+ }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::~safe_VkWin32KeyedMutexAcquireReleaseInfoNV()
+{
+ if (pAcquireSyncs)
+ delete[] pAcquireSyncs;
+ if (pAcquireKeys)
+ delete[] pAcquireKeys;
+ if (pAcquireTimeoutMilliseconds)
+ delete[] pAcquireTimeoutMilliseconds;
+ if (pReleaseSyncs)
+ delete[] pReleaseSyncs;
+ if (pReleaseKeys)
+ delete[] pReleaseKeys;
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ acquireCount = in_struct->acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeoutMilliseconds = nullptr;
+ releaseCount = in_struct->releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && in_struct->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+ }
+ }
+ if (in_struct->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)in_struct->pAcquireKeys, sizeof(uint64_t)*in_struct->acquireCount);
+ }
+ if (in_struct->pAcquireTimeoutMilliseconds) {
+ pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
+ memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)in_struct->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*in_struct->acquireCount);
+ }
+ if (releaseCount && in_struct->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+ }
+ }
+ if (in_struct->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[in_struct->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)in_struct->pReleaseKeys, sizeof(uint64_t)*in_struct->releaseCount);
+ }
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ acquireCount = src->acquireCount;
+ pAcquireSyncs = nullptr;
+ pAcquireKeys = nullptr;
+ pAcquireTimeoutMilliseconds = nullptr;
+ releaseCount = src->releaseCount;
+ pReleaseSyncs = nullptr;
+ pReleaseKeys = nullptr;
+ if (acquireCount && src->pAcquireSyncs) {
+ pAcquireSyncs = new VkDeviceMemory[acquireCount];
+ for (uint32_t i=0; i<acquireCount; ++i) {
+ pAcquireSyncs[i] = src->pAcquireSyncs[i];
+ }
+ }
+ if (src->pAcquireKeys) {
+ pAcquireKeys = new uint64_t[src->acquireCount];
+ memcpy ((void *)pAcquireKeys, (void *)src->pAcquireKeys, sizeof(uint64_t)*src->acquireCount);
+ }
+ if (src->pAcquireTimeoutMilliseconds) {
+ pAcquireTimeoutMilliseconds = new uint32_t[src->acquireCount];
+ memcpy ((void *)pAcquireTimeoutMilliseconds, (void *)src->pAcquireTimeoutMilliseconds, sizeof(uint32_t)*src->acquireCount);
+ }
+ if (releaseCount && src->pReleaseSyncs) {
+ pReleaseSyncs = new VkDeviceMemory[releaseCount];
+ for (uint32_t i=0; i<releaseCount; ++i) {
+ pReleaseSyncs[i] = src->pReleaseSyncs[i];
+ }
+ }
+ if (src->pReleaseKeys) {
+ pReleaseKeys = new uint64_t[src->releaseCount];
+ memcpy ((void *)pReleaseKeys, (void *)src->pReleaseKeys, sizeof(uint64_t)*src->releaseCount);
+ }
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+
+safe_VkMemoryAllocateFlagsInfoKHX::safe_VkMemoryAllocateFlagsInfoKHX(const VkMemoryAllocateFlagsInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ deviceMask(in_struct->deviceMask)
+{
+}
+
+safe_VkMemoryAllocateFlagsInfoKHX::safe_VkMemoryAllocateFlagsInfoKHX()
+{}
+
+safe_VkMemoryAllocateFlagsInfoKHX::safe_VkMemoryAllocateFlagsInfoKHX(const safe_VkMemoryAllocateFlagsInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ deviceMask = src.deviceMask;
+}
+
+safe_VkMemoryAllocateFlagsInfoKHX::~safe_VkMemoryAllocateFlagsInfoKHX()
+{
+}
+
+void safe_VkMemoryAllocateFlagsInfoKHX::initialize(const VkMemoryAllocateFlagsInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ deviceMask = in_struct->deviceMask;
+}
+
+void safe_VkMemoryAllocateFlagsInfoKHX::initialize(const safe_VkMemoryAllocateFlagsInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ deviceMask = src->deviceMask;
+}
+
+safe_VkBindBufferMemoryInfoKHX::safe_VkBindBufferMemoryInfoKHX(const VkBindBufferMemoryInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ buffer(in_struct->buffer),
+ memory(in_struct->memory),
+ memoryOffset(in_struct->memoryOffset),
+ deviceIndexCount(in_struct->deviceIndexCount),
+ pDeviceIndices(nullptr)
+{
+ if (in_struct->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
+ }
+}
+
+safe_VkBindBufferMemoryInfoKHX::safe_VkBindBufferMemoryInfoKHX() :
+ pDeviceIndices(nullptr)
+{}
+
+safe_VkBindBufferMemoryInfoKHX::safe_VkBindBufferMemoryInfoKHX(const safe_VkBindBufferMemoryInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ buffer = src.buffer;
+ memory = src.memory;
+ memoryOffset = src.memoryOffset;
+ deviceIndexCount = src.deviceIndexCount;
+ pDeviceIndices = nullptr;
+ if (src.pDeviceIndices) {
+ pDeviceIndices = new uint32_t[src.deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
+ }
+}
+
+safe_VkBindBufferMemoryInfoKHX::~safe_VkBindBufferMemoryInfoKHX()
+{
+ if (pDeviceIndices)
+ delete[] pDeviceIndices;
+}
+
+void safe_VkBindBufferMemoryInfoKHX::initialize(const VkBindBufferMemoryInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ buffer = in_struct->buffer;
+ memory = in_struct->memory;
+ memoryOffset = in_struct->memoryOffset;
+ deviceIndexCount = in_struct->deviceIndexCount;
+ pDeviceIndices = nullptr;
+ if (in_struct->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
+ }
+}
+
+void safe_VkBindBufferMemoryInfoKHX::initialize(const safe_VkBindBufferMemoryInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ buffer = src->buffer;
+ memory = src->memory;
+ memoryOffset = src->memoryOffset;
+ deviceIndexCount = src->deviceIndexCount;
+ pDeviceIndices = nullptr;
+ if (src->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[src->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)src->pDeviceIndices, sizeof(uint32_t)*src->deviceIndexCount);
+ }
+}
+
+safe_VkBindImageMemoryInfoKHX::safe_VkBindImageMemoryInfoKHX(const VkBindImageMemoryInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ image(in_struct->image),
+ memory(in_struct->memory),
+ memoryOffset(in_struct->memoryOffset),
+ deviceIndexCount(in_struct->deviceIndexCount),
+ pDeviceIndices(nullptr),
+ SFRRectCount(in_struct->SFRRectCount),
+ pSFRRects(nullptr)
+{
+ if (in_struct->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
+ }
+ if (in_struct->pSFRRects) {
+ pSFRRects = new VkRect2D[in_struct->SFRRectCount];
+ memcpy ((void *)pSFRRects, (void *)in_struct->pSFRRects, sizeof(VkRect2D)*in_struct->SFRRectCount);
+ }
+}
+
+safe_VkBindImageMemoryInfoKHX::safe_VkBindImageMemoryInfoKHX() :
+ pDeviceIndices(nullptr),
+ pSFRRects(nullptr)
+{}
+
+safe_VkBindImageMemoryInfoKHX::safe_VkBindImageMemoryInfoKHX(const safe_VkBindImageMemoryInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ image = src.image;
+ memory = src.memory;
+ memoryOffset = src.memoryOffset;
+ deviceIndexCount = src.deviceIndexCount;
+ pDeviceIndices = nullptr;
+ SFRRectCount = src.SFRRectCount;
+ pSFRRects = nullptr;
+ if (src.pDeviceIndices) {
+ pDeviceIndices = new uint32_t[src.deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
+ }
+ if (src.pSFRRects) {
+ pSFRRects = new VkRect2D[src.SFRRectCount];
+ memcpy ((void *)pSFRRects, (void *)src.pSFRRects, sizeof(VkRect2D)*src.SFRRectCount);
+ }
+}
+
+safe_VkBindImageMemoryInfoKHX::~safe_VkBindImageMemoryInfoKHX()
+{
+ if (pDeviceIndices)
+ delete[] pDeviceIndices;
+ if (pSFRRects)
+ delete[] pSFRRects;
+}
+
+void safe_VkBindImageMemoryInfoKHX::initialize(const VkBindImageMemoryInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ image = in_struct->image;
+ memory = in_struct->memory;
+ memoryOffset = in_struct->memoryOffset;
+ deviceIndexCount = in_struct->deviceIndexCount;
+ pDeviceIndices = nullptr;
+ SFRRectCount = in_struct->SFRRectCount;
+ pSFRRects = nullptr;
+ if (in_struct->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
+ }
+ if (in_struct->pSFRRects) {
+ pSFRRects = new VkRect2D[in_struct->SFRRectCount];
+ memcpy ((void *)pSFRRects, (void *)in_struct->pSFRRects, sizeof(VkRect2D)*in_struct->SFRRectCount);
+ }
+}
+
+void safe_VkBindImageMemoryInfoKHX::initialize(const safe_VkBindImageMemoryInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ image = src->image;
+ memory = src->memory;
+ memoryOffset = src->memoryOffset;
+ deviceIndexCount = src->deviceIndexCount;
+ pDeviceIndices = nullptr;
+ SFRRectCount = src->SFRRectCount;
+ pSFRRects = nullptr;
+ if (src->pDeviceIndices) {
+ pDeviceIndices = new uint32_t[src->deviceIndexCount];
+ memcpy ((void *)pDeviceIndices, (void *)src->pDeviceIndices, sizeof(uint32_t)*src->deviceIndexCount);
+ }
+ if (src->pSFRRects) {
+ pSFRRects = new VkRect2D[src->SFRRectCount];
+ memcpy ((void *)pSFRRects, (void *)src->pSFRRects, sizeof(VkRect2D)*src->SFRRectCount);
+ }
+}
+
+safe_VkDeviceGroupRenderPassBeginInfoKHX::safe_VkDeviceGroupRenderPassBeginInfoKHX(const VkDeviceGroupRenderPassBeginInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ deviceMask(in_struct->deviceMask),
+ deviceRenderAreaCount(in_struct->deviceRenderAreaCount),
+ pDeviceRenderAreas(nullptr)
+{
+ if (in_struct->pDeviceRenderAreas) {
+ pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
+ memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
+ }
+}
+
+safe_VkDeviceGroupRenderPassBeginInfoKHX::safe_VkDeviceGroupRenderPassBeginInfoKHX() :
+ pDeviceRenderAreas(nullptr)
+{}
+
+safe_VkDeviceGroupRenderPassBeginInfoKHX::safe_VkDeviceGroupRenderPassBeginInfoKHX(const safe_VkDeviceGroupRenderPassBeginInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ deviceMask = src.deviceMask;
+ deviceRenderAreaCount = src.deviceRenderAreaCount;
+ pDeviceRenderAreas = nullptr;
+ if (src.pDeviceRenderAreas) {
+ pDeviceRenderAreas = new VkRect2D[src.deviceRenderAreaCount];
+ memcpy ((void *)pDeviceRenderAreas, (void *)src.pDeviceRenderAreas, sizeof(VkRect2D)*src.deviceRenderAreaCount);
+ }
+}
+
+safe_VkDeviceGroupRenderPassBeginInfoKHX::~safe_VkDeviceGroupRenderPassBeginInfoKHX()
+{
+ if (pDeviceRenderAreas)
+ delete[] pDeviceRenderAreas;
+}
+
+void safe_VkDeviceGroupRenderPassBeginInfoKHX::initialize(const VkDeviceGroupRenderPassBeginInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ deviceMask = in_struct->deviceMask;
+ deviceRenderAreaCount = in_struct->deviceRenderAreaCount;
+ pDeviceRenderAreas = nullptr;
+ if (in_struct->pDeviceRenderAreas) {
+ pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
+ memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
+ }
+}
+
+void safe_VkDeviceGroupRenderPassBeginInfoKHX::initialize(const safe_VkDeviceGroupRenderPassBeginInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ deviceMask = src->deviceMask;
+ deviceRenderAreaCount = src->deviceRenderAreaCount;
+ pDeviceRenderAreas = nullptr;
+ if (src->pDeviceRenderAreas) {
+ pDeviceRenderAreas = new VkRect2D[src->deviceRenderAreaCount];
+ memcpy ((void *)pDeviceRenderAreas, (void *)src->pDeviceRenderAreas, sizeof(VkRect2D)*src->deviceRenderAreaCount);
+ }
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfoKHX::safe_VkDeviceGroupCommandBufferBeginInfoKHX(const VkDeviceGroupCommandBufferBeginInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ deviceMask(in_struct->deviceMask)
+{
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfoKHX::safe_VkDeviceGroupCommandBufferBeginInfoKHX()
+{}
+
+safe_VkDeviceGroupCommandBufferBeginInfoKHX::safe_VkDeviceGroupCommandBufferBeginInfoKHX(const safe_VkDeviceGroupCommandBufferBeginInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ deviceMask = src.deviceMask;
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfoKHX::~safe_VkDeviceGroupCommandBufferBeginInfoKHX()
+{
+}
+
+void safe_VkDeviceGroupCommandBufferBeginInfoKHX::initialize(const VkDeviceGroupCommandBufferBeginInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ deviceMask = in_struct->deviceMask;
+}
+
+void safe_VkDeviceGroupCommandBufferBeginInfoKHX::initialize(const safe_VkDeviceGroupCommandBufferBeginInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ deviceMask = src->deviceMask;
+}
+
+safe_VkDeviceGroupSubmitInfoKHX::safe_VkDeviceGroupSubmitInfoKHX(const VkDeviceGroupSubmitInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ waitSemaphoreCount(in_struct->waitSemaphoreCount),
+ pWaitSemaphoreDeviceIndices(nullptr),
+ commandBufferCount(in_struct->commandBufferCount),
+ pCommandBufferDeviceMasks(nullptr),
+ signalSemaphoreCount(in_struct->signalSemaphoreCount),
+ pSignalSemaphoreDeviceIndices(nullptr)
+{
+ if (in_struct->pWaitSemaphoreDeviceIndices) {
+ pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
+ memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
+ }
+ if (in_struct->pCommandBufferDeviceMasks) {
+ pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
+ memcpy ((void *)pCommandBufferDeviceMasks, (void *)in_struct->pCommandBufferDeviceMasks, sizeof(uint32_t)*in_struct->commandBufferCount);
+ }
+ if (in_struct->pSignalSemaphoreDeviceIndices) {
+ pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
+ memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)in_struct->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->signalSemaphoreCount);
+ }
+}
+
+safe_VkDeviceGroupSubmitInfoKHX::safe_VkDeviceGroupSubmitInfoKHX() :
+ pWaitSemaphoreDeviceIndices(nullptr),
+ pCommandBufferDeviceMasks(nullptr),
+ pSignalSemaphoreDeviceIndices(nullptr)
+{}
+
+safe_VkDeviceGroupSubmitInfoKHX::safe_VkDeviceGroupSubmitInfoKHX(const safe_VkDeviceGroupSubmitInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ waitSemaphoreCount = src.waitSemaphoreCount;
+ pWaitSemaphoreDeviceIndices = nullptr;
+ commandBufferCount = src.commandBufferCount;
+ pCommandBufferDeviceMasks = nullptr;
+ signalSemaphoreCount = src.signalSemaphoreCount;
+ pSignalSemaphoreDeviceIndices = nullptr;
+ if (src.pWaitSemaphoreDeviceIndices) {
+ pWaitSemaphoreDeviceIndices = new uint32_t[src.waitSemaphoreCount];
+ memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)src.pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*src.waitSemaphoreCount);
+ }
+ if (src.pCommandBufferDeviceMasks) {
+ pCommandBufferDeviceMasks = new uint32_t[src.commandBufferCount];
+ memcpy ((void *)pCommandBufferDeviceMasks, (void *)src.pCommandBufferDeviceMasks, sizeof(uint32_t)*src.commandBufferCount);
+ }
+ if (src.pSignalSemaphoreDeviceIndices) {
+ pSignalSemaphoreDeviceIndices = new uint32_t[src.signalSemaphoreCount];
+ memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)src.pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*src.signalSemaphoreCount);
+ }
+}
+
+safe_VkDeviceGroupSubmitInfoKHX::~safe_VkDeviceGroupSubmitInfoKHX()
+{
+ if (pWaitSemaphoreDeviceIndices)
+ delete[] pWaitSemaphoreDeviceIndices;
+ if (pCommandBufferDeviceMasks)
+ delete[] pCommandBufferDeviceMasks;
+ if (pSignalSemaphoreDeviceIndices)
+ delete[] pSignalSemaphoreDeviceIndices;
+}
+
+void safe_VkDeviceGroupSubmitInfoKHX::initialize(const VkDeviceGroupSubmitInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ waitSemaphoreCount = in_struct->waitSemaphoreCount;
+ pWaitSemaphoreDeviceIndices = nullptr;
+ commandBufferCount = in_struct->commandBufferCount;
+ pCommandBufferDeviceMasks = nullptr;
+ signalSemaphoreCount = in_struct->signalSemaphoreCount;
+ pSignalSemaphoreDeviceIndices = nullptr;
+ if (in_struct->pWaitSemaphoreDeviceIndices) {
+ pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
+ memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
+ }
+ if (in_struct->pCommandBufferDeviceMasks) {
+ pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
+ memcpy ((void *)pCommandBufferDeviceMasks, (void *)in_struct->pCommandBufferDeviceMasks, sizeof(uint32_t)*in_struct->commandBufferCount);
+ }
+ if (in_struct->pSignalSemaphoreDeviceIndices) {
+ pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
+ memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)in_struct->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->signalSemaphoreCount);
+ }
+}
+
+void safe_VkDeviceGroupSubmitInfoKHX::initialize(const safe_VkDeviceGroupSubmitInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ waitSemaphoreCount = src->waitSemaphoreCount;
+ pWaitSemaphoreDeviceIndices = nullptr;
+ commandBufferCount = src->commandBufferCount;
+ pCommandBufferDeviceMasks = nullptr;
+ signalSemaphoreCount = src->signalSemaphoreCount;
+ pSignalSemaphoreDeviceIndices = nullptr;
+ if (src->pWaitSemaphoreDeviceIndices) {
+ pWaitSemaphoreDeviceIndices = new uint32_t[src->waitSemaphoreCount];
+ memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)src->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*src->waitSemaphoreCount);
+ }
+ if (src->pCommandBufferDeviceMasks) {
+ pCommandBufferDeviceMasks = new uint32_t[src->commandBufferCount];
+ memcpy ((void *)pCommandBufferDeviceMasks, (void *)src->pCommandBufferDeviceMasks, sizeof(uint32_t)*src->commandBufferCount);
+ }
+ if (src->pSignalSemaphoreDeviceIndices) {
+ pSignalSemaphoreDeviceIndices = new uint32_t[src->signalSemaphoreCount];
+ memcpy ((void *)pSignalSemaphoreDeviceIndices, (void *)src->pSignalSemaphoreDeviceIndices, sizeof(uint32_t)*src->signalSemaphoreCount);
+ }
+}
+
+safe_VkDeviceGroupBindSparseInfoKHX::safe_VkDeviceGroupBindSparseInfoKHX(const VkDeviceGroupBindSparseInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ resourceDeviceIndex(in_struct->resourceDeviceIndex),
+ memoryDeviceIndex(in_struct->memoryDeviceIndex)
+{
+}
+
+safe_VkDeviceGroupBindSparseInfoKHX::safe_VkDeviceGroupBindSparseInfoKHX()
+{}
+
+safe_VkDeviceGroupBindSparseInfoKHX::safe_VkDeviceGroupBindSparseInfoKHX(const safe_VkDeviceGroupBindSparseInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ resourceDeviceIndex = src.resourceDeviceIndex;
+ memoryDeviceIndex = src.memoryDeviceIndex;
+}
+
+safe_VkDeviceGroupBindSparseInfoKHX::~safe_VkDeviceGroupBindSparseInfoKHX()
+{
+}
+
+void safe_VkDeviceGroupBindSparseInfoKHX::initialize(const VkDeviceGroupBindSparseInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ resourceDeviceIndex = in_struct->resourceDeviceIndex;
+ memoryDeviceIndex = in_struct->memoryDeviceIndex;
+}
+
+void safe_VkDeviceGroupBindSparseInfoKHX::initialize(const safe_VkDeviceGroupBindSparseInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ resourceDeviceIndex = src->resourceDeviceIndex;
+ memoryDeviceIndex = src->memoryDeviceIndex;
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHX::safe_VkDeviceGroupPresentCapabilitiesKHX(const VkDeviceGroupPresentCapabilitiesKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ modes(in_struct->modes)
+{
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ presentMask[i] = in_struct->presentMask[i];
+ }
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHX::safe_VkDeviceGroupPresentCapabilitiesKHX()
+{}
+
+safe_VkDeviceGroupPresentCapabilitiesKHX::safe_VkDeviceGroupPresentCapabilitiesKHX(const safe_VkDeviceGroupPresentCapabilitiesKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ modes = src.modes;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ presentMask[i] = src.presentMask[i];
+ }
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHX::~safe_VkDeviceGroupPresentCapabilitiesKHX()
+{
+}
+
+void safe_VkDeviceGroupPresentCapabilitiesKHX::initialize(const VkDeviceGroupPresentCapabilitiesKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ modes = in_struct->modes;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ presentMask[i] = in_struct->presentMask[i];
+ }
+}
+
+void safe_VkDeviceGroupPresentCapabilitiesKHX::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ modes = src->modes;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ presentMask[i] = src->presentMask[i];
+ }
+}
+
+safe_VkImageSwapchainCreateInfoKHX::safe_VkImageSwapchainCreateInfoKHX(const VkImageSwapchainCreateInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchain(in_struct->swapchain)
+{
+}
+
+safe_VkImageSwapchainCreateInfoKHX::safe_VkImageSwapchainCreateInfoKHX()
+{}
+
+safe_VkImageSwapchainCreateInfoKHX::safe_VkImageSwapchainCreateInfoKHX(const safe_VkImageSwapchainCreateInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchain = src.swapchain;
+}
+
+safe_VkImageSwapchainCreateInfoKHX::~safe_VkImageSwapchainCreateInfoKHX()
+{
+}
+
+void safe_VkImageSwapchainCreateInfoKHX::initialize(const VkImageSwapchainCreateInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchain = in_struct->swapchain;
+}
+
+void safe_VkImageSwapchainCreateInfoKHX::initialize(const safe_VkImageSwapchainCreateInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchain = src->swapchain;
+}
+
+safe_VkBindImageMemorySwapchainInfoKHX::safe_VkBindImageMemorySwapchainInfoKHX(const VkBindImageMemorySwapchainInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchain(in_struct->swapchain),
+ imageIndex(in_struct->imageIndex)
+{
+}
+
+safe_VkBindImageMemorySwapchainInfoKHX::safe_VkBindImageMemorySwapchainInfoKHX()
+{}
+
+safe_VkBindImageMemorySwapchainInfoKHX::safe_VkBindImageMemorySwapchainInfoKHX(const safe_VkBindImageMemorySwapchainInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchain = src.swapchain;
+ imageIndex = src.imageIndex;
+}
+
+safe_VkBindImageMemorySwapchainInfoKHX::~safe_VkBindImageMemorySwapchainInfoKHX()
+{
+}
+
+void safe_VkBindImageMemorySwapchainInfoKHX::initialize(const VkBindImageMemorySwapchainInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchain = in_struct->swapchain;
+ imageIndex = in_struct->imageIndex;
+}
+
+void safe_VkBindImageMemorySwapchainInfoKHX::initialize(const safe_VkBindImageMemorySwapchainInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchain = src->swapchain;
+ imageIndex = src->imageIndex;
+}
+
+safe_VkAcquireNextImageInfoKHX::safe_VkAcquireNextImageInfoKHX(const VkAcquireNextImageInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchain(in_struct->swapchain),
+ timeout(in_struct->timeout),
+ semaphore(in_struct->semaphore),
+ fence(in_struct->fence),
+ deviceMask(in_struct->deviceMask)
+{
+}
+
+safe_VkAcquireNextImageInfoKHX::safe_VkAcquireNextImageInfoKHX()
+{}
+
+safe_VkAcquireNextImageInfoKHX::safe_VkAcquireNextImageInfoKHX(const safe_VkAcquireNextImageInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchain = src.swapchain;
+ timeout = src.timeout;
+ semaphore = src.semaphore;
+ fence = src.fence;
+ deviceMask = src.deviceMask;
+}
+
+safe_VkAcquireNextImageInfoKHX::~safe_VkAcquireNextImageInfoKHX()
+{
+}
+
+void safe_VkAcquireNextImageInfoKHX::initialize(const VkAcquireNextImageInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchain = in_struct->swapchain;
+ timeout = in_struct->timeout;
+ semaphore = in_struct->semaphore;
+ fence = in_struct->fence;
+ deviceMask = in_struct->deviceMask;
+}
+
+void safe_VkAcquireNextImageInfoKHX::initialize(const safe_VkAcquireNextImageInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchain = src->swapchain;
+ timeout = src->timeout;
+ semaphore = src->semaphore;
+ fence = src->fence;
+ deviceMask = src->deviceMask;
+}
+
+safe_VkDeviceGroupPresentInfoKHX::safe_VkDeviceGroupPresentInfoKHX(const VkDeviceGroupPresentInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchainCount(in_struct->swapchainCount),
+ pDeviceMasks(nullptr),
+ mode(in_struct->mode)
+{
+ if (in_struct->pDeviceMasks) {
+ pDeviceMasks = new uint32_t[in_struct->swapchainCount];
+ memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
+ }
+}
+
+safe_VkDeviceGroupPresentInfoKHX::safe_VkDeviceGroupPresentInfoKHX() :
+ pDeviceMasks(nullptr)
+{}
+
+safe_VkDeviceGroupPresentInfoKHX::safe_VkDeviceGroupPresentInfoKHX(const safe_VkDeviceGroupPresentInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchainCount = src.swapchainCount;
+ pDeviceMasks = nullptr;
+ mode = src.mode;
+ if (src.pDeviceMasks) {
+ pDeviceMasks = new uint32_t[src.swapchainCount];
+ memcpy ((void *)pDeviceMasks, (void *)src.pDeviceMasks, sizeof(uint32_t)*src.swapchainCount);
+ }
+}
+
+safe_VkDeviceGroupPresentInfoKHX::~safe_VkDeviceGroupPresentInfoKHX()
+{
+ if (pDeviceMasks)
+ delete[] pDeviceMasks;
+}
+
+void safe_VkDeviceGroupPresentInfoKHX::initialize(const VkDeviceGroupPresentInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchainCount = in_struct->swapchainCount;
+ pDeviceMasks = nullptr;
+ mode = in_struct->mode;
+ if (in_struct->pDeviceMasks) {
+ pDeviceMasks = new uint32_t[in_struct->swapchainCount];
+ memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
+ }
+}
+
+void safe_VkDeviceGroupPresentInfoKHX::initialize(const safe_VkDeviceGroupPresentInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchainCount = src->swapchainCount;
+ pDeviceMasks = nullptr;
+ mode = src->mode;
+ if (src->pDeviceMasks) {
+ pDeviceMasks = new uint32_t[src->swapchainCount];
+ memcpy ((void *)pDeviceMasks, (void *)src->pDeviceMasks, sizeof(uint32_t)*src->swapchainCount);
+ }
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHX::safe_VkDeviceGroupSwapchainCreateInfoKHX(const VkDeviceGroupSwapchainCreateInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ modes(in_struct->modes)
+{
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHX::safe_VkDeviceGroupSwapchainCreateInfoKHX()
+{}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHX::safe_VkDeviceGroupSwapchainCreateInfoKHX(const safe_VkDeviceGroupSwapchainCreateInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ modes = src.modes;
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHX::~safe_VkDeviceGroupSwapchainCreateInfoKHX()
+{
+}
+
+void safe_VkDeviceGroupSwapchainCreateInfoKHX::initialize(const VkDeviceGroupSwapchainCreateInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ modes = in_struct->modes;
+}
+
+void safe_VkDeviceGroupSwapchainCreateInfoKHX::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ modes = src->modes;
+}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ disabledValidationCheckCount(in_struct->disabledValidationCheckCount),
+ pDisabledValidationChecks(nullptr)
+{
+ if (in_struct->pDisabledValidationChecks) {
+ pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
+ memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
+ }
+}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT() :
+ pDisabledValidationChecks(nullptr)
+{}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ disabledValidationCheckCount = src.disabledValidationCheckCount;
+ pDisabledValidationChecks = nullptr;
+ if (src.pDisabledValidationChecks) {
+ pDisabledValidationChecks = new VkValidationCheckEXT[src.disabledValidationCheckCount];
+ memcpy ((void *)pDisabledValidationChecks, (void *)src.pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*src.disabledValidationCheckCount);
+ }
+}
+
+safe_VkValidationFlagsEXT::~safe_VkValidationFlagsEXT()
+{
+ if (pDisabledValidationChecks)
+ delete[] pDisabledValidationChecks;
+}
+
+void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ disabledValidationCheckCount = in_struct->disabledValidationCheckCount;
+ pDisabledValidationChecks = nullptr;
+ if (in_struct->pDisabledValidationChecks) {
+ pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
+ memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
+ }
+}
+
+void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ disabledValidationCheckCount = src->disabledValidationCheckCount;
+ pDisabledValidationChecks = nullptr;
+ if (src->pDisabledValidationChecks) {
+ pDisabledValidationChecks = new VkValidationCheckEXT[src->disabledValidationCheckCount];
+ memcpy ((void *)pDisabledValidationChecks, (void *)src->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*src->disabledValidationCheckCount);
+ }
+}
+#ifdef VK_USE_PLATFORM_VI_NN
+
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ window(in_struct->window)
+{
+}
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN()
+{}
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ window = src.window;
+}
+
+safe_VkViSurfaceCreateInfoNN::~safe_VkViSurfaceCreateInfoNN()
+{
+}
+
+void safe_VkViSurfaceCreateInfoNN::initialize(const VkViSurfaceCreateInfoNN* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ window = in_struct->window;
+}
+
+void safe_VkViSurfaceCreateInfoNN::initialize(const safe_VkViSurfaceCreateInfoNN* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ window = src->window;
+}
+#endif // VK_USE_PLATFORM_VI_NN
+
+
+safe_VkPhysicalDeviceGroupPropertiesKHX::safe_VkPhysicalDeviceGroupPropertiesKHX(const VkPhysicalDeviceGroupPropertiesKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ physicalDeviceCount(in_struct->physicalDeviceCount),
+ subsetAllocation(in_struct->subsetAllocation)
+{
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ physicalDevices[i] = in_struct->physicalDevices[i];
+ }
+}
+
+safe_VkPhysicalDeviceGroupPropertiesKHX::safe_VkPhysicalDeviceGroupPropertiesKHX()
+{}
+
+safe_VkPhysicalDeviceGroupPropertiesKHX::safe_VkPhysicalDeviceGroupPropertiesKHX(const safe_VkPhysicalDeviceGroupPropertiesKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ physicalDeviceCount = src.physicalDeviceCount;
+ subsetAllocation = src.subsetAllocation;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ physicalDevices[i] = src.physicalDevices[i];
+ }
+}
+
+safe_VkPhysicalDeviceGroupPropertiesKHX::~safe_VkPhysicalDeviceGroupPropertiesKHX()
+{
+}
+
+void safe_VkPhysicalDeviceGroupPropertiesKHX::initialize(const VkPhysicalDeviceGroupPropertiesKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ physicalDeviceCount = in_struct->physicalDeviceCount;
+ subsetAllocation = in_struct->subsetAllocation;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ physicalDevices[i] = in_struct->physicalDevices[i];
+ }
+}
+
+void safe_VkPhysicalDeviceGroupPropertiesKHX::initialize(const safe_VkPhysicalDeviceGroupPropertiesKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ physicalDeviceCount = src->physicalDeviceCount;
+ subsetAllocation = src->subsetAllocation;
+ for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE_KHX; ++i) {
+ physicalDevices[i] = src->physicalDevices[i];
+ }
+}
+
+safe_VkDeviceGroupDeviceCreateInfoKHX::safe_VkDeviceGroupDeviceCreateInfoKHX(const VkDeviceGroupDeviceCreateInfoKHX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ physicalDeviceCount(in_struct->physicalDeviceCount),
+ pPhysicalDevices(nullptr)
+{
+ if (in_struct->pPhysicalDevices) {
+ pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
+ memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
+ }
+}
+
+safe_VkDeviceGroupDeviceCreateInfoKHX::safe_VkDeviceGroupDeviceCreateInfoKHX() :
+ pPhysicalDevices(nullptr)
+{}
+
+safe_VkDeviceGroupDeviceCreateInfoKHX::safe_VkDeviceGroupDeviceCreateInfoKHX(const safe_VkDeviceGroupDeviceCreateInfoKHX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ physicalDeviceCount = src.physicalDeviceCount;
+ pPhysicalDevices = nullptr;
+ if (src.pPhysicalDevices) {
+ pPhysicalDevices = new VkPhysicalDevice[src.physicalDeviceCount];
+ memcpy ((void *)pPhysicalDevices, (void *)src.pPhysicalDevices, sizeof(VkPhysicalDevice)*src.physicalDeviceCount);
+ }
+}
+
+safe_VkDeviceGroupDeviceCreateInfoKHX::~safe_VkDeviceGroupDeviceCreateInfoKHX()
+{
+ if (pPhysicalDevices)
+ delete[] pPhysicalDevices;
+}
+
+void safe_VkDeviceGroupDeviceCreateInfoKHX::initialize(const VkDeviceGroupDeviceCreateInfoKHX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ physicalDeviceCount = in_struct->physicalDeviceCount;
+ pPhysicalDevices = nullptr;
+ if (in_struct->pPhysicalDevices) {
+ pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
+ memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
+ }
+}
+
+void safe_VkDeviceGroupDeviceCreateInfoKHX::initialize(const safe_VkDeviceGroupDeviceCreateInfoKHX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ physicalDeviceCount = src->physicalDeviceCount;
+ pPhysicalDevices = nullptr;
+ if (src->pPhysicalDevices) {
+ pPhysicalDevices = new VkPhysicalDevice[src->physicalDeviceCount];
+ memcpy ((void *)pPhysicalDevices, (void *)src->pPhysicalDevices, sizeof(VkPhysicalDevice)*src->physicalDeviceCount);
+ }
+}
+
+safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ computeBindingPointSupport(in_struct->computeBindingPointSupport)
+{
+}
+
+safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX()
+{}
+
+safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ computeBindingPointSupport = src.computeBindingPointSupport;
+}
+
+safe_VkDeviceGeneratedCommandsFeaturesNVX::~safe_VkDeviceGeneratedCommandsFeaturesNVX()
+{
+}
+
+void safe_VkDeviceGeneratedCommandsFeaturesNVX::initialize(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ computeBindingPointSupport = in_struct->computeBindingPointSupport;
+}
+
+void safe_VkDeviceGeneratedCommandsFeaturesNVX::initialize(const safe_VkDeviceGeneratedCommandsFeaturesNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ computeBindingPointSupport = src->computeBindingPointSupport;
+}
+
+safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX(const VkDeviceGeneratedCommandsLimitsNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ maxIndirectCommandsLayoutTokenCount(in_struct->maxIndirectCommandsLayoutTokenCount),
+ maxObjectEntryCounts(in_struct->maxObjectEntryCounts),
+ minSequenceCountBufferOffsetAlignment(in_struct->minSequenceCountBufferOffsetAlignment),
+ minSequenceIndexBufferOffsetAlignment(in_struct->minSequenceIndexBufferOffsetAlignment),
+ minCommandsTokenBufferOffsetAlignment(in_struct->minCommandsTokenBufferOffsetAlignment)
+{
+}
+
+safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX()
+{}
+
+safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX(const safe_VkDeviceGeneratedCommandsLimitsNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ maxIndirectCommandsLayoutTokenCount = src.maxIndirectCommandsLayoutTokenCount;
+ maxObjectEntryCounts = src.maxObjectEntryCounts;
+ minSequenceCountBufferOffsetAlignment = src.minSequenceCountBufferOffsetAlignment;
+ minSequenceIndexBufferOffsetAlignment = src.minSequenceIndexBufferOffsetAlignment;
+ minCommandsTokenBufferOffsetAlignment = src.minCommandsTokenBufferOffsetAlignment;
+}
+
+safe_VkDeviceGeneratedCommandsLimitsNVX::~safe_VkDeviceGeneratedCommandsLimitsNVX()
+{
+}
+
+void safe_VkDeviceGeneratedCommandsLimitsNVX::initialize(const VkDeviceGeneratedCommandsLimitsNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ maxIndirectCommandsLayoutTokenCount = in_struct->maxIndirectCommandsLayoutTokenCount;
+ maxObjectEntryCounts = in_struct->maxObjectEntryCounts;
+ minSequenceCountBufferOffsetAlignment = in_struct->minSequenceCountBufferOffsetAlignment;
+ minSequenceIndexBufferOffsetAlignment = in_struct->minSequenceIndexBufferOffsetAlignment;
+ minCommandsTokenBufferOffsetAlignment = in_struct->minCommandsTokenBufferOffsetAlignment;
+}
+
+void safe_VkDeviceGeneratedCommandsLimitsNVX::initialize(const safe_VkDeviceGeneratedCommandsLimitsNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ maxIndirectCommandsLayoutTokenCount = src->maxIndirectCommandsLayoutTokenCount;
+ maxObjectEntryCounts = src->maxObjectEntryCounts;
+ minSequenceCountBufferOffsetAlignment = src->minSequenceCountBufferOffsetAlignment;
+ minSequenceIndexBufferOffsetAlignment = src->minSequenceIndexBufferOffsetAlignment;
+ minCommandsTokenBufferOffsetAlignment = src->minCommandsTokenBufferOffsetAlignment;
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ pipelineBindPoint(in_struct->pipelineBindPoint),
+ flags(in_struct->flags),
+ tokenCount(in_struct->tokenCount),
+ pTokens(nullptr)
+{
+ if (in_struct->pTokens) {
+ pTokens = new VkIndirectCommandsLayoutTokenNVX[in_struct->tokenCount];
+ memcpy ((void *)pTokens, (void *)in_struct->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*in_struct->tokenCount);
+ }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX() :
+ pTokens(nullptr)
+{}
+
+safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ pipelineBindPoint = src.pipelineBindPoint;
+ flags = src.flags;
+ tokenCount = src.tokenCount;
+ pTokens = nullptr;
+ if (src.pTokens) {
+ pTokens = new VkIndirectCommandsLayoutTokenNVX[src.tokenCount];
+ memcpy ((void *)pTokens, (void *)src.pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*src.tokenCount);
+ }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNVX::~safe_VkIndirectCommandsLayoutCreateInfoNVX()
+{
+ if (pTokens)
+ delete[] pTokens;
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ pipelineBindPoint = in_struct->pipelineBindPoint;
+ flags = in_struct->flags;
+ tokenCount = in_struct->tokenCount;
+ pTokens = nullptr;
+ if (in_struct->pTokens) {
+ pTokens = new VkIndirectCommandsLayoutTokenNVX[in_struct->tokenCount];
+ memcpy ((void *)pTokens, (void *)in_struct->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*in_struct->tokenCount);
+ }
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const safe_VkIndirectCommandsLayoutCreateInfoNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ pipelineBindPoint = src->pipelineBindPoint;
+ flags = src->flags;
+ tokenCount = src->tokenCount;
+ pTokens = nullptr;
+ if (src->pTokens) {
+ pTokens = new VkIndirectCommandsLayoutTokenNVX[src->tokenCount];
+ memcpy ((void *)pTokens, (void *)src->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*src->tokenCount);
+ }
+}
+
+safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const VkCmdProcessCommandsInfoNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ objectTable(in_struct->objectTable),
+ indirectCommandsLayout(in_struct->indirectCommandsLayout),
+ indirectCommandsTokenCount(in_struct->indirectCommandsTokenCount),
+ pIndirectCommandsTokens(nullptr),
+ maxSequencesCount(in_struct->maxSequencesCount),
+ targetCommandBuffer(in_struct->targetCommandBuffer),
+ sequencesCountBuffer(in_struct->sequencesCountBuffer),
+ sequencesCountOffset(in_struct->sequencesCountOffset),
+ sequencesIndexBuffer(in_struct->sequencesIndexBuffer),
+ sequencesIndexOffset(in_struct->sequencesIndexOffset)
+{
+ if (indirectCommandsTokenCount && in_struct->pIndirectCommandsTokens) {
+ pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
+ for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+ pIndirectCommandsTokens[i] = in_struct->pIndirectCommandsTokens[i];
+ }
+ }
+}
+
+safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX() :
+ pIndirectCommandsTokens(nullptr)
+{}
+
+safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const safe_VkCmdProcessCommandsInfoNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ objectTable = src.objectTable;
+ indirectCommandsLayout = src.indirectCommandsLayout;
+ indirectCommandsTokenCount = src.indirectCommandsTokenCount;
+ pIndirectCommandsTokens = nullptr;
+ maxSequencesCount = src.maxSequencesCount;
+ targetCommandBuffer = src.targetCommandBuffer;
+ sequencesCountBuffer = src.sequencesCountBuffer;
+ sequencesCountOffset = src.sequencesCountOffset;
+ sequencesIndexBuffer = src.sequencesIndexBuffer;
+ sequencesIndexOffset = src.sequencesIndexOffset;
+ if (indirectCommandsTokenCount && src.pIndirectCommandsTokens) {
+ pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
+ for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+ pIndirectCommandsTokens[i] = src.pIndirectCommandsTokens[i];
+ }
+ }
+}
+
+safe_VkCmdProcessCommandsInfoNVX::~safe_VkCmdProcessCommandsInfoNVX()
+{
+ if (pIndirectCommandsTokens)
+ delete[] pIndirectCommandsTokens;
+}
+
+void safe_VkCmdProcessCommandsInfoNVX::initialize(const VkCmdProcessCommandsInfoNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ objectTable = in_struct->objectTable;
+ indirectCommandsLayout = in_struct->indirectCommandsLayout;
+ indirectCommandsTokenCount = in_struct->indirectCommandsTokenCount;
+ pIndirectCommandsTokens = nullptr;
+ maxSequencesCount = in_struct->maxSequencesCount;
+ targetCommandBuffer = in_struct->targetCommandBuffer;
+ sequencesCountBuffer = in_struct->sequencesCountBuffer;
+ sequencesCountOffset = in_struct->sequencesCountOffset;
+ sequencesIndexBuffer = in_struct->sequencesIndexBuffer;
+ sequencesIndexOffset = in_struct->sequencesIndexOffset;
+ if (indirectCommandsTokenCount && in_struct->pIndirectCommandsTokens) {
+ pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
+ for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+ pIndirectCommandsTokens[i] = in_struct->pIndirectCommandsTokens[i];
+ }
+ }
+}
+
+void safe_VkCmdProcessCommandsInfoNVX::initialize(const safe_VkCmdProcessCommandsInfoNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ objectTable = src->objectTable;
+ indirectCommandsLayout = src->indirectCommandsLayout;
+ indirectCommandsTokenCount = src->indirectCommandsTokenCount;
+ pIndirectCommandsTokens = nullptr;
+ maxSequencesCount = src->maxSequencesCount;
+ targetCommandBuffer = src->targetCommandBuffer;
+ sequencesCountBuffer = src->sequencesCountBuffer;
+ sequencesCountOffset = src->sequencesCountOffset;
+ sequencesIndexBuffer = src->sequencesIndexBuffer;
+ sequencesIndexOffset = src->sequencesIndexOffset;
+ if (indirectCommandsTokenCount && src->pIndirectCommandsTokens) {
+ pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
+ for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+ pIndirectCommandsTokens[i] = src->pIndirectCommandsTokens[i];
+ }
+ }
+}
+
+safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ objectTable(in_struct->objectTable),
+ indirectCommandsLayout(in_struct->indirectCommandsLayout),
+ maxSequencesCount(in_struct->maxSequencesCount)
+{
+}
+
+safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX()
+{}
+
+safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ objectTable = src.objectTable;
+ indirectCommandsLayout = src.indirectCommandsLayout;
+ maxSequencesCount = src.maxSequencesCount;
+}
+
+safe_VkCmdReserveSpaceForCommandsInfoNVX::~safe_VkCmdReserveSpaceForCommandsInfoNVX()
+{
+}
+
+void safe_VkCmdReserveSpaceForCommandsInfoNVX::initialize(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ objectTable = in_struct->objectTable;
+ indirectCommandsLayout = in_struct->indirectCommandsLayout;
+ maxSequencesCount = in_struct->maxSequencesCount;
+}
+
+void safe_VkCmdReserveSpaceForCommandsInfoNVX::initialize(const safe_VkCmdReserveSpaceForCommandsInfoNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ objectTable = src->objectTable;
+ indirectCommandsLayout = src->indirectCommandsLayout;
+ maxSequencesCount = src->maxSequencesCount;
+}
+
+safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const VkObjectTableCreateInfoNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ objectCount(in_struct->objectCount),
+ pObjectEntryTypes(nullptr),
+ pObjectEntryCounts(nullptr),
+ pObjectEntryUsageFlags(nullptr),
+ maxUniformBuffersPerDescriptor(in_struct->maxUniformBuffersPerDescriptor),
+ maxStorageBuffersPerDescriptor(in_struct->maxStorageBuffersPerDescriptor),
+ maxStorageImagesPerDescriptor(in_struct->maxStorageImagesPerDescriptor),
+ maxSampledImagesPerDescriptor(in_struct->maxSampledImagesPerDescriptor),
+ maxPipelineLayouts(in_struct->maxPipelineLayouts)
+{
+ if (in_struct->pObjectEntryTypes) {
+ pObjectEntryTypes = new VkObjectEntryTypeNVX[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryTypes, (void *)in_struct->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*in_struct->objectCount);
+ }
+ if (in_struct->pObjectEntryCounts) {
+ pObjectEntryCounts = new uint32_t[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryCounts, (void *)in_struct->pObjectEntryCounts, sizeof(uint32_t)*in_struct->objectCount);
+ }
+ if (in_struct->pObjectEntryUsageFlags) {
+ pObjectEntryUsageFlags = new VkObjectEntryUsageFlagsNVX[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryUsageFlags, (void *)in_struct->pObjectEntryUsageFlags, sizeof(VkObjectEntryUsageFlagsNVX)*in_struct->objectCount);
+ }
+}
+
+safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX() :
+ pObjectEntryTypes(nullptr),
+ pObjectEntryCounts(nullptr),
+ pObjectEntryUsageFlags(nullptr)
+{}
+
+safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const safe_VkObjectTableCreateInfoNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ objectCount = src.objectCount;
+ pObjectEntryTypes = nullptr;
+ pObjectEntryCounts = nullptr;
+ pObjectEntryUsageFlags = nullptr;
+ maxUniformBuffersPerDescriptor = src.maxUniformBuffersPerDescriptor;
+ maxStorageBuffersPerDescriptor = src.maxStorageBuffersPerDescriptor;
+ maxStorageImagesPerDescriptor = src.maxStorageImagesPerDescriptor;
+ maxSampledImagesPerDescriptor = src.maxSampledImagesPerDescriptor;
+ maxPipelineLayouts = src.maxPipelineLayouts;
+ if (src.pObjectEntryTypes) {
+ pObjectEntryTypes = new VkObjectEntryTypeNVX[src.objectCount];
+ memcpy ((void *)pObjectEntryTypes, (void *)src.pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*src.objectCount);
+ }
+ if (src.pObjectEntryCounts) {
+ pObjectEntryCounts = new uint32_t[src.objectCount];
+ memcpy ((void *)pObjectEntryCounts, (void *)src.pObjectEntryCounts, sizeof(uint32_t)*src.objectCount);
+ }
+ if (src.pObjectEntryUsageFlags) {
+ pObjectEntryUsageFlags = new VkObjectEntryUsageFlagsNVX[src.objectCount];
+ memcpy ((void *)pObjectEntryUsageFlags, (void *)src.pObjectEntryUsageFlags, sizeof(VkObjectEntryUsageFlagsNVX)*src.objectCount);
+ }
+}
+
+safe_VkObjectTableCreateInfoNVX::~safe_VkObjectTableCreateInfoNVX()
+{
+ if (pObjectEntryTypes)
+ delete[] pObjectEntryTypes;
+ if (pObjectEntryCounts)
+ delete[] pObjectEntryCounts;
+ if (pObjectEntryUsageFlags)
+ delete[] pObjectEntryUsageFlags;
+}
+
+void safe_VkObjectTableCreateInfoNVX::initialize(const VkObjectTableCreateInfoNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ objectCount = in_struct->objectCount;
+ pObjectEntryTypes = nullptr;
+ pObjectEntryCounts = nullptr;
+ pObjectEntryUsageFlags = nullptr;
+ maxUniformBuffersPerDescriptor = in_struct->maxUniformBuffersPerDescriptor;
+ maxStorageBuffersPerDescriptor = in_struct->maxStorageBuffersPerDescriptor;
+ maxStorageImagesPerDescriptor = in_struct->maxStorageImagesPerDescriptor;
+ maxSampledImagesPerDescriptor = in_struct->maxSampledImagesPerDescriptor;
+ maxPipelineLayouts = in_struct->maxPipelineLayouts;
+ if (in_struct->pObjectEntryTypes) {
+ pObjectEntryTypes = new VkObjectEntryTypeNVX[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryTypes, (void *)in_struct->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*in_struct->objectCount);
+ }
+ if (in_struct->pObjectEntryCounts) {
+ pObjectEntryCounts = new uint32_t[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryCounts, (void *)in_struct->pObjectEntryCounts, sizeof(uint32_t)*in_struct->objectCount);
+ }
+ if (in_struct->pObjectEntryUsageFlags) {
+ pObjectEntryUsageFlags = new VkObjectEntryUsageFlagsNVX[in_struct->objectCount];
+ memcpy ((void *)pObjectEntryUsageFlags, (void *)in_struct->pObjectEntryUsageFlags, sizeof(VkObjectEntryUsageFlagsNVX)*in_struct->objectCount);
+ }
+}
+
+void safe_VkObjectTableCreateInfoNVX::initialize(const safe_VkObjectTableCreateInfoNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ objectCount = src->objectCount;
+ pObjectEntryTypes = nullptr;
+ pObjectEntryCounts = nullptr;
+ pObjectEntryUsageFlags = nullptr;
+ maxUniformBuffersPerDescriptor = src->maxUniformBuffersPerDescriptor;
+ maxStorageBuffersPerDescriptor = src->maxStorageBuffersPerDescriptor;
+ maxStorageImagesPerDescriptor = src->maxStorageImagesPerDescriptor;
+ maxSampledImagesPerDescriptor = src->maxSampledImagesPerDescriptor;
+ maxPipelineLayouts = src->maxPipelineLayouts;
+ if (src->pObjectEntryTypes) {
+ pObjectEntryTypes = new VkObjectEntryTypeNVX[src->objectCount];
+ memcpy ((void *)pObjectEntryTypes, (void *)src->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*src->objectCount);
+ }
+ if (src->pObjectEntryCounts) {
+ pObjectEntryCounts = new uint32_t[src->objectCount];
+ memcpy ((void *)pObjectEntryCounts, (void *)src->pObjectEntryCounts, sizeof(uint32_t)*src->objectCount);
+ }
+ if (src->pObjectEntryUsageFlags) {
+ pObjectEntryUsageFlags = new VkObjectEntryUsageFlagsNVX[src->objectCount];
+ memcpy ((void *)pObjectEntryUsageFlags, (void *)src->pObjectEntryUsageFlags, sizeof(VkObjectEntryUsageFlagsNVX)*src->objectCount);
+ }
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ viewportWScalingEnable(in_struct->viewportWScalingEnable),
+ viewportCount(in_struct->viewportCount),
+ pViewportWScalings(nullptr)
+{
+ if (in_struct->pViewportWScalings) {
+ pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
+ memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
+ }
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV() :
+ pViewportWScalings(nullptr)
+{}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ viewportWScalingEnable = src.viewportWScalingEnable;
+ viewportCount = src.viewportCount;
+ pViewportWScalings = nullptr;
+ if (src.pViewportWScalings) {
+ pViewportWScalings = new VkViewportWScalingNV[src.viewportCount];
+ memcpy ((void *)pViewportWScalings, (void *)src.pViewportWScalings, sizeof(VkViewportWScalingNV)*src.viewportCount);
+ }
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::~safe_VkPipelineViewportWScalingStateCreateInfoNV()
+{
+ if (pViewportWScalings)
+ delete[] pViewportWScalings;
+}
+
+void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ viewportWScalingEnable = in_struct->viewportWScalingEnable;
+ viewportCount = in_struct->viewportCount;
+ pViewportWScalings = nullptr;
+ if (in_struct->pViewportWScalings) {
+ pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
+ memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
+ }
+}
+
+void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ viewportWScalingEnable = src->viewportWScalingEnable;
+ viewportCount = src->viewportCount;
+ pViewportWScalings = nullptr;
+ if (src->pViewportWScalings) {
+ pViewportWScalings = new VkViewportWScalingNV[src->viewportCount];
+ memcpy ((void *)pViewportWScalings, (void *)src->pViewportWScalings, sizeof(VkViewportWScalingNV)*src->viewportCount);
+ }
+}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ minImageCount(in_struct->minImageCount),
+ maxImageCount(in_struct->maxImageCount),
+ currentExtent(in_struct->currentExtent),
+ minImageExtent(in_struct->minImageExtent),
+ maxImageExtent(in_struct->maxImageExtent),
+ maxImageArrayLayers(in_struct->maxImageArrayLayers),
+ supportedTransforms(in_struct->supportedTransforms),
+ currentTransform(in_struct->currentTransform),
+ supportedCompositeAlpha(in_struct->supportedCompositeAlpha),
+ supportedUsageFlags(in_struct->supportedUsageFlags),
+ supportedSurfaceCounters(in_struct->supportedSurfaceCounters)
+{
+}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT()
+{}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ minImageCount = src.minImageCount;
+ maxImageCount = src.maxImageCount;
+ currentExtent = src.currentExtent;
+ minImageExtent = src.minImageExtent;
+ maxImageExtent = src.maxImageExtent;
+ maxImageArrayLayers = src.maxImageArrayLayers;
+ supportedTransforms = src.supportedTransforms;
+ currentTransform = src.currentTransform;
+ supportedCompositeAlpha = src.supportedCompositeAlpha;
+ supportedUsageFlags = src.supportedUsageFlags;
+ supportedSurfaceCounters = src.supportedSurfaceCounters;
+}
+
+safe_VkSurfaceCapabilities2EXT::~safe_VkSurfaceCapabilities2EXT()
+{
+}
+
+void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ minImageCount = in_struct->minImageCount;
+ maxImageCount = in_struct->maxImageCount;
+ currentExtent = in_struct->currentExtent;
+ minImageExtent = in_struct->minImageExtent;
+ maxImageExtent = in_struct->maxImageExtent;
+ maxImageArrayLayers = in_struct->maxImageArrayLayers;
+ supportedTransforms = in_struct->supportedTransforms;
+ currentTransform = in_struct->currentTransform;
+ supportedCompositeAlpha = in_struct->supportedCompositeAlpha;
+ supportedUsageFlags = in_struct->supportedUsageFlags;
+ supportedSurfaceCounters = in_struct->supportedSurfaceCounters;
+}
+
+void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities2EXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ minImageCount = src->minImageCount;
+ maxImageCount = src->maxImageCount;
+ currentExtent = src->currentExtent;
+ minImageExtent = src->minImageExtent;
+ maxImageExtent = src->maxImageExtent;
+ maxImageArrayLayers = src->maxImageArrayLayers;
+ supportedTransforms = src->supportedTransforms;
+ currentTransform = src->currentTransform;
+ supportedCompositeAlpha = src->supportedCompositeAlpha;
+ supportedUsageFlags = src->supportedUsageFlags;
+ supportedSurfaceCounters = src->supportedSurfaceCounters;
+}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ powerState(in_struct->powerState)
+{
+}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT()
+{}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ powerState = src.powerState;
+}
+
+safe_VkDisplayPowerInfoEXT::~safe_VkDisplayPowerInfoEXT()
+{
+}
+
+void safe_VkDisplayPowerInfoEXT::initialize(const VkDisplayPowerInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ powerState = in_struct->powerState;
+}
+
+void safe_VkDisplayPowerInfoEXT::initialize(const safe_VkDisplayPowerInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ powerState = src->powerState;
+}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ deviceEvent(in_struct->deviceEvent)
+{
+}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT()
+{}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ deviceEvent = src.deviceEvent;
+}
+
+safe_VkDeviceEventInfoEXT::~safe_VkDeviceEventInfoEXT()
+{
+}
+
+void safe_VkDeviceEventInfoEXT::initialize(const VkDeviceEventInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ deviceEvent = in_struct->deviceEvent;
+}
+
+void safe_VkDeviceEventInfoEXT::initialize(const safe_VkDeviceEventInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ deviceEvent = src->deviceEvent;
+}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ displayEvent(in_struct->displayEvent)
+{
+}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT()
+{}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ displayEvent = src.displayEvent;
+}
+
+safe_VkDisplayEventInfoEXT::~safe_VkDisplayEventInfoEXT()
+{
+}
+
+void safe_VkDisplayEventInfoEXT::initialize(const VkDisplayEventInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ displayEvent = in_struct->displayEvent;
+}
+
+void safe_VkDisplayEventInfoEXT::initialize(const safe_VkDisplayEventInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ displayEvent = src->displayEvent;
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ surfaceCounters(in_struct->surfaceCounters)
+{
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT()
+{}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ surfaceCounters = src.surfaceCounters;
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::~safe_VkSwapchainCounterCreateInfoEXT()
+{
+}
+
+void safe_VkSwapchainCounterCreateInfoEXT::initialize(const VkSwapchainCounterCreateInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ surfaceCounters = in_struct->surfaceCounters;
+}
+
+void safe_VkSwapchainCounterCreateInfoEXT::initialize(const safe_VkSwapchainCounterCreateInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ surfaceCounters = src->surfaceCounters;
+}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ swapchainCount(in_struct->swapchainCount),
+ pTimes(nullptr)
+{
+ if (in_struct->pTimes) {
+ pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
+ memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
+ }
+}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE() :
+ pTimes(nullptr)
+{}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ swapchainCount = src.swapchainCount;
+ pTimes = nullptr;
+ if (src.pTimes) {
+ pTimes = new VkPresentTimeGOOGLE[src.swapchainCount];
+ memcpy ((void *)pTimes, (void *)src.pTimes, sizeof(VkPresentTimeGOOGLE)*src.swapchainCount);
+ }
+}
+
+safe_VkPresentTimesInfoGOOGLE::~safe_VkPresentTimesInfoGOOGLE()
+{
+ if (pTimes)
+ delete[] pTimes;
+}
+
+void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ swapchainCount = in_struct->swapchainCount;
+ pTimes = nullptr;
+ if (in_struct->pTimes) {
+ pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
+ memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
+ }
+}
+
+void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOGLE* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ swapchainCount = src->swapchainCount;
+ pTimes = nullptr;
+ if (src->pTimes) {
+ pTimes = new VkPresentTimeGOOGLE[src->swapchainCount];
+ memcpy ((void *)pTimes, (void *)src->pTimes, sizeof(VkPresentTimeGOOGLE)*src->swapchainCount);
+ }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ perViewPositionAllComponents(in_struct->perViewPositionAllComponents)
+{
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+{}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ perViewPositionAllComponents = src.perViewPositionAllComponents;
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+{
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ perViewPositionAllComponents = in_struct->perViewPositionAllComponents;
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ perViewPositionAllComponents = src->perViewPositionAllComponents;
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ viewportCount(in_struct->viewportCount),
+ pViewportSwizzles(nullptr)
+{
+ if (in_struct->pViewportSwizzles) {
+ pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
+ memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
+ }
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV() :
+ pViewportSwizzles(nullptr)
+{}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ viewportCount = src.viewportCount;
+ pViewportSwizzles = nullptr;
+ if (src.pViewportSwizzles) {
+ pViewportSwizzles = new VkViewportSwizzleNV[src.viewportCount];
+ memcpy ((void *)pViewportSwizzles, (void *)src.pViewportSwizzles, sizeof(VkViewportSwizzleNV)*src.viewportCount);
+ }
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::~safe_VkPipelineViewportSwizzleStateCreateInfoNV()
+{
+ if (pViewportSwizzles)
+ delete[] pViewportSwizzles;
+}
+
+void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ viewportCount = in_struct->viewportCount;
+ pViewportSwizzles = nullptr;
+ if (in_struct->pViewportSwizzles) {
+ pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
+ memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
+ }
+}
+
+void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ viewportCount = src->viewportCount;
+ pViewportSwizzles = nullptr;
+ if (src->pViewportSwizzles) {
+ pViewportSwizzles = new VkViewportSwizzleNV[src->viewportCount];
+ memcpy ((void *)pViewportSwizzles, (void *)src->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*src->viewportCount);
+ }
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ maxDiscardRectangles(in_struct->maxDiscardRectangles)
+{
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
+{}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ maxDiscardRectangles = src.maxDiscardRectangles;
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
+{
+}
+
+void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ maxDiscardRectangles = in_struct->maxDiscardRectangles;
+}
+
+void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ maxDiscardRectangles = src->maxDiscardRectangles;
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ discardRectangleMode(in_struct->discardRectangleMode),
+ discardRectangleCount(in_struct->discardRectangleCount),
+ pDiscardRectangles(nullptr)
+{
+ if (in_struct->pDiscardRectangles) {
+ pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
+ memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
+ }
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT() :
+ pDiscardRectangles(nullptr)
+{}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ discardRectangleMode = src.discardRectangleMode;
+ discardRectangleCount = src.discardRectangleCount;
+ pDiscardRectangles = nullptr;
+ if (src.pDiscardRectangles) {
+ pDiscardRectangles = new VkRect2D[src.discardRectangleCount];
+ memcpy ((void *)pDiscardRectangles, (void *)src.pDiscardRectangles, sizeof(VkRect2D)*src.discardRectangleCount);
+ }
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::~safe_VkPipelineDiscardRectangleStateCreateInfoEXT()
+{
+ if (pDiscardRectangles)
+ delete[] pDiscardRectangles;
+}
+
+void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ discardRectangleMode = in_struct->discardRectangleMode;
+ discardRectangleCount = in_struct->discardRectangleCount;
+ pDiscardRectangles = nullptr;
+ if (in_struct->pDiscardRectangles) {
+ pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
+ memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
+ }
+}
+
+void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ discardRectangleMode = src->discardRectangleMode;
+ discardRectangleCount = src->discardRectangleCount;
+ pDiscardRectangles = nullptr;
+ if (src->pDiscardRectangles) {
+ pDiscardRectangles = new VkRect2D[src->discardRectangleCount];
+ memcpy ((void *)pDiscardRectangles, (void *)src->pDiscardRectangles, sizeof(VkRect2D)*src->discardRectangleCount);
+ }
+}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ displayPrimaryRed(in_struct->displayPrimaryRed),
+ displayPrimaryGreen(in_struct->displayPrimaryGreen),
+ displayPrimaryBlue(in_struct->displayPrimaryBlue),
+ whitePoint(in_struct->whitePoint),
+ maxLuminance(in_struct->maxLuminance),
+ minLuminance(in_struct->minLuminance),
+ maxContentLightLevel(in_struct->maxContentLightLevel),
+ maxFrameAverageLightLevel(in_struct->maxFrameAverageLightLevel)
+{
+}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT()
+{}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ displayPrimaryRed = src.displayPrimaryRed;
+ displayPrimaryGreen = src.displayPrimaryGreen;
+ displayPrimaryBlue = src.displayPrimaryBlue;
+ whitePoint = src.whitePoint;
+ maxLuminance = src.maxLuminance;
+ minLuminance = src.minLuminance;
+ maxContentLightLevel = src.maxContentLightLevel;
+ maxFrameAverageLightLevel = src.maxFrameAverageLightLevel;
+}
+
+safe_VkHdrMetadataEXT::~safe_VkHdrMetadataEXT()
+{
+}
+
+void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ displayPrimaryRed = in_struct->displayPrimaryRed;
+ displayPrimaryGreen = in_struct->displayPrimaryGreen;
+ displayPrimaryBlue = in_struct->displayPrimaryBlue;
+ whitePoint = in_struct->whitePoint;
+ maxLuminance = in_struct->maxLuminance;
+ minLuminance = in_struct->minLuminance;
+ maxContentLightLevel = in_struct->maxContentLightLevel;
+ maxFrameAverageLightLevel = in_struct->maxFrameAverageLightLevel;
+}
+
+void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ displayPrimaryRed = src->displayPrimaryRed;
+ displayPrimaryGreen = src->displayPrimaryGreen;
+ displayPrimaryBlue = src->displayPrimaryBlue;
+ whitePoint = src->whitePoint;
+ maxLuminance = src->maxLuminance;
+ minLuminance = src->minLuminance;
+ maxContentLightLevel = src->maxContentLightLevel;
+ maxFrameAverageLightLevel = src->maxFrameAverageLightLevel;
+}
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+
+safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ pView(in_struct->pView)
+{
+}
+
+safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK()
+{}
+
+safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ pView = src.pView;
+}
+
+safe_VkIOSSurfaceCreateInfoMVK::~safe_VkIOSSurfaceCreateInfoMVK()
+{
+}
+
+void safe_VkIOSSurfaceCreateInfoMVK::initialize(const VkIOSSurfaceCreateInfoMVK* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ pView = in_struct->pView;
+}
+
+void safe_VkIOSSurfaceCreateInfoMVK::initialize(const safe_VkIOSSurfaceCreateInfoMVK* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ pView = src->pView;
+}
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+
+
+safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ pView(in_struct->pView)
+{
+}
+
+safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK()
+{}
+
+safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ pView = src.pView;
+}
+
+safe_VkMacOSSurfaceCreateInfoMVK::~safe_VkMacOSSurfaceCreateInfoMVK()
+{
+}
+
+void safe_VkMacOSSurfaceCreateInfoMVK::initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ pView = in_struct->pView;
+}
+
+void safe_VkMacOSSurfaceCreateInfoMVK::initialize(const safe_VkMacOSSurfaceCreateInfoMVK* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ pView = src->pView;
+}
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+
+safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT(const VkSamplerReductionModeCreateInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ reductionMode(in_struct->reductionMode)
+{
+}
+
+safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT()
+{}
+
+safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT(const safe_VkSamplerReductionModeCreateInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ reductionMode = src.reductionMode;
+}
+
+safe_VkSamplerReductionModeCreateInfoEXT::~safe_VkSamplerReductionModeCreateInfoEXT()
+{
+}
+
+void safe_VkSamplerReductionModeCreateInfoEXT::initialize(const VkSamplerReductionModeCreateInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ reductionMode = in_struct->reductionMode;
+}
+
+void safe_VkSamplerReductionModeCreateInfoEXT::initialize(const safe_VkSamplerReductionModeCreateInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ reductionMode = src->reductionMode;
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
+ filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping)
+{
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+{}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ filterMinmaxSingleComponentFormats = src.filterMinmaxSingleComponentFormats;
+ filterMinmaxImageComponentMapping = src.filterMinmaxImageComponentMapping;
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::~safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+{
+}
+
+void safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::initialize(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
+ filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
+}
+
+void safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ filterMinmaxSingleComponentFormats = src->filterMinmaxSingleComponentFormats;
+ filterMinmaxImageComponentMapping = src->filterMinmaxImageComponentMapping;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ advancedBlendCoherentOperations(in_struct->advancedBlendCoherentOperations)
+{
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
+{}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ advancedBlendCoherentOperations = src.advancedBlendCoherentOperations;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
+{
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ advancedBlendCoherentOperations = in_struct->advancedBlendCoherentOperations;
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ advancedBlendCoherentOperations = src->advancedBlendCoherentOperations;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ advancedBlendMaxColorAttachments(in_struct->advancedBlendMaxColorAttachments),
+ advancedBlendIndependentBlend(in_struct->advancedBlendIndependentBlend),
+ advancedBlendNonPremultipliedSrcColor(in_struct->advancedBlendNonPremultipliedSrcColor),
+ advancedBlendNonPremultipliedDstColor(in_struct->advancedBlendNonPremultipliedDstColor),
+ advancedBlendCorrelatedOverlap(in_struct->advancedBlendCorrelatedOverlap),
+ advancedBlendAllOperations(in_struct->advancedBlendAllOperations)
+{
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+{}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ advancedBlendMaxColorAttachments = src.advancedBlendMaxColorAttachments;
+ advancedBlendIndependentBlend = src.advancedBlendIndependentBlend;
+ advancedBlendNonPremultipliedSrcColor = src.advancedBlendNonPremultipliedSrcColor;
+ advancedBlendNonPremultipliedDstColor = src.advancedBlendNonPremultipliedDstColor;
+ advancedBlendCorrelatedOverlap = src.advancedBlendCorrelatedOverlap;
+ advancedBlendAllOperations = src.advancedBlendAllOperations;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+{
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ advancedBlendMaxColorAttachments = in_struct->advancedBlendMaxColorAttachments;
+ advancedBlendIndependentBlend = in_struct->advancedBlendIndependentBlend;
+ advancedBlendNonPremultipliedSrcColor = in_struct->advancedBlendNonPremultipliedSrcColor;
+ advancedBlendNonPremultipliedDstColor = in_struct->advancedBlendNonPremultipliedDstColor;
+ advancedBlendCorrelatedOverlap = in_struct->advancedBlendCorrelatedOverlap;
+ advancedBlendAllOperations = in_struct->advancedBlendAllOperations;
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ advancedBlendMaxColorAttachments = src->advancedBlendMaxColorAttachments;
+ advancedBlendIndependentBlend = src->advancedBlendIndependentBlend;
+ advancedBlendNonPremultipliedSrcColor = src->advancedBlendNonPremultipliedSrcColor;
+ advancedBlendNonPremultipliedDstColor = src->advancedBlendNonPremultipliedDstColor;
+ advancedBlendCorrelatedOverlap = src->advancedBlendCorrelatedOverlap;
+ advancedBlendAllOperations = src->advancedBlendAllOperations;
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ srcPremultiplied(in_struct->srcPremultiplied),
+ dstPremultiplied(in_struct->dstPremultiplied),
+ blendOverlap(in_struct->blendOverlap)
+{
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
+{}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ srcPremultiplied = src.srcPremultiplied;
+ dstPremultiplied = src.dstPremultiplied;
+ blendOverlap = src.blendOverlap;
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
+{
+}
+
+void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ srcPremultiplied = in_struct->srcPremultiplied;
+ dstPremultiplied = in_struct->dstPremultiplied;
+ blendOverlap = in_struct->blendOverlap;
+}
+
+void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ srcPremultiplied = src->srcPremultiplied;
+ dstPremultiplied = src->dstPremultiplied;
+ blendOverlap = src->blendOverlap;
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ coverageToColorEnable(in_struct->coverageToColorEnable),
+ coverageToColorLocation(in_struct->coverageToColorLocation)
+{
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV()
+{}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ coverageToColorEnable = src.coverageToColorEnable;
+ coverageToColorLocation = src.coverageToColorLocation;
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::~safe_VkPipelineCoverageToColorStateCreateInfoNV()
+{
+}
+
+void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ coverageToColorEnable = in_struct->coverageToColorEnable;
+ coverageToColorLocation = in_struct->coverageToColorLocation;
+}
+
+void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ coverageToColorEnable = src->coverageToColorEnable;
+ coverageToColorLocation = src->coverageToColorLocation;
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct) :
+ sType(in_struct->sType),
+ pNext(in_struct->pNext),
+ flags(in_struct->flags),
+ coverageModulationMode(in_struct->coverageModulationMode),
+ coverageModulationTableEnable(in_struct->coverageModulationTableEnable),
+ coverageModulationTableCount(in_struct->coverageModulationTableCount),
+ pCoverageModulationTable(nullptr)
+{
+ if (in_struct->pCoverageModulationTable) {
+ pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
+ memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
+ }
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV() :
+ pCoverageModulationTable(nullptr)
+{}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& src)
+{
+ sType = src.sType;
+ pNext = src.pNext;
+ flags = src.flags;
+ coverageModulationMode = src.coverageModulationMode;
+ coverageModulationTableEnable = src.coverageModulationTableEnable;
+ coverageModulationTableCount = src.coverageModulationTableCount;
+ pCoverageModulationTable = nullptr;
+ if (src.pCoverageModulationTable) {
+ pCoverageModulationTable = new float[src.coverageModulationTableCount];
+ memcpy ((void *)pCoverageModulationTable, (void *)src.pCoverageModulationTable, sizeof(float)*src.coverageModulationTableCount);
+ }
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::~safe_VkPipelineCoverageModulationStateCreateInfoNV()
+{
+ if (pCoverageModulationTable)
+ delete[] pCoverageModulationTable;
+}
+
+void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct)
+{
+ sType = in_struct->sType;
+ pNext = in_struct->pNext;
+ flags = in_struct->flags;
+ coverageModulationMode = in_struct->coverageModulationMode;
+ coverageModulationTableEnable = in_struct->coverageModulationTableEnable;
+ coverageModulationTableCount = in_struct->coverageModulationTableCount;
+ pCoverageModulationTable = nullptr;
+ if (in_struct->pCoverageModulationTable) {
+ pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
+ memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
+ }
+}
+
+void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* src)
+{
+ sType = src->sType;
+ pNext = src->pNext;
+ flags = src->flags;
+ coverageModulationMode = src->coverageModulationMode;
+ coverageModulationTableEnable = src->coverageModulationTableEnable;
+ coverageModulationTableCount = src->coverageModulationTableCount;
+ pCoverageModulationTable = nullptr;
+ if (src->pCoverageModulationTable) {
+ pCoverageModulationTable = new float[src->coverageModulationTableCount];
+ memcpy ((void *)pCoverageModulationTable, (void *)src->pCoverageModulationTable, sizeof(float)*src->coverageModulationTableCount);
+ }
+}
diff --git a/build-fuchsia/generated/include/vk_safe_struct.h b/build-fuchsia/generated/include/vk_safe_struct.h
new file mode 100644
index 0000000..f314b64
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_safe_struct.h
@@ -0,0 +1,3247 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#pragma once
+#include <vulkan/vulkan.h>
+
+
+struct safe_VkApplicationInfo {
+ VkStructureType sType;
+ const void* pNext;
+ const char* pApplicationName;
+ uint32_t applicationVersion;
+ const char* pEngineName;
+ uint32_t engineVersion;
+ uint32_t apiVersion;
+ safe_VkApplicationInfo(const VkApplicationInfo* in_struct);
+ safe_VkApplicationInfo(const safe_VkApplicationInfo& src);
+ safe_VkApplicationInfo();
+ ~safe_VkApplicationInfo();
+ void initialize(const VkApplicationInfo* in_struct);
+ void initialize(const safe_VkApplicationInfo* src);
+ VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); }
+ VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); }
+};
+
+struct safe_VkInstanceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkInstanceCreateFlags flags;
+ safe_VkApplicationInfo* pApplicationInfo;
+ uint32_t enabledLayerCount;
+ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionCount;
+ const char* const* ppEnabledExtensionNames;
+ safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct);
+ safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src);
+ safe_VkInstanceCreateInfo();
+ ~safe_VkInstanceCreateInfo();
+ void initialize(const VkInstanceCreateInfo* in_struct);
+ void initialize(const safe_VkInstanceCreateInfo* src);
+ VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); }
+ VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); }
+};
+
+struct safe_VkAllocationCallbacks {
+ void* pUserData;
+ PFN_vkAllocationFunction pfnAllocation;
+ PFN_vkReallocationFunction pfnReallocation;
+ PFN_vkFreeFunction pfnFree;
+ PFN_vkInternalAllocationNotification pfnInternalAllocation;
+ PFN_vkInternalFreeNotification pfnInternalFree;
+ safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct);
+ safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src);
+ safe_VkAllocationCallbacks();
+ ~safe_VkAllocationCallbacks();
+ void initialize(const VkAllocationCallbacks* in_struct);
+ void initialize(const safe_VkAllocationCallbacks* src);
+ VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); }
+ VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); }
+};
+
+struct safe_VkDeviceQueueCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueCount;
+ const float* pQueuePriorities;
+ safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct);
+ safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src);
+ safe_VkDeviceQueueCreateInfo();
+ ~safe_VkDeviceQueueCreateInfo();
+ void initialize(const VkDeviceQueueCreateInfo* in_struct);
+ void initialize(const safe_VkDeviceQueueCreateInfo* src);
+ VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); }
+ VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); }
+};
+
+struct safe_VkDeviceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceCreateFlags flags;
+ uint32_t queueCreateInfoCount;
+ safe_VkDeviceQueueCreateInfo* pQueueCreateInfos;
+ uint32_t enabledLayerCount;
+ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionCount;
+ const char* const* ppEnabledExtensionNames;
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
+ safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct);
+ safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src);
+ safe_VkDeviceCreateInfo();
+ ~safe_VkDeviceCreateInfo();
+ void initialize(const VkDeviceCreateInfo* in_struct);
+ void initialize(const safe_VkDeviceCreateInfo* src);
+ VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); }
+ VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); }
+};
+
+struct safe_VkSubmitInfo {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ VkSemaphore* pWaitSemaphores;
+ const VkPipelineStageFlags* pWaitDstStageMask;
+ uint32_t commandBufferCount;
+ VkCommandBuffer* pCommandBuffers;
+ uint32_t signalSemaphoreCount;
+ VkSemaphore* pSignalSemaphores;
+ safe_VkSubmitInfo(const VkSubmitInfo* in_struct);
+ safe_VkSubmitInfo(const safe_VkSubmitInfo& src);
+ safe_VkSubmitInfo();
+ ~safe_VkSubmitInfo();
+ void initialize(const VkSubmitInfo* in_struct);
+ void initialize(const safe_VkSubmitInfo* src);
+ VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); }
+ VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); }
+};
+
+struct safe_VkMemoryAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceSize allocationSize;
+ uint32_t memoryTypeIndex;
+ safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct);
+ safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src);
+ safe_VkMemoryAllocateInfo();
+ ~safe_VkMemoryAllocateInfo();
+ void initialize(const VkMemoryAllocateInfo* in_struct);
+ void initialize(const safe_VkMemoryAllocateInfo* src);
+ VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); }
+ VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); }
+};
+
+struct safe_VkMappedMemoryRange {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct);
+ safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src);
+ safe_VkMappedMemoryRange();
+ ~safe_VkMappedMemoryRange();
+ void initialize(const VkMappedMemoryRange* in_struct);
+ void initialize(const safe_VkMappedMemoryRange* src);
+ VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); }
+ VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); }
+};
+
+struct safe_VkSparseBufferMemoryBindInfo {
+ VkBuffer buffer;
+ uint32_t bindCount;
+ VkSparseMemoryBind* pBinds;
+ safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct);
+ safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src);
+ safe_VkSparseBufferMemoryBindInfo();
+ ~safe_VkSparseBufferMemoryBindInfo();
+ void initialize(const VkSparseBufferMemoryBindInfo* in_struct);
+ void initialize(const safe_VkSparseBufferMemoryBindInfo* src);
+ VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); }
+ VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); }
+};
+
+struct safe_VkSparseImageOpaqueMemoryBindInfo {
+ VkImage image;
+ uint32_t bindCount;
+ VkSparseMemoryBind* pBinds;
+ safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
+ safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src);
+ safe_VkSparseImageOpaqueMemoryBindInfo();
+ ~safe_VkSparseImageOpaqueMemoryBindInfo();
+ void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
+ void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src);
+ VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); }
+ VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); }
+};
+
+struct safe_VkSparseImageMemoryBindInfo {
+ VkImage image;
+ uint32_t bindCount;
+ VkSparseImageMemoryBind* pBinds;
+ safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct);
+ safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src);
+ safe_VkSparseImageMemoryBindInfo();
+ ~safe_VkSparseImageMemoryBindInfo();
+ void initialize(const VkSparseImageMemoryBindInfo* in_struct);
+ void initialize(const safe_VkSparseImageMemoryBindInfo* src);
+ VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); }
+ VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); }
+};
+
+struct safe_VkBindSparseInfo {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ VkSemaphore* pWaitSemaphores;
+ uint32_t bufferBindCount;
+ safe_VkSparseBufferMemoryBindInfo* pBufferBinds;
+ uint32_t imageOpaqueBindCount;
+ safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+ uint32_t imageBindCount;
+ safe_VkSparseImageMemoryBindInfo* pImageBinds;
+ uint32_t signalSemaphoreCount;
+ VkSemaphore* pSignalSemaphores;
+ safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct);
+ safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src);
+ safe_VkBindSparseInfo();
+ ~safe_VkBindSparseInfo();
+ void initialize(const VkBindSparseInfo* in_struct);
+ void initialize(const safe_VkBindSparseInfo* src);
+ VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); }
+ VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); }
+};
+
+struct safe_VkFenceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkFenceCreateFlags flags;
+ safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct);
+ safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src);
+ safe_VkFenceCreateInfo();
+ ~safe_VkFenceCreateInfo();
+ void initialize(const VkFenceCreateInfo* in_struct);
+ void initialize(const safe_VkFenceCreateInfo* src);
+ VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); }
+ VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); }
+};
+
+struct safe_VkSemaphoreCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphoreCreateFlags flags;
+ safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct);
+ safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src);
+ safe_VkSemaphoreCreateInfo();
+ ~safe_VkSemaphoreCreateInfo();
+ void initialize(const VkSemaphoreCreateInfo* in_struct);
+ void initialize(const safe_VkSemaphoreCreateInfo* src);
+ VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); }
+ VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); }
+};
+
+struct safe_VkEventCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkEventCreateFlags flags;
+ safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct);
+ safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src);
+ safe_VkEventCreateInfo();
+ ~safe_VkEventCreateInfo();
+ void initialize(const VkEventCreateInfo* in_struct);
+ void initialize(const safe_VkEventCreateInfo* src);
+ VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); }
+ VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); }
+};
+
+struct safe_VkQueryPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkQueryPoolCreateFlags flags;
+ VkQueryType queryType;
+ uint32_t queryCount;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+ safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct);
+ safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src);
+ safe_VkQueryPoolCreateInfo();
+ ~safe_VkQueryPoolCreateInfo();
+ void initialize(const VkQueryPoolCreateInfo* in_struct);
+ void initialize(const safe_VkQueryPoolCreateInfo* src);
+ VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); }
+ VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); }
+};
+
+struct safe_VkBufferCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCreateFlags flags;
+ VkDeviceSize size;
+ VkBufferUsageFlags usage;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct);
+ safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src);
+ safe_VkBufferCreateInfo();
+ ~safe_VkBufferCreateInfo();
+ void initialize(const VkBufferCreateInfo* in_struct);
+ void initialize(const safe_VkBufferCreateInfo* src);
+ VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); }
+ VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); }
+};
+
+struct safe_VkBufferViewCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferViewCreateFlags flags;
+ VkBuffer buffer;
+ VkFormat format;
+ VkDeviceSize offset;
+ VkDeviceSize range;
+ safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct);
+ safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src);
+ safe_VkBufferViewCreateInfo();
+ ~safe_VkBufferViewCreateInfo();
+ void initialize(const VkBufferViewCreateInfo* in_struct);
+ void initialize(const safe_VkBufferViewCreateInfo* src);
+ VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); }
+ VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); }
+};
+
+struct safe_VkImageCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageCreateFlags flags;
+ VkImageType imageType;
+ VkFormat format;
+ VkExtent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+ VkSampleCountFlagBits samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ VkImageLayout initialLayout;
+ safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct);
+ safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src);
+ safe_VkImageCreateInfo();
+ ~safe_VkImageCreateInfo();
+ void initialize(const VkImageCreateInfo* in_struct);
+ void initialize(const safe_VkImageCreateInfo* src);
+ VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); }
+ VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); }
+};
+
+struct safe_VkImageViewCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageViewCreateFlags flags;
+ VkImage image;
+ VkImageViewType viewType;
+ VkFormat format;
+ VkComponentMapping components;
+ VkImageSubresourceRange subresourceRange;
+ safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct);
+ safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src);
+ safe_VkImageViewCreateInfo();
+ ~safe_VkImageViewCreateInfo();
+ void initialize(const VkImageViewCreateInfo* in_struct);
+ void initialize(const safe_VkImageViewCreateInfo* src);
+ VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); }
+ VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); }
+};
+
+struct safe_VkShaderModuleCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkShaderModuleCreateFlags flags;
+ size_t codeSize;
+ const uint32_t* pCode;
+ safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct);
+ safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src);
+ safe_VkShaderModuleCreateInfo();
+ ~safe_VkShaderModuleCreateInfo();
+ void initialize(const VkShaderModuleCreateInfo* in_struct);
+ void initialize(const safe_VkShaderModuleCreateInfo* src);
+ VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); }
+ VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineCacheCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCacheCreateFlags flags;
+ size_t initialDataSize;
+ const void* pInitialData;
+ safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct);
+ safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src);
+ safe_VkPipelineCacheCreateInfo();
+ ~safe_VkPipelineCacheCreateInfo();
+ void initialize(const VkPipelineCacheCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineCacheCreateInfo* src);
+ VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); }
+ VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); }
+};
+
+struct safe_VkSpecializationInfo {
+ uint32_t mapEntryCount;
+ const VkSpecializationMapEntry* pMapEntries;
+ size_t dataSize;
+ const void* pData;
+ safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct);
+ safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src);
+ safe_VkSpecializationInfo();
+ ~safe_VkSpecializationInfo();
+ void initialize(const VkSpecializationInfo* in_struct);
+ void initialize(const safe_VkSpecializationInfo* src);
+ VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); }
+ VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); }
+};
+
+struct safe_VkPipelineShaderStageCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineShaderStageCreateFlags flags;
+ VkShaderStageFlagBits stage;
+ VkShaderModule module;
+ const char* pName;
+ safe_VkSpecializationInfo* pSpecializationInfo;
+ safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct);
+ safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src);
+ safe_VkPipelineShaderStageCreateInfo();
+ ~safe_VkPipelineShaderStageCreateInfo();
+ void initialize(const VkPipelineShaderStageCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineShaderStageCreateInfo* src);
+ VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); }
+ VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineVertexInputStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineVertexInputStateCreateFlags flags;
+ uint32_t vertexBindingDescriptionCount;
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ uint32_t vertexAttributeDescriptionCount;
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct);
+ safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src);
+ safe_VkPipelineVertexInputStateCreateInfo();
+ ~safe_VkPipelineVertexInputStateCreateInfo();
+ void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineVertexInputStateCreateInfo* src);
+ VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); }
+ VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineInputAssemblyStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineInputAssemblyStateCreateFlags flags;
+ VkPrimitiveTopology topology;
+ VkBool32 primitiveRestartEnable;
+ safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
+ safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src);
+ safe_VkPipelineInputAssemblyStateCreateInfo();
+ ~safe_VkPipelineInputAssemblyStateCreateInfo();
+ void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src);
+ VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); }
+ VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineTessellationStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineTessellationStateCreateFlags flags;
+ uint32_t patchControlPoints;
+ safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct);
+ safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src);
+ safe_VkPipelineTessellationStateCreateInfo();
+ ~safe_VkPipelineTessellationStateCreateInfo();
+ void initialize(const VkPipelineTessellationStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineTessellationStateCreateInfo* src);
+ VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); }
+ VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineViewportStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineViewportStateCreateFlags flags;
+ uint32_t viewportCount;
+ const VkViewport* pViewports;
+ uint32_t scissorCount;
+ const VkRect2D* pScissors;
+ safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct);
+ safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src);
+ safe_VkPipelineViewportStateCreateInfo();
+ ~safe_VkPipelineViewportStateCreateInfo();
+ void initialize(const VkPipelineViewportStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineViewportStateCreateInfo* src);
+ VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); }
+ VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineRasterizationStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineRasterizationStateCreateFlags flags;
+ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkPolygonMode polygonMode;
+ VkCullModeFlags cullMode;
+ VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
+ float depthBiasConstantFactor;
+ float depthBiasClamp;
+ float depthBiasSlopeFactor;
+ float lineWidth;
+ safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct);
+ safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src);
+ safe_VkPipelineRasterizationStateCreateInfo();
+ ~safe_VkPipelineRasterizationStateCreateInfo();
+ void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineRasterizationStateCreateInfo* src);
+ VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); }
+ VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineMultisampleStateCreateFlags flags;
+ VkSampleCountFlagBits rasterizationSamples;
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+ const VkSampleMask* pSampleMask;
+ VkBool32 alphaToCoverageEnable;
+ VkBool32 alphaToOneEnable;
+ safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct);
+ safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src);
+ safe_VkPipelineMultisampleStateCreateInfo();
+ ~safe_VkPipelineMultisampleStateCreateInfo();
+ void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineMultisampleStateCreateInfo* src);
+ VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); }
+ VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineDepthStencilStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineDepthStencilStateCreateFlags flags;
+ VkBool32 depthTestEnable;
+ VkBool32 depthWriteEnable;
+ VkCompareOp depthCompareOp;
+ VkBool32 depthBoundsTestEnable;
+ VkBool32 stencilTestEnable;
+ VkStencilOpState front;
+ VkStencilOpState back;
+ float minDepthBounds;
+ float maxDepthBounds;
+ safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct);
+ safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src);
+ safe_VkPipelineDepthStencilStateCreateInfo();
+ ~safe_VkPipelineDepthStencilStateCreateInfo();
+ void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src);
+ VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); }
+ VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineColorBlendStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineColorBlendStateCreateFlags flags;
+ VkBool32 logicOpEnable;
+ VkLogicOp logicOp;
+ uint32_t attachmentCount;
+ const VkPipelineColorBlendAttachmentState* pAttachments;
+ float blendConstants[4];
+ safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct);
+ safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src);
+ safe_VkPipelineColorBlendStateCreateInfo();
+ ~safe_VkPipelineColorBlendStateCreateInfo();
+ void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineColorBlendStateCreateInfo* src);
+ VkPipelineColorBlendStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>(this); }
+ VkPipelineColorBlendStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineDynamicStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const VkDynamicState* pDynamicStates;
+ safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct);
+ safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src);
+ safe_VkPipelineDynamicStateCreateInfo();
+ ~safe_VkPipelineDynamicStateCreateInfo();
+ void initialize(const VkPipelineDynamicStateCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineDynamicStateCreateInfo* src);
+ VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); }
+ VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); }
+};
+
+struct safe_VkGraphicsPipelineCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCreateFlags flags;
+ uint32_t stageCount;
+ safe_VkPipelineShaderStageCreateInfo* pStages;
+ safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ safe_VkPipelineTessellationStateCreateInfo* pTessellationState;
+ safe_VkPipelineViewportStateCreateInfo* pViewportState;
+ safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState;
+ safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ safe_VkPipelineDynamicStateCreateInfo* pDynamicState;
+ VkPipelineLayout layout;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkPipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct);
+ safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src);
+ safe_VkGraphicsPipelineCreateInfo();
+ ~safe_VkGraphicsPipelineCreateInfo();
+ void initialize(const VkGraphicsPipelineCreateInfo* in_struct);
+ void initialize(const safe_VkGraphicsPipelineCreateInfo* src);
+ VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); }
+ VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); }
+};
+
+struct safe_VkComputePipelineCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCreateFlags flags;
+ safe_VkPipelineShaderStageCreateInfo stage;
+ VkPipelineLayout layout;
+ VkPipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct);
+ safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src);
+ safe_VkComputePipelineCreateInfo();
+ ~safe_VkComputePipelineCreateInfo();
+ void initialize(const VkComputePipelineCreateInfo* in_struct);
+ void initialize(const safe_VkComputePipelineCreateInfo* src);
+ VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); }
+ VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); }
+};
+
+struct safe_VkPipelineLayoutCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ VkDescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const VkPushConstantRange* pPushConstantRanges;
+ safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct);
+ safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src);
+ safe_VkPipelineLayoutCreateInfo();
+ ~safe_VkPipelineLayoutCreateInfo();
+ void initialize(const VkPipelineLayoutCreateInfo* in_struct);
+ void initialize(const safe_VkPipelineLayoutCreateInfo* src);
+ VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); }
+ VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); }
+};
+
+struct safe_VkSamplerCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkSamplerCreateFlags flags;
+ VkFilter magFilter;
+ VkFilter minFilter;
+ VkSamplerMipmapMode mipmapMode;
+ VkSamplerAddressMode addressModeU;
+ VkSamplerAddressMode addressModeV;
+ VkSamplerAddressMode addressModeW;
+ float mipLodBias;
+ VkBool32 anisotropyEnable;
+ float maxAnisotropy;
+ VkBool32 compareEnable;
+ VkCompareOp compareOp;
+ float minLod;
+ float maxLod;
+ VkBorderColor borderColor;
+ VkBool32 unnormalizedCoordinates;
+ safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct);
+ safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src);
+ safe_VkSamplerCreateInfo();
+ ~safe_VkSamplerCreateInfo();
+ void initialize(const VkSamplerCreateInfo* in_struct);
+ void initialize(const safe_VkSamplerCreateInfo* src);
+ VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); }
+ VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); }
+};
+
+struct safe_VkDescriptorSetLayoutBinding {
+ uint32_t binding;
+ VkDescriptorType descriptorType;
+ uint32_t descriptorCount;
+ VkShaderStageFlags stageFlags;
+ VkSampler* pImmutableSamplers;
+ safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct);
+ safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src);
+ safe_VkDescriptorSetLayoutBinding();
+ ~safe_VkDescriptorSetLayoutBinding();
+ void initialize(const VkDescriptorSetLayoutBinding* in_struct);
+ void initialize(const safe_VkDescriptorSetLayoutBinding* src);
+ VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); }
+ VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); }
+};
+
+struct safe_VkDescriptorSetLayoutCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ safe_VkDescriptorSetLayoutBinding* pBindings;
+ safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct);
+ safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src);
+ safe_VkDescriptorSetLayoutCreateInfo();
+ ~safe_VkDescriptorSetLayoutCreateInfo();
+ void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct);
+ void initialize(const safe_VkDescriptorSetLayoutCreateInfo* src);
+ VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); }
+ VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); }
+};
+
+struct safe_VkDescriptorPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t poolSizeCount;
+ const VkDescriptorPoolSize* pPoolSizes;
+ safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct);
+ safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src);
+ safe_VkDescriptorPoolCreateInfo();
+ ~safe_VkDescriptorPoolCreateInfo();
+ void initialize(const VkDescriptorPoolCreateInfo* in_struct);
+ void initialize(const safe_VkDescriptorPoolCreateInfo* src);
+ VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); }
+ VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); }
+};
+
+struct safe_VkDescriptorSetAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPool descriptorPool;
+ uint32_t descriptorSetCount;
+ VkDescriptorSetLayout* pSetLayouts;
+ safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct);
+ safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src);
+ safe_VkDescriptorSetAllocateInfo();
+ ~safe_VkDescriptorSetAllocateInfo();
+ void initialize(const VkDescriptorSetAllocateInfo* in_struct);
+ void initialize(const safe_VkDescriptorSetAllocateInfo* src);
+ VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); }
+ VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); }
+};
+
+struct safe_VkWriteDescriptorSet {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ VkDescriptorType descriptorType;
+ VkDescriptorImageInfo* pImageInfo;
+ VkDescriptorBufferInfo* pBufferInfo;
+ VkBufferView* pTexelBufferView;
+ safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct);
+ safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src);
+ safe_VkWriteDescriptorSet();
+ ~safe_VkWriteDescriptorSet();
+ void initialize(const VkWriteDescriptorSet* in_struct);
+ void initialize(const safe_VkWriteDescriptorSet* src);
+ VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); }
+ VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); }
+};
+
+struct safe_VkCopyDescriptorSet {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet srcSet;
+ uint32_t srcBinding;
+ uint32_t srcArrayElement;
+ VkDescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct);
+ safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src);
+ safe_VkCopyDescriptorSet();
+ ~safe_VkCopyDescriptorSet();
+ void initialize(const VkCopyDescriptorSet* in_struct);
+ void initialize(const safe_VkCopyDescriptorSet* src);
+ VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); }
+ VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); }
+};
+
+struct safe_VkFramebufferCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkFramebufferCreateFlags flags;
+ VkRenderPass renderPass;
+ uint32_t attachmentCount;
+ VkImageView* pAttachments;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layers;
+ safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct);
+ safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src);
+ safe_VkFramebufferCreateInfo();
+ ~safe_VkFramebufferCreateInfo();
+ void initialize(const VkFramebufferCreateInfo* in_struct);
+ void initialize(const safe_VkFramebufferCreateInfo* src);
+ VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); }
+ VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); }
+};
+
+struct safe_VkSubpassDescription {
+ VkSubpassDescriptionFlags flags;
+ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+ const VkAttachmentReference* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const VkAttachmentReference* pColorAttachments;
+ const VkAttachmentReference* pResolveAttachments;
+ const VkAttachmentReference* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
+ safe_VkSubpassDescription(const VkSubpassDescription* in_struct);
+ safe_VkSubpassDescription(const safe_VkSubpassDescription& src);
+ safe_VkSubpassDescription();
+ ~safe_VkSubpassDescription();
+ void initialize(const VkSubpassDescription* in_struct);
+ void initialize(const safe_VkSubpassDescription* src);
+ VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); }
+ VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); }
+};
+
+struct safe_VkRenderPassCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const VkAttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+ safe_VkSubpassDescription* pSubpasses;
+ uint32_t dependencyCount;
+ const VkSubpassDependency* pDependencies;
+ safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct);
+ safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src);
+ safe_VkRenderPassCreateInfo();
+ ~safe_VkRenderPassCreateInfo();
+ void initialize(const VkRenderPassCreateInfo* in_struct);
+ void initialize(const safe_VkRenderPassCreateInfo* src);
+ VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); }
+ VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); }
+};
+
+struct safe_VkCommandPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct);
+ safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src);
+ safe_VkCommandPoolCreateInfo();
+ ~safe_VkCommandPoolCreateInfo();
+ void initialize(const VkCommandPoolCreateInfo* in_struct);
+ void initialize(const safe_VkCommandPoolCreateInfo* src);
+ VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); }
+ VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); }
+};
+
+struct safe_VkCommandBufferAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandPool commandPool;
+ VkCommandBufferLevel level;
+ uint32_t commandBufferCount;
+ safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct);
+ safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src);
+ safe_VkCommandBufferAllocateInfo();
+ ~safe_VkCommandBufferAllocateInfo();
+ void initialize(const VkCommandBufferAllocateInfo* in_struct);
+ void initialize(const safe_VkCommandBufferAllocateInfo* src);
+ VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); }
+ VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); }
+};
+
+struct safe_VkCommandBufferInheritanceInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkFramebuffer framebuffer;
+ VkBool32 occlusionQueryEnable;
+ VkQueryControlFlags queryFlags;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+ safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct);
+ safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src);
+ safe_VkCommandBufferInheritanceInfo();
+ ~safe_VkCommandBufferInheritanceInfo();
+ void initialize(const VkCommandBufferInheritanceInfo* in_struct);
+ void initialize(const safe_VkCommandBufferInheritanceInfo* src);
+ VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); }
+ VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); }
+};
+
+struct safe_VkCommandBufferBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandBufferUsageFlags flags;
+ safe_VkCommandBufferInheritanceInfo* pInheritanceInfo;
+ safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct);
+ safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src);
+ safe_VkCommandBufferBeginInfo();
+ ~safe_VkCommandBufferBeginInfo();
+ void initialize(const VkCommandBufferBeginInfo* in_struct);
+ void initialize(const safe_VkCommandBufferBeginInfo* src);
+ VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); }
+ VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); }
+};
+
+struct safe_VkMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct);
+ safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src);
+ safe_VkMemoryBarrier();
+ ~safe_VkMemoryBarrier();
+ void initialize(const VkMemoryBarrier* in_struct);
+ void initialize(const safe_VkMemoryBarrier* src);
+ VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); }
+ VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); }
+};
+
+struct safe_VkBufferMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct);
+ safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src);
+ safe_VkBufferMemoryBarrier();
+ ~safe_VkBufferMemoryBarrier();
+ void initialize(const VkBufferMemoryBarrier* in_struct);
+ void initialize(const safe_VkBufferMemoryBarrier* src);
+ VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); }
+ VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); }
+};
+
+struct safe_VkImageMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkImage image;
+ VkImageSubresourceRange subresourceRange;
+ safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct);
+ safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src);
+ safe_VkImageMemoryBarrier();
+ ~safe_VkImageMemoryBarrier();
+ void initialize(const VkImageMemoryBarrier* in_struct);
+ void initialize(const safe_VkImageMemoryBarrier* src);
+ VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); }
+ VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); }
+};
+
+struct safe_VkRenderPassBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
+ VkRect2D renderArea;
+ uint32_t clearValueCount;
+ const VkClearValue* pClearValues;
+ safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct);
+ safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src);
+ safe_VkRenderPassBeginInfo();
+ ~safe_VkRenderPassBeginInfo();
+ void initialize(const VkRenderPassBeginInfo* in_struct);
+ void initialize(const safe_VkRenderPassBeginInfo* src);
+ VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); }
+ VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); }
+};
+
+struct safe_VkSwapchainCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSwapchainCreateFlagsKHR flags;
+ VkSurfaceKHR surface;
+ uint32_t minImageCount;
+ VkFormat imageFormat;
+ VkColorSpaceKHR imageColorSpace;
+ VkExtent2D imageExtent;
+ uint32_t imageArrayLayers;
+ VkImageUsageFlags imageUsage;
+ VkSharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ VkSurfaceTransformFlagBitsKHR preTransform;
+ VkCompositeAlphaFlagBitsKHR compositeAlpha;
+ VkPresentModeKHR presentMode;
+ VkBool32 clipped;
+ VkSwapchainKHR oldSwapchain;
+ safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct);
+ safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src);
+ safe_VkSwapchainCreateInfoKHR();
+ ~safe_VkSwapchainCreateInfoKHR();
+ void initialize(const VkSwapchainCreateInfoKHR* in_struct);
+ void initialize(const safe_VkSwapchainCreateInfoKHR* src);
+ VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); }
+ VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkPresentInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ VkSemaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ VkSwapchainKHR* pSwapchains;
+ const uint32_t* pImageIndices;
+ VkResult* pResults;
+ safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct);
+ safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src);
+ safe_VkPresentInfoKHR();
+ ~safe_VkPresentInfoKHR();
+ void initialize(const VkPresentInfoKHR* in_struct);
+ void initialize(const safe_VkPresentInfoKHR* src);
+ VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); }
+ VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); }
+};
+
+struct safe_VkDisplayPropertiesKHR {
+ VkDisplayKHR display;
+ const char* displayName;
+ VkExtent2D physicalDimensions;
+ VkExtent2D physicalResolution;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkBool32 planeReorderPossible;
+ VkBool32 persistentContent;
+ safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct);
+ safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src);
+ safe_VkDisplayPropertiesKHR();
+ ~safe_VkDisplayPropertiesKHR();
+ void initialize(const VkDisplayPropertiesKHR* in_struct);
+ void initialize(const safe_VkDisplayPropertiesKHR* src);
+ VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); }
+ VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); }
+};
+
+struct safe_VkDisplayModeCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayModeCreateFlagsKHR flags;
+ VkDisplayModeParametersKHR parameters;
+ safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct);
+ safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src);
+ safe_VkDisplayModeCreateInfoKHR();
+ ~safe_VkDisplayModeCreateInfoKHR();
+ void initialize(const VkDisplayModeCreateInfoKHR* in_struct);
+ void initialize(const safe_VkDisplayModeCreateInfoKHR* src);
+ VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); }
+ VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplaySurfaceCreateFlagsKHR flags;
+ VkDisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ VkSurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+ VkExtent2D imageExtent;
+ safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct);
+ safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src);
+ safe_VkDisplaySurfaceCreateInfoKHR();
+ ~safe_VkDisplaySurfaceCreateInfoKHR();
+ void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src);
+ VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); }
+ VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkDisplayPresentInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkRect2D srcRect;
+ VkRect2D dstRect;
+ VkBool32 persistent;
+ safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct);
+ safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src);
+ safe_VkDisplayPresentInfoKHR();
+ ~safe_VkDisplayPresentInfoKHR();
+ void initialize(const VkDisplayPresentInfoKHR* in_struct);
+ void initialize(const safe_VkDisplayPresentInfoKHR* src);
+ VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); }
+ VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+struct safe_VkXlibSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkXlibSurfaceCreateFlagsKHR flags;
+ Display* dpy;
+ Window window;
+ safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* in_struct);
+ safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& src);
+ safe_VkXlibSurfaceCreateInfoKHR();
+ ~safe_VkXlibSurfaceCreateInfoKHR();
+ void initialize(const VkXlibSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkXlibSurfaceCreateInfoKHR* src);
+ VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); }
+ VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+struct safe_VkXcbSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkXcbSurfaceCreateFlagsKHR flags;
+ xcb_connection_t* connection;
+ xcb_window_t window;
+ safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* in_struct);
+ safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& src);
+ safe_VkXcbSurfaceCreateInfoKHR();
+ ~safe_VkXcbSurfaceCreateInfoKHR();
+ void initialize(const VkXcbSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkXcbSurfaceCreateInfoKHR* src);
+ VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); }
+ VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+struct safe_VkWaylandSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkWaylandSurfaceCreateFlagsKHR flags;
+ struct wl_display* display;
+ struct wl_surface* surface;
+ safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* in_struct);
+ safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& src);
+ safe_VkWaylandSurfaceCreateInfoKHR();
+ ~safe_VkWaylandSurfaceCreateInfoKHR();
+ void initialize(const VkWaylandSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* src);
+ VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); }
+ VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+struct safe_VkMirSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkMirSurfaceCreateFlagsKHR flags;
+ MirConnection* connection;
+ MirSurface* mirSurface;
+ safe_VkMirSurfaceCreateInfoKHR(const VkMirSurfaceCreateInfoKHR* in_struct);
+ safe_VkMirSurfaceCreateInfoKHR(const safe_VkMirSurfaceCreateInfoKHR& src);
+ safe_VkMirSurfaceCreateInfoKHR();
+ ~safe_VkMirSurfaceCreateInfoKHR();
+ void initialize(const VkMirSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkMirSurfaceCreateInfoKHR* src);
+ VkMirSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkMirSurfaceCreateInfoKHR *>(this); }
+ VkMirSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkMirSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkAndroidSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkAndroidSurfaceCreateFlagsKHR flags;
+ ANativeWindow* window;
+ safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* in_struct);
+ safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& src);
+ safe_VkAndroidSurfaceCreateInfoKHR();
+ ~safe_VkAndroidSurfaceCreateInfoKHR();
+ void initialize(const VkAndroidSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* src);
+ VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); }
+ VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkWin32SurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkWin32SurfaceCreateFlagsKHR flags;
+ HINSTANCE hinstance;
+ HWND hwnd;
+ safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* in_struct);
+ safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& src);
+ safe_VkWin32SurfaceCreateInfoKHR();
+ ~safe_VkWin32SurfaceCreateInfoKHR();
+ void initialize(const VkWin32SurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkWin32SurfaceCreateInfoKHR* src);
+ VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); }
+ VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+struct safe_VkMagmaSurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t imagePipeHandle;
+ uint32_t width;
+ uint32_t height;
+ safe_VkMagmaSurfaceCreateInfoKHR(const VkMagmaSurfaceCreateInfoKHR* in_struct);
+ safe_VkMagmaSurfaceCreateInfoKHR(const safe_VkMagmaSurfaceCreateInfoKHR& src);
+ safe_VkMagmaSurfaceCreateInfoKHR();
+ ~safe_VkMagmaSurfaceCreateInfoKHR();
+ void initialize(const VkMagmaSurfaceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkMagmaSurfaceCreateInfoKHR* src);
+ VkMagmaSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkMagmaSurfaceCreateInfoKHR *>(this); }
+ VkMagmaSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkMagmaSurfaceCreateInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+struct safe_VkPhysicalDeviceFeatures2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkPhysicalDeviceFeatures features;
+ safe_VkPhysicalDeviceFeatures2KHR(const VkPhysicalDeviceFeatures2KHR* in_struct);
+ safe_VkPhysicalDeviceFeatures2KHR(const safe_VkPhysicalDeviceFeatures2KHR& src);
+ safe_VkPhysicalDeviceFeatures2KHR();
+ ~safe_VkPhysicalDeviceFeatures2KHR();
+ void initialize(const VkPhysicalDeviceFeatures2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceFeatures2KHR* src);
+ VkPhysicalDeviceFeatures2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2KHR *>(this); }
+ VkPhysicalDeviceFeatures2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkPhysicalDeviceProperties properties;
+ safe_VkPhysicalDeviceProperties2KHR(const VkPhysicalDeviceProperties2KHR* in_struct);
+ safe_VkPhysicalDeviceProperties2KHR(const safe_VkPhysicalDeviceProperties2KHR& src);
+ safe_VkPhysicalDeviceProperties2KHR();
+ ~safe_VkPhysicalDeviceProperties2KHR();
+ void initialize(const VkPhysicalDeviceProperties2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceProperties2KHR* src);
+ VkPhysicalDeviceProperties2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2KHR *>(this); }
+ VkPhysicalDeviceProperties2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2KHR const *>(this); }
+};
+
+struct safe_VkFormatProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkFormatProperties formatProperties;
+ safe_VkFormatProperties2KHR(const VkFormatProperties2KHR* in_struct);
+ safe_VkFormatProperties2KHR(const safe_VkFormatProperties2KHR& src);
+ safe_VkFormatProperties2KHR();
+ ~safe_VkFormatProperties2KHR();
+ void initialize(const VkFormatProperties2KHR* in_struct);
+ void initialize(const safe_VkFormatProperties2KHR* src);
+ VkFormatProperties2KHR *ptr() { return reinterpret_cast<VkFormatProperties2KHR *>(this); }
+ VkFormatProperties2KHR const *ptr() const { return reinterpret_cast<VkFormatProperties2KHR const *>(this); }
+};
+
+struct safe_VkImageFormatProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkImageFormatProperties imageFormatProperties;
+ safe_VkImageFormatProperties2KHR(const VkImageFormatProperties2KHR* in_struct);
+ safe_VkImageFormatProperties2KHR(const safe_VkImageFormatProperties2KHR& src);
+ safe_VkImageFormatProperties2KHR();
+ ~safe_VkImageFormatProperties2KHR();
+ void initialize(const VkImageFormatProperties2KHR* in_struct);
+ void initialize(const safe_VkImageFormatProperties2KHR* src);
+ VkImageFormatProperties2KHR *ptr() { return reinterpret_cast<VkImageFormatProperties2KHR *>(this); }
+ VkImageFormatProperties2KHR const *ptr() const { return reinterpret_cast<VkImageFormatProperties2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceImageFormatInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ VkImageType type;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+ VkImageCreateFlags flags;
+ safe_VkPhysicalDeviceImageFormatInfo2KHR(const VkPhysicalDeviceImageFormatInfo2KHR* in_struct);
+ safe_VkPhysicalDeviceImageFormatInfo2KHR(const safe_VkPhysicalDeviceImageFormatInfo2KHR& src);
+ safe_VkPhysicalDeviceImageFormatInfo2KHR();
+ ~safe_VkPhysicalDeviceImageFormatInfo2KHR();
+ void initialize(const VkPhysicalDeviceImageFormatInfo2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceImageFormatInfo2KHR* src);
+ VkPhysicalDeviceImageFormatInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2KHR *>(this); }
+ VkPhysicalDeviceImageFormatInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2KHR const *>(this); }
+};
+
+struct safe_VkQueueFamilyProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkQueueFamilyProperties queueFamilyProperties;
+ safe_VkQueueFamilyProperties2KHR(const VkQueueFamilyProperties2KHR* in_struct);
+ safe_VkQueueFamilyProperties2KHR(const safe_VkQueueFamilyProperties2KHR& src);
+ safe_VkQueueFamilyProperties2KHR();
+ ~safe_VkQueueFamilyProperties2KHR();
+ void initialize(const VkQueueFamilyProperties2KHR* in_struct);
+ void initialize(const safe_VkQueueFamilyProperties2KHR* src);
+ VkQueueFamilyProperties2KHR *ptr() { return reinterpret_cast<VkQueueFamilyProperties2KHR *>(this); }
+ VkQueueFamilyProperties2KHR const *ptr() const { return reinterpret_cast<VkQueueFamilyProperties2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceMemoryProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkPhysicalDeviceMemoryProperties memoryProperties;
+ safe_VkPhysicalDeviceMemoryProperties2KHR(const VkPhysicalDeviceMemoryProperties2KHR* in_struct);
+ safe_VkPhysicalDeviceMemoryProperties2KHR(const safe_VkPhysicalDeviceMemoryProperties2KHR& src);
+ safe_VkPhysicalDeviceMemoryProperties2KHR();
+ ~safe_VkPhysicalDeviceMemoryProperties2KHR();
+ void initialize(const VkPhysicalDeviceMemoryProperties2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceMemoryProperties2KHR* src);
+ VkPhysicalDeviceMemoryProperties2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR *>(this); }
+ VkPhysicalDeviceMemoryProperties2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR const *>(this); }
+};
+
+struct safe_VkSparseImageFormatProperties2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSparseImageFormatProperties properties;
+ safe_VkSparseImageFormatProperties2KHR(const VkSparseImageFormatProperties2KHR* in_struct);
+ safe_VkSparseImageFormatProperties2KHR(const safe_VkSparseImageFormatProperties2KHR& src);
+ safe_VkSparseImageFormatProperties2KHR();
+ ~safe_VkSparseImageFormatProperties2KHR();
+ void initialize(const VkSparseImageFormatProperties2KHR* in_struct);
+ void initialize(const safe_VkSparseImageFormatProperties2KHR* src);
+ VkSparseImageFormatProperties2KHR *ptr() { return reinterpret_cast<VkSparseImageFormatProperties2KHR *>(this); }
+ VkSparseImageFormatProperties2KHR const *ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceSparseImageFormatInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ VkImageType type;
+ VkSampleCountFlagBits samples;
+ VkImageUsageFlags usage;
+ VkImageTiling tiling;
+ safe_VkPhysicalDeviceSparseImageFormatInfo2KHR(const VkPhysicalDeviceSparseImageFormatInfo2KHR* in_struct);
+ safe_VkPhysicalDeviceSparseImageFormatInfo2KHR(const safe_VkPhysicalDeviceSparseImageFormatInfo2KHR& src);
+ safe_VkPhysicalDeviceSparseImageFormatInfo2KHR();
+ ~safe_VkPhysicalDeviceSparseImageFormatInfo2KHR();
+ void initialize(const VkPhysicalDeviceSparseImageFormatInfo2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2KHR* src);
+ VkPhysicalDeviceSparseImageFormatInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2KHR *>(this); }
+ VkPhysicalDeviceSparseImageFormatInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceExternalImageFormatInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ safe_VkPhysicalDeviceExternalImageFormatInfoKHR(const VkPhysicalDeviceExternalImageFormatInfoKHR* in_struct);
+ safe_VkPhysicalDeviceExternalImageFormatInfoKHR(const safe_VkPhysicalDeviceExternalImageFormatInfoKHR& src);
+ safe_VkPhysicalDeviceExternalImageFormatInfoKHR();
+ ~safe_VkPhysicalDeviceExternalImageFormatInfoKHR();
+ void initialize(const VkPhysicalDeviceExternalImageFormatInfoKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfoKHR* src);
+ VkPhysicalDeviceExternalImageFormatInfoKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfoKHR *>(this); }
+ VkPhysicalDeviceExternalImageFormatInfoKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfoKHR const *>(this); }
+};
+
+struct safe_VkExternalImageFormatPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkExternalMemoryPropertiesKHR externalMemoryProperties;
+ safe_VkExternalImageFormatPropertiesKHR(const VkExternalImageFormatPropertiesKHR* in_struct);
+ safe_VkExternalImageFormatPropertiesKHR(const safe_VkExternalImageFormatPropertiesKHR& src);
+ safe_VkExternalImageFormatPropertiesKHR();
+ ~safe_VkExternalImageFormatPropertiesKHR();
+ void initialize(const VkExternalImageFormatPropertiesKHR* in_struct);
+ void initialize(const safe_VkExternalImageFormatPropertiesKHR* src);
+ VkExternalImageFormatPropertiesKHR *ptr() { return reinterpret_cast<VkExternalImageFormatPropertiesKHR *>(this); }
+ VkExternalImageFormatPropertiesKHR const *ptr() const { return reinterpret_cast<VkExternalImageFormatPropertiesKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceExternalBufferInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCreateFlags flags;
+ VkBufferUsageFlags usage;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ safe_VkPhysicalDeviceExternalBufferInfoKHR(const VkPhysicalDeviceExternalBufferInfoKHR* in_struct);
+ safe_VkPhysicalDeviceExternalBufferInfoKHR(const safe_VkPhysicalDeviceExternalBufferInfoKHR& src);
+ safe_VkPhysicalDeviceExternalBufferInfoKHR();
+ ~safe_VkPhysicalDeviceExternalBufferInfoKHR();
+ void initialize(const VkPhysicalDeviceExternalBufferInfoKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceExternalBufferInfoKHR* src);
+ VkPhysicalDeviceExternalBufferInfoKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfoKHR *>(this); }
+ VkPhysicalDeviceExternalBufferInfoKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfoKHR const *>(this); }
+};
+
+struct safe_VkExternalBufferPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkExternalMemoryPropertiesKHR externalMemoryProperties;
+ safe_VkExternalBufferPropertiesKHR(const VkExternalBufferPropertiesKHR* in_struct);
+ safe_VkExternalBufferPropertiesKHR(const safe_VkExternalBufferPropertiesKHR& src);
+ safe_VkExternalBufferPropertiesKHR();
+ ~safe_VkExternalBufferPropertiesKHR();
+ void initialize(const VkExternalBufferPropertiesKHR* in_struct);
+ void initialize(const safe_VkExternalBufferPropertiesKHR* src);
+ VkExternalBufferPropertiesKHR *ptr() { return reinterpret_cast<VkExternalBufferPropertiesKHR *>(this); }
+ VkExternalBufferPropertiesKHR const *ptr() const { return reinterpret_cast<VkExternalBufferPropertiesKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceIDPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint8_t deviceUUID[VK_UUID_SIZE];
+ uint8_t driverUUID[VK_UUID_SIZE];
+ uint8_t deviceLUID[VK_LUID_SIZE_KHR];
+ uint32_t deviceNodeMask;
+ VkBool32 deviceLUIDValid;
+ safe_VkPhysicalDeviceIDPropertiesKHR(const VkPhysicalDeviceIDPropertiesKHR* in_struct);
+ safe_VkPhysicalDeviceIDPropertiesKHR(const safe_VkPhysicalDeviceIDPropertiesKHR& src);
+ safe_VkPhysicalDeviceIDPropertiesKHR();
+ ~safe_VkPhysicalDeviceIDPropertiesKHR();
+ void initialize(const VkPhysicalDeviceIDPropertiesKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceIDPropertiesKHR* src);
+ VkPhysicalDeviceIDPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceIDPropertiesKHR *>(this); }
+ VkPhysicalDeviceIDPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIDPropertiesKHR const *>(this); }
+};
+
+struct safe_VkExternalMemoryImageCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHR handleTypes;
+ safe_VkExternalMemoryImageCreateInfoKHR(const VkExternalMemoryImageCreateInfoKHR* in_struct);
+ safe_VkExternalMemoryImageCreateInfoKHR(const safe_VkExternalMemoryImageCreateInfoKHR& src);
+ safe_VkExternalMemoryImageCreateInfoKHR();
+ ~safe_VkExternalMemoryImageCreateInfoKHR();
+ void initialize(const VkExternalMemoryImageCreateInfoKHR* in_struct);
+ void initialize(const safe_VkExternalMemoryImageCreateInfoKHR* src);
+ VkExternalMemoryImageCreateInfoKHR *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoKHR *>(this); }
+ VkExternalMemoryImageCreateInfoKHR const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkExternalMemoryBufferCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHR handleTypes;
+ safe_VkExternalMemoryBufferCreateInfoKHR(const VkExternalMemoryBufferCreateInfoKHR* in_struct);
+ safe_VkExternalMemoryBufferCreateInfoKHR(const safe_VkExternalMemoryBufferCreateInfoKHR& src);
+ safe_VkExternalMemoryBufferCreateInfoKHR();
+ ~safe_VkExternalMemoryBufferCreateInfoKHR();
+ void initialize(const VkExternalMemoryBufferCreateInfoKHR* in_struct);
+ void initialize(const safe_VkExternalMemoryBufferCreateInfoKHR* src);
+ VkExternalMemoryBufferCreateInfoKHR *ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfoKHR *>(this); }
+ VkExternalMemoryBufferCreateInfoKHR const *ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkExportMemoryAllocateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHR handleTypes;
+ safe_VkExportMemoryAllocateInfoKHR(const VkExportMemoryAllocateInfoKHR* in_struct);
+ safe_VkExportMemoryAllocateInfoKHR(const safe_VkExportMemoryAllocateInfoKHR& src);
+ safe_VkExportMemoryAllocateInfoKHR();
+ ~safe_VkExportMemoryAllocateInfoKHR();
+ void initialize(const VkExportMemoryAllocateInfoKHR* in_struct);
+ void initialize(const safe_VkExportMemoryAllocateInfoKHR* src);
+ VkExportMemoryAllocateInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoKHR *>(this); }
+ VkExportMemoryAllocateInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoKHR const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportMemoryWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct);
+ safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& src);
+ safe_VkImportMemoryWin32HandleInfoKHR();
+ ~safe_VkImportMemoryWin32HandleInfoKHR();
+ void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* src);
+ VkImportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>(this); }
+ VkImportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkExportMemoryWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct);
+ safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& src);
+ safe_VkExportMemoryWin32HandleInfoKHR();
+ ~safe_VkExportMemoryWin32HandleInfoKHR();
+ void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* src);
+ VkExportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>(this); }
+ VkExportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkMemoryWin32HandlePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t memoryTypeBits;
+ safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct);
+ safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& src);
+ safe_VkMemoryWin32HandlePropertiesKHR();
+ ~safe_VkMemoryWin32HandlePropertiesKHR();
+ void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct);
+ void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* src);
+ VkMemoryWin32HandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(this); }
+ VkMemoryWin32HandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkMemoryGetWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct);
+ safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& src);
+ safe_VkMemoryGetWin32HandleInfoKHR();
+ ~safe_VkMemoryGetWin32HandleInfoKHR();
+ void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* src);
+ VkMemoryGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>(this); }
+ VkMemoryGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+struct safe_VkImportMemoryFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ int fd;
+ safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct);
+ safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& src);
+ safe_VkImportMemoryFdInfoKHR();
+ ~safe_VkImportMemoryFdInfoKHR();
+ void initialize(const VkImportMemoryFdInfoKHR* in_struct);
+ void initialize(const safe_VkImportMemoryFdInfoKHR* src);
+ VkImportMemoryFdInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR *>(this); }
+ VkImportMemoryFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const *>(this); }
+};
+
+struct safe_VkMemoryFdPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t memoryTypeBits;
+ safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct);
+ safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& src);
+ safe_VkMemoryFdPropertiesKHR();
+ ~safe_VkMemoryFdPropertiesKHR();
+ void initialize(const VkMemoryFdPropertiesKHR* in_struct);
+ void initialize(const safe_VkMemoryFdPropertiesKHR* src);
+ VkMemoryFdPropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR *>(this); }
+ VkMemoryFdPropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const *>(this); }
+};
+
+struct safe_VkMemoryGetFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct);
+ safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& src);
+ safe_VkMemoryGetFdInfoKHR();
+ ~safe_VkMemoryGetFdInfoKHR();
+ void initialize(const VkMemoryGetFdInfoKHR* in_struct);
+ void initialize(const safe_VkMemoryGetFdInfoKHR* src);
+ VkMemoryGetFdInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR *>(this); }
+ VkMemoryGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t acquireCount;
+ VkDeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeouts;
+ uint32_t releaseCount;
+ VkDeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
+ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct);
+ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src);
+ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
+ ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
+ void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct);
+ void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* src);
+ VkWin32KeyedMutexAcquireReleaseInfoKHR *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>(this); }
+ VkWin32KeyedMutexAcquireReleaseInfoKHR const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+struct safe_VkPhysicalDeviceExternalSemaphoreInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ safe_VkPhysicalDeviceExternalSemaphoreInfoKHR(const VkPhysicalDeviceExternalSemaphoreInfoKHR* in_struct);
+ safe_VkPhysicalDeviceExternalSemaphoreInfoKHR(const safe_VkPhysicalDeviceExternalSemaphoreInfoKHR& src);
+ safe_VkPhysicalDeviceExternalSemaphoreInfoKHR();
+ ~safe_VkPhysicalDeviceExternalSemaphoreInfoKHR();
+ void initialize(const VkPhysicalDeviceExternalSemaphoreInfoKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfoKHR* src);
+ VkPhysicalDeviceExternalSemaphoreInfoKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfoKHR *>(this); }
+ VkPhysicalDeviceExternalSemaphoreInfoKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfoKHR const *>(this); }
+};
+
+struct safe_VkExternalSemaphorePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes;
+ VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes;
+ VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures;
+ safe_VkExternalSemaphorePropertiesKHR(const VkExternalSemaphorePropertiesKHR* in_struct);
+ safe_VkExternalSemaphorePropertiesKHR(const safe_VkExternalSemaphorePropertiesKHR& src);
+ safe_VkExternalSemaphorePropertiesKHR();
+ ~safe_VkExternalSemaphorePropertiesKHR();
+ void initialize(const VkExternalSemaphorePropertiesKHR* in_struct);
+ void initialize(const safe_VkExternalSemaphorePropertiesKHR* src);
+ VkExternalSemaphorePropertiesKHR *ptr() { return reinterpret_cast<VkExternalSemaphorePropertiesKHR *>(this); }
+ VkExternalSemaphorePropertiesKHR const *ptr() const { return reinterpret_cast<VkExternalSemaphorePropertiesKHR const *>(this); }
+};
+
+struct safe_VkExportSemaphoreCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHR handleTypes;
+ safe_VkExportSemaphoreCreateInfoKHR(const VkExportSemaphoreCreateInfoKHR* in_struct);
+ safe_VkExportSemaphoreCreateInfoKHR(const safe_VkExportSemaphoreCreateInfoKHR& src);
+ safe_VkExportSemaphoreCreateInfoKHR();
+ ~safe_VkExportSemaphoreCreateInfoKHR();
+ void initialize(const VkExportSemaphoreCreateInfoKHR* in_struct);
+ void initialize(const safe_VkExportSemaphoreCreateInfoKHR* src);
+ VkExportSemaphoreCreateInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfoKHR *>(this); }
+ VkExportSemaphoreCreateInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfoKHR const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportSemaphoreWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkSemaphoreImportFlagsKHR flags;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct);
+ safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& src);
+ safe_VkImportSemaphoreWin32HandleInfoKHR();
+ ~safe_VkImportSemaphoreWin32HandleInfoKHR();
+ void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* src);
+ VkImportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>(this); }
+ VkImportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkExportSemaphoreWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct);
+ safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& src);
+ safe_VkExportSemaphoreWin32HandleInfoKHR();
+ ~safe_VkExportSemaphoreWin32HandleInfoKHR();
+ void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* src);
+ VkExportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>(this); }
+ VkExportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkD3D12FenceSubmitInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreValuesCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValuesCount;
+ const uint64_t* pSignalSemaphoreValues;
+ safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct);
+ safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& src);
+ safe_VkD3D12FenceSubmitInfoKHR();
+ ~safe_VkD3D12FenceSubmitInfoKHR();
+ void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct);
+ void initialize(const safe_VkD3D12FenceSubmitInfoKHR* src);
+ VkD3D12FenceSubmitInfoKHR *ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>(this); }
+ VkD3D12FenceSubmitInfoKHR const *ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkSemaphoreGetWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct);
+ safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& src);
+ safe_VkSemaphoreGetWin32HandleInfoKHR();
+ ~safe_VkSemaphoreGetWin32HandleInfoKHR();
+ void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* src);
+ VkSemaphoreGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>(this); }
+ VkSemaphoreGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+struct safe_VkImportSemaphoreFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkSemaphoreImportFlagsKHR flags;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ int fd;
+ safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct);
+ safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& src);
+ safe_VkImportSemaphoreFdInfoKHR();
+ ~safe_VkImportSemaphoreFdInfoKHR();
+ void initialize(const VkImportSemaphoreFdInfoKHR* in_struct);
+ void initialize(const safe_VkImportSemaphoreFdInfoKHR* src);
+ VkImportSemaphoreFdInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR *>(this); }
+ VkImportSemaphoreFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const *>(this); }
+};
+
+struct safe_VkSemaphoreGetFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct);
+ safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& src);
+ safe_VkSemaphoreGetFdInfoKHR();
+ ~safe_VkSemaphoreGetFdInfoKHR();
+ void initialize(const VkSemaphoreGetFdInfoKHR* in_struct);
+ void initialize(const safe_VkSemaphoreGetFdInfoKHR* src);
+ VkSemaphoreGetFdInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR *>(this); }
+ VkSemaphoreGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t maxPushDescriptors;
+ safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct);
+ safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src);
+ safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
+ ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
+ void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct);
+ void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* src);
+ VkPhysicalDevicePushDescriptorPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>(this); }
+ VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDevice16BitStorageFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 storageBuffer16BitAccess;
+ VkBool32 uniformAndStorageBuffer16BitAccess;
+ VkBool32 storagePushConstant16;
+ VkBool32 storageInputOutput16;
+ safe_VkPhysicalDevice16BitStorageFeaturesKHR(const VkPhysicalDevice16BitStorageFeaturesKHR* in_struct);
+ safe_VkPhysicalDevice16BitStorageFeaturesKHR(const safe_VkPhysicalDevice16BitStorageFeaturesKHR& src);
+ safe_VkPhysicalDevice16BitStorageFeaturesKHR();
+ ~safe_VkPhysicalDevice16BitStorageFeaturesKHR();
+ void initialize(const VkPhysicalDevice16BitStorageFeaturesKHR* in_struct);
+ void initialize(const safe_VkPhysicalDevice16BitStorageFeaturesKHR* src);
+ VkPhysicalDevice16BitStorageFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeaturesKHR *>(this); }
+ VkPhysicalDevice16BitStorageFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevice16BitStorageFeaturesKHR const *>(this); }
+};
+
+struct safe_VkPresentRegionKHR {
+ uint32_t rectangleCount;
+ const VkRectLayerKHR* pRectangles;
+ safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct);
+ safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& src);
+ safe_VkPresentRegionKHR();
+ ~safe_VkPresentRegionKHR();
+ void initialize(const VkPresentRegionKHR* in_struct);
+ void initialize(const safe_VkPresentRegionKHR* src);
+ VkPresentRegionKHR *ptr() { return reinterpret_cast<VkPresentRegionKHR *>(this); }
+ VkPresentRegionKHR const *ptr() const { return reinterpret_cast<VkPresentRegionKHR const *>(this); }
+};
+
+struct safe_VkPresentRegionsKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t swapchainCount;
+ safe_VkPresentRegionKHR* pRegions;
+ safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct);
+ safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& src);
+ safe_VkPresentRegionsKHR();
+ ~safe_VkPresentRegionsKHR();
+ void initialize(const VkPresentRegionsKHR* in_struct);
+ void initialize(const safe_VkPresentRegionsKHR* src);
+ VkPresentRegionsKHR *ptr() { return reinterpret_cast<VkPresentRegionsKHR *>(this); }
+ VkPresentRegionsKHR const *ptr() const { return reinterpret_cast<VkPresentRegionsKHR const *>(this); }
+};
+
+struct safe_VkDescriptorUpdateTemplateCreateInfoKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkDescriptorUpdateTemplateCreateFlagsKHR flags;
+ uint32_t descriptorUpdateEntryCount;
+ const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
+ VkDescriptorUpdateTemplateTypeKHR templateType;
+ VkDescriptorSetLayout descriptorSetLayout;
+ VkPipelineBindPoint pipelineBindPoint;
+ VkPipelineLayout pipelineLayout;
+ uint32_t set;
+ safe_VkDescriptorUpdateTemplateCreateInfoKHR(const VkDescriptorUpdateTemplateCreateInfoKHR* in_struct);
+ safe_VkDescriptorUpdateTemplateCreateInfoKHR(const safe_VkDescriptorUpdateTemplateCreateInfoKHR& src);
+ safe_VkDescriptorUpdateTemplateCreateInfoKHR();
+ ~safe_VkDescriptorUpdateTemplateCreateInfoKHR();
+ void initialize(const VkDescriptorUpdateTemplateCreateInfoKHR* in_struct);
+ void initialize(const safe_VkDescriptorUpdateTemplateCreateInfoKHR* src);
+ VkDescriptorUpdateTemplateCreateInfoKHR *ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfoKHR *>(this); }
+ VkDescriptorUpdateTemplateCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfoKHR const *>(this); }
+};
+
+struct safe_VkSharedPresentSurfaceCapabilitiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkImageUsageFlags sharedPresentSupportedUsageFlags;
+ safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct);
+ safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src);
+ safe_VkSharedPresentSurfaceCapabilitiesKHR();
+ ~safe_VkSharedPresentSurfaceCapabilitiesKHR();
+ void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct);
+ void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* src);
+ VkSharedPresentSurfaceCapabilitiesKHR *ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>(this); }
+ VkSharedPresentSurfaceCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceExternalFenceInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalFenceHandleTypeFlagBitsKHR handleType;
+ safe_VkPhysicalDeviceExternalFenceInfoKHR(const VkPhysicalDeviceExternalFenceInfoKHR* in_struct);
+ safe_VkPhysicalDeviceExternalFenceInfoKHR(const safe_VkPhysicalDeviceExternalFenceInfoKHR& src);
+ safe_VkPhysicalDeviceExternalFenceInfoKHR();
+ ~safe_VkPhysicalDeviceExternalFenceInfoKHR();
+ void initialize(const VkPhysicalDeviceExternalFenceInfoKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceExternalFenceInfoKHR* src);
+ VkPhysicalDeviceExternalFenceInfoKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfoKHR *>(this); }
+ VkPhysicalDeviceExternalFenceInfoKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfoKHR const *>(this); }
+};
+
+struct safe_VkExternalFencePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes;
+ VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes;
+ VkExternalFenceFeatureFlagsKHR externalFenceFeatures;
+ safe_VkExternalFencePropertiesKHR(const VkExternalFencePropertiesKHR* in_struct);
+ safe_VkExternalFencePropertiesKHR(const safe_VkExternalFencePropertiesKHR& src);
+ safe_VkExternalFencePropertiesKHR();
+ ~safe_VkExternalFencePropertiesKHR();
+ void initialize(const VkExternalFencePropertiesKHR* in_struct);
+ void initialize(const safe_VkExternalFencePropertiesKHR* src);
+ VkExternalFencePropertiesKHR *ptr() { return reinterpret_cast<VkExternalFencePropertiesKHR *>(this); }
+ VkExternalFencePropertiesKHR const *ptr() const { return reinterpret_cast<VkExternalFencePropertiesKHR const *>(this); }
+};
+
+struct safe_VkExportFenceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalFenceHandleTypeFlagsKHR handleTypes;
+ safe_VkExportFenceCreateInfoKHR(const VkExportFenceCreateInfoKHR* in_struct);
+ safe_VkExportFenceCreateInfoKHR(const safe_VkExportFenceCreateInfoKHR& src);
+ safe_VkExportFenceCreateInfoKHR();
+ ~safe_VkExportFenceCreateInfoKHR();
+ void initialize(const VkExportFenceCreateInfoKHR* in_struct);
+ void initialize(const safe_VkExportFenceCreateInfoKHR* src);
+ VkExportFenceCreateInfoKHR *ptr() { return reinterpret_cast<VkExportFenceCreateInfoKHR *>(this); }
+ VkExportFenceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceCreateInfoKHR const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportFenceWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFence fence;
+ VkFenceImportFlagsKHR flags;
+ VkExternalFenceHandleTypeFlagBitsKHR handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct);
+ safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& src);
+ safe_VkImportFenceWin32HandleInfoKHR();
+ ~safe_VkImportFenceWin32HandleInfoKHR();
+ void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkImportFenceWin32HandleInfoKHR* src);
+ VkImportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>(this); }
+ VkImportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkExportFenceWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct);
+ safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& src);
+ safe_VkExportFenceWin32HandleInfoKHR();
+ ~safe_VkExportFenceWin32HandleInfoKHR();
+ void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkExportFenceWin32HandleInfoKHR* src);
+ VkExportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>(this); }
+ VkExportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkFenceGetWin32HandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFence fence;
+ VkExternalFenceHandleTypeFlagBitsKHR handleType;
+ safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct);
+ safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& src);
+ safe_VkFenceGetWin32HandleInfoKHR();
+ ~safe_VkFenceGetWin32HandleInfoKHR();
+ void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct);
+ void initialize(const safe_VkFenceGetWin32HandleInfoKHR* src);
+ VkFenceGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>(this); }
+ VkFenceGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+struct safe_VkImportFenceFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFence fence;
+ VkFenceImportFlagsKHR flags;
+ VkExternalFenceHandleTypeFlagBitsKHR handleType;
+ int fd;
+ safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct);
+ safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& src);
+ safe_VkImportFenceFdInfoKHR();
+ ~safe_VkImportFenceFdInfoKHR();
+ void initialize(const VkImportFenceFdInfoKHR* in_struct);
+ void initialize(const safe_VkImportFenceFdInfoKHR* src);
+ VkImportFenceFdInfoKHR *ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR *>(this); }
+ VkImportFenceFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const *>(this); }
+};
+
+struct safe_VkFenceGetFdInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkFence fence;
+ VkExternalFenceHandleTypeFlagBitsKHR handleType;
+ safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct);
+ safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& src);
+ safe_VkFenceGetFdInfoKHR();
+ ~safe_VkFenceGetFdInfoKHR();
+ void initialize(const VkFenceGetFdInfoKHR* in_struct);
+ void initialize(const safe_VkFenceGetFdInfoKHR* src);
+ VkFenceGetFdInfoKHR *ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR *>(this); }
+ VkFenceGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceSurfaceInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSurfaceKHR surface;
+ safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct);
+ safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src);
+ safe_VkPhysicalDeviceSurfaceInfo2KHR();
+ ~safe_VkPhysicalDeviceSurfaceInfo2KHR();
+ void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* src);
+ VkPhysicalDeviceSurfaceInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>(this); }
+ VkPhysicalDeviceSurfaceInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const *>(this); }
+};
+
+struct safe_VkSurfaceCapabilities2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+ safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct);
+ safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& src);
+ safe_VkSurfaceCapabilities2KHR();
+ ~safe_VkSurfaceCapabilities2KHR();
+ void initialize(const VkSurfaceCapabilities2KHR* in_struct);
+ void initialize(const safe_VkSurfaceCapabilities2KHR* src);
+ VkSurfaceCapabilities2KHR *ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR *>(this); }
+ VkSurfaceCapabilities2KHR const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const *>(this); }
+};
+
+struct safe_VkSurfaceFormat2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceFormatKHR surfaceFormat;
+ safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct);
+ safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& src);
+ safe_VkSurfaceFormat2KHR();
+ ~safe_VkSurfaceFormat2KHR();
+ void initialize(const VkSurfaceFormat2KHR* in_struct);
+ void initialize(const safe_VkSurfaceFormat2KHR* src);
+ VkSurfaceFormat2KHR *ptr() { return reinterpret_cast<VkSurfaceFormat2KHR *>(this); }
+ VkSurfaceFormat2KHR const *ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceVariablePointerFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 variablePointersStorageBuffer;
+ VkBool32 variablePointers;
+ safe_VkPhysicalDeviceVariablePointerFeaturesKHR(const VkPhysicalDeviceVariablePointerFeaturesKHR* in_struct);
+ safe_VkPhysicalDeviceVariablePointerFeaturesKHR(const safe_VkPhysicalDeviceVariablePointerFeaturesKHR& src);
+ safe_VkPhysicalDeviceVariablePointerFeaturesKHR();
+ ~safe_VkPhysicalDeviceVariablePointerFeaturesKHR();
+ void initialize(const VkPhysicalDeviceVariablePointerFeaturesKHR* in_struct);
+ void initialize(const safe_VkPhysicalDeviceVariablePointerFeaturesKHR* src);
+ VkPhysicalDeviceVariablePointerFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointerFeaturesKHR *>(this); }
+ VkPhysicalDeviceVariablePointerFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVariablePointerFeaturesKHR const *>(this); }
+};
+
+struct safe_VkMemoryDedicatedRequirementsKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 prefersDedicatedAllocation;
+ VkBool32 requiresDedicatedAllocation;
+ safe_VkMemoryDedicatedRequirementsKHR(const VkMemoryDedicatedRequirementsKHR* in_struct);
+ safe_VkMemoryDedicatedRequirementsKHR(const safe_VkMemoryDedicatedRequirementsKHR& src);
+ safe_VkMemoryDedicatedRequirementsKHR();
+ ~safe_VkMemoryDedicatedRequirementsKHR();
+ void initialize(const VkMemoryDedicatedRequirementsKHR* in_struct);
+ void initialize(const safe_VkMemoryDedicatedRequirementsKHR* src);
+ VkMemoryDedicatedRequirementsKHR *ptr() { return reinterpret_cast<VkMemoryDedicatedRequirementsKHR *>(this); }
+ VkMemoryDedicatedRequirementsKHR const *ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirementsKHR const *>(this); }
+};
+
+struct safe_VkMemoryDedicatedAllocateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkBuffer buffer;
+ safe_VkMemoryDedicatedAllocateInfoKHR(const VkMemoryDedicatedAllocateInfoKHR* in_struct);
+ safe_VkMemoryDedicatedAllocateInfoKHR(const safe_VkMemoryDedicatedAllocateInfoKHR& src);
+ safe_VkMemoryDedicatedAllocateInfoKHR();
+ ~safe_VkMemoryDedicatedAllocateInfoKHR();
+ void initialize(const VkMemoryDedicatedAllocateInfoKHR* in_struct);
+ void initialize(const safe_VkMemoryDedicatedAllocateInfoKHR* src);
+ VkMemoryDedicatedAllocateInfoKHR *ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfoKHR *>(this); }
+ VkMemoryDedicatedAllocateInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfoKHR const *>(this); }
+};
+
+struct safe_VkBufferMemoryRequirementsInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ safe_VkBufferMemoryRequirementsInfo2KHR(const VkBufferMemoryRequirementsInfo2KHR* in_struct);
+ safe_VkBufferMemoryRequirementsInfo2KHR(const safe_VkBufferMemoryRequirementsInfo2KHR& src);
+ safe_VkBufferMemoryRequirementsInfo2KHR();
+ ~safe_VkBufferMemoryRequirementsInfo2KHR();
+ void initialize(const VkBufferMemoryRequirementsInfo2KHR* in_struct);
+ void initialize(const safe_VkBufferMemoryRequirementsInfo2KHR* src);
+ VkBufferMemoryRequirementsInfo2KHR *ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2KHR *>(this); }
+ VkBufferMemoryRequirementsInfo2KHR const *ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2KHR const *>(this); }
+};
+
+struct safe_VkImageMemoryRequirementsInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ safe_VkImageMemoryRequirementsInfo2KHR(const VkImageMemoryRequirementsInfo2KHR* in_struct);
+ safe_VkImageMemoryRequirementsInfo2KHR(const safe_VkImageMemoryRequirementsInfo2KHR& src);
+ safe_VkImageMemoryRequirementsInfo2KHR();
+ ~safe_VkImageMemoryRequirementsInfo2KHR();
+ void initialize(const VkImageMemoryRequirementsInfo2KHR* in_struct);
+ void initialize(const safe_VkImageMemoryRequirementsInfo2KHR* src);
+ VkImageMemoryRequirementsInfo2KHR *ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2KHR *>(this); }
+ VkImageMemoryRequirementsInfo2KHR const *ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2KHR const *>(this); }
+};
+
+struct safe_VkImageSparseMemoryRequirementsInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ safe_VkImageSparseMemoryRequirementsInfo2KHR(const VkImageSparseMemoryRequirementsInfo2KHR* in_struct);
+ safe_VkImageSparseMemoryRequirementsInfo2KHR(const safe_VkImageSparseMemoryRequirementsInfo2KHR& src);
+ safe_VkImageSparseMemoryRequirementsInfo2KHR();
+ ~safe_VkImageSparseMemoryRequirementsInfo2KHR();
+ void initialize(const VkImageSparseMemoryRequirementsInfo2KHR* in_struct);
+ void initialize(const safe_VkImageSparseMemoryRequirementsInfo2KHR* src);
+ VkImageSparseMemoryRequirementsInfo2KHR *ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2KHR *>(this); }
+ VkImageSparseMemoryRequirementsInfo2KHR const *ptr() const { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2KHR const *>(this); }
+};
+
+struct safe_VkMemoryRequirements2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkMemoryRequirements memoryRequirements;
+ safe_VkMemoryRequirements2KHR(const VkMemoryRequirements2KHR* in_struct);
+ safe_VkMemoryRequirements2KHR(const safe_VkMemoryRequirements2KHR& src);
+ safe_VkMemoryRequirements2KHR();
+ ~safe_VkMemoryRequirements2KHR();
+ void initialize(const VkMemoryRequirements2KHR* in_struct);
+ void initialize(const safe_VkMemoryRequirements2KHR* src);
+ VkMemoryRequirements2KHR *ptr() { return reinterpret_cast<VkMemoryRequirements2KHR *>(this); }
+ VkMemoryRequirements2KHR const *ptr() const { return reinterpret_cast<VkMemoryRequirements2KHR const *>(this); }
+};
+
+struct safe_VkSparseImageMemoryRequirements2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSparseImageMemoryRequirements memoryRequirements;
+ safe_VkSparseImageMemoryRequirements2KHR(const VkSparseImageMemoryRequirements2KHR* in_struct);
+ safe_VkSparseImageMemoryRequirements2KHR(const safe_VkSparseImageMemoryRequirements2KHR& src);
+ safe_VkSparseImageMemoryRequirements2KHR();
+ ~safe_VkSparseImageMemoryRequirements2KHR();
+ void initialize(const VkSparseImageMemoryRequirements2KHR* in_struct);
+ void initialize(const safe_VkSparseImageMemoryRequirements2KHR* src);
+ VkSparseImageMemoryRequirements2KHR *ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2KHR *>(this); }
+ VkSparseImageMemoryRequirements2KHR const *ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2KHR const *>(this); }
+};
+
+struct safe_VkImportMemoryFuchsiaHandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ uint32_t handle;
+ safe_VkImportMemoryFuchsiaHandleInfoKHR(const VkImportMemoryFuchsiaHandleInfoKHR* in_struct);
+ safe_VkImportMemoryFuchsiaHandleInfoKHR(const safe_VkImportMemoryFuchsiaHandleInfoKHR& src);
+ safe_VkImportMemoryFuchsiaHandleInfoKHR();
+ ~safe_VkImportMemoryFuchsiaHandleInfoKHR();
+ void initialize(const VkImportMemoryFuchsiaHandleInfoKHR* in_struct);
+ void initialize(const safe_VkImportMemoryFuchsiaHandleInfoKHR* src);
+ VkImportMemoryFuchsiaHandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFuchsiaHandleInfoKHR *>(this); }
+ VkImportMemoryFuchsiaHandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFuchsiaHandleInfoKHR const *>(this); }
+};
+
+struct safe_VkMemoryFuchsiaHandlePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t memoryTypeBits;
+ safe_VkMemoryFuchsiaHandlePropertiesKHR(const VkMemoryFuchsiaHandlePropertiesKHR* in_struct);
+ safe_VkMemoryFuchsiaHandlePropertiesKHR(const safe_VkMemoryFuchsiaHandlePropertiesKHR& src);
+ safe_VkMemoryFuchsiaHandlePropertiesKHR();
+ ~safe_VkMemoryFuchsiaHandlePropertiesKHR();
+ void initialize(const VkMemoryFuchsiaHandlePropertiesKHR* in_struct);
+ void initialize(const safe_VkMemoryFuchsiaHandlePropertiesKHR* src);
+ VkMemoryFuchsiaHandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFuchsiaHandlePropertiesKHR *>(this); }
+ VkMemoryFuchsiaHandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFuchsiaHandlePropertiesKHR const *>(this); }
+};
+
+struct safe_VkMemoryGetFuchsiaHandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType;
+ safe_VkMemoryGetFuchsiaHandleInfoKHR(const VkMemoryGetFuchsiaHandleInfoKHR* in_struct);
+ safe_VkMemoryGetFuchsiaHandleInfoKHR(const safe_VkMemoryGetFuchsiaHandleInfoKHR& src);
+ safe_VkMemoryGetFuchsiaHandleInfoKHR();
+ ~safe_VkMemoryGetFuchsiaHandleInfoKHR();
+ void initialize(const VkMemoryGetFuchsiaHandleInfoKHR* in_struct);
+ void initialize(const safe_VkMemoryGetFuchsiaHandleInfoKHR* src);
+ VkMemoryGetFuchsiaHandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFuchsiaHandleInfoKHR *>(this); }
+ VkMemoryGetFuchsiaHandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFuchsiaHandleInfoKHR const *>(this); }
+};
+
+struct safe_VkImportSemaphoreFuchsiaHandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkSemaphoreImportFlagsKHR flags;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ uint32_t handle;
+ safe_VkImportSemaphoreFuchsiaHandleInfoKHR(const VkImportSemaphoreFuchsiaHandleInfoKHR* in_struct);
+ safe_VkImportSemaphoreFuchsiaHandleInfoKHR(const safe_VkImportSemaphoreFuchsiaHandleInfoKHR& src);
+ safe_VkImportSemaphoreFuchsiaHandleInfoKHR();
+ ~safe_VkImportSemaphoreFuchsiaHandleInfoKHR();
+ void initialize(const VkImportSemaphoreFuchsiaHandleInfoKHR* in_struct);
+ void initialize(const safe_VkImportSemaphoreFuchsiaHandleInfoKHR* src);
+ VkImportSemaphoreFuchsiaHandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFuchsiaHandleInfoKHR *>(this); }
+ VkImportSemaphoreFuchsiaHandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFuchsiaHandleInfoKHR const *>(this); }
+};
+
+struct safe_VkSemaphoreGetFuchsiaHandleInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBitsKHR handleType;
+ safe_VkSemaphoreGetFuchsiaHandleInfoKHR(const VkSemaphoreGetFuchsiaHandleInfoKHR* in_struct);
+ safe_VkSemaphoreGetFuchsiaHandleInfoKHR(const safe_VkSemaphoreGetFuchsiaHandleInfoKHR& src);
+ safe_VkSemaphoreGetFuchsiaHandleInfoKHR();
+ ~safe_VkSemaphoreGetFuchsiaHandleInfoKHR();
+ void initialize(const VkSemaphoreGetFuchsiaHandleInfoKHR* in_struct);
+ void initialize(const safe_VkSemaphoreGetFuchsiaHandleInfoKHR* src);
+ VkSemaphoreGetFuchsiaHandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFuchsiaHandleInfoKHR *>(this); }
+ VkSemaphoreGetFuchsiaHandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFuchsiaHandleInfoKHR const *>(this); }
+};
+
+struct safe_VkDebugReportCallbackCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDebugReportFlagsEXT flags;
+ PFN_vkDebugReportCallbackEXT pfnCallback;
+ void* pUserData;
+ safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct);
+ safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src);
+ safe_VkDebugReportCallbackCreateInfoEXT();
+ ~safe_VkDebugReportCallbackCreateInfoEXT();
+ void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct);
+ void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src);
+ VkDebugReportCallbackCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>(this); }
+ VkDebugReportCallbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkPipelineRasterizationStateRasterizationOrderAMD {
+ VkStructureType sType;
+ const void* pNext;
+ VkRasterizationOrderAMD rasterizationOrder;
+ safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct);
+ safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src);
+ safe_VkPipelineRasterizationStateRasterizationOrderAMD();
+ ~safe_VkPipelineRasterizationStateRasterizationOrderAMD();
+ void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct);
+ void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src);
+ VkPipelineRasterizationStateRasterizationOrderAMD *ptr() { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>(this); }
+ VkPipelineRasterizationStateRasterizationOrderAMD const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const *>(this); }
+};
+
+struct safe_VkDebugMarkerObjectNameInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ const char* pObjectName;
+ safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct);
+ safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src);
+ safe_VkDebugMarkerObjectNameInfoEXT();
+ ~safe_VkDebugMarkerObjectNameInfoEXT();
+ void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct);
+ void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src);
+ VkDebugMarkerObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(this); }
+ VkDebugMarkerObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>(this); }
+};
+
+struct safe_VkDebugMarkerObjectTagInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+ safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct);
+ safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src);
+ safe_VkDebugMarkerObjectTagInfoEXT();
+ ~safe_VkDebugMarkerObjectTagInfoEXT();
+ void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct);
+ void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src);
+ VkDebugMarkerObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>(this); }
+ VkDebugMarkerObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>(this); }
+};
+
+struct safe_VkDebugMarkerMarkerInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ const char* pMarkerName;
+ float color[4];
+ safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct);
+ safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src);
+ safe_VkDebugMarkerMarkerInfoEXT();
+ ~safe_VkDebugMarkerMarkerInfoEXT();
+ void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct);
+ void initialize(const safe_VkDebugMarkerMarkerInfoEXT* src);
+ VkDebugMarkerMarkerInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>(this); }
+ VkDebugMarkerMarkerInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>(this); }
+};
+
+struct safe_VkDedicatedAllocationImageCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 dedicatedAllocation;
+ safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct);
+ safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src);
+ safe_VkDedicatedAllocationImageCreateInfoNV();
+ ~safe_VkDedicatedAllocationImageCreateInfoNV();
+ void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct);
+ void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src);
+ VkDedicatedAllocationImageCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>(this); }
+ VkDedicatedAllocationImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>(this); }
+};
+
+struct safe_VkDedicatedAllocationBufferCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 dedicatedAllocation;
+ safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct);
+ safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src);
+ safe_VkDedicatedAllocationBufferCreateInfoNV();
+ ~safe_VkDedicatedAllocationBufferCreateInfoNV();
+ void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct);
+ void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src);
+ VkDedicatedAllocationBufferCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>(this); }
+ VkDedicatedAllocationBufferCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>(this); }
+};
+
+struct safe_VkDedicatedAllocationMemoryAllocateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkBuffer buffer;
+ safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct);
+ safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src);
+ safe_VkDedicatedAllocationMemoryAllocateInfoNV();
+ ~safe_VkDedicatedAllocationMemoryAllocateInfoNV();
+ void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct);
+ void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src);
+ VkDedicatedAllocationMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>(this); }
+ VkDedicatedAllocationMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>(this); }
+};
+
+struct safe_VkTextureLODGatherFormatPropertiesAMD {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 supportsTextureGatherLODBiasAMD;
+ safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct);
+ safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& src);
+ safe_VkTextureLODGatherFormatPropertiesAMD();
+ ~safe_VkTextureLODGatherFormatPropertiesAMD();
+ void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct);
+ void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* src);
+ VkTextureLODGatherFormatPropertiesAMD *ptr() { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>(this); }
+ VkTextureLODGatherFormatPropertiesAMD const *ptr() const { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD const *>(this); }
+};
+
+struct safe_VkRenderPassMultiviewCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t subpassCount;
+ const uint32_t* pViewMasks;
+ uint32_t dependencyCount;
+ const int32_t* pViewOffsets;
+ uint32_t correlationMaskCount;
+ const uint32_t* pCorrelationMasks;
+ safe_VkRenderPassMultiviewCreateInfoKHX(const VkRenderPassMultiviewCreateInfoKHX* in_struct);
+ safe_VkRenderPassMultiviewCreateInfoKHX(const safe_VkRenderPassMultiviewCreateInfoKHX& src);
+ safe_VkRenderPassMultiviewCreateInfoKHX();
+ ~safe_VkRenderPassMultiviewCreateInfoKHX();
+ void initialize(const VkRenderPassMultiviewCreateInfoKHX* in_struct);
+ void initialize(const safe_VkRenderPassMultiviewCreateInfoKHX* src);
+ VkRenderPassMultiviewCreateInfoKHX *ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfoKHX *>(this); }
+ VkRenderPassMultiviewCreateInfoKHX const *ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfoKHX const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceMultiviewFeaturesKHX {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 multiview;
+ VkBool32 multiviewGeometryShader;
+ VkBool32 multiviewTessellationShader;
+ safe_VkPhysicalDeviceMultiviewFeaturesKHX(const VkPhysicalDeviceMultiviewFeaturesKHX* in_struct);
+ safe_VkPhysicalDeviceMultiviewFeaturesKHX(const safe_VkPhysicalDeviceMultiviewFeaturesKHX& src);
+ safe_VkPhysicalDeviceMultiviewFeaturesKHX();
+ ~safe_VkPhysicalDeviceMultiviewFeaturesKHX();
+ void initialize(const VkPhysicalDeviceMultiviewFeaturesKHX* in_struct);
+ void initialize(const safe_VkPhysicalDeviceMultiviewFeaturesKHX* src);
+ VkPhysicalDeviceMultiviewFeaturesKHX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeaturesKHX *>(this); }
+ VkPhysicalDeviceMultiviewFeaturesKHX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewFeaturesKHX const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceMultiviewPropertiesKHX {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t maxMultiviewViewCount;
+ uint32_t maxMultiviewInstanceIndex;
+ safe_VkPhysicalDeviceMultiviewPropertiesKHX(const VkPhysicalDeviceMultiviewPropertiesKHX* in_struct);
+ safe_VkPhysicalDeviceMultiviewPropertiesKHX(const safe_VkPhysicalDeviceMultiviewPropertiesKHX& src);
+ safe_VkPhysicalDeviceMultiviewPropertiesKHX();
+ ~safe_VkPhysicalDeviceMultiviewPropertiesKHX();
+ void initialize(const VkPhysicalDeviceMultiviewPropertiesKHX* in_struct);
+ void initialize(const safe_VkPhysicalDeviceMultiviewPropertiesKHX* src);
+ VkPhysicalDeviceMultiviewPropertiesKHX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewPropertiesKHX *>(this); }
+ VkPhysicalDeviceMultiviewPropertiesKHX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewPropertiesKHX const *>(this); }
+};
+
+struct safe_VkExternalMemoryImageCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsNV handleTypes;
+ safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct);
+ safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src);
+ safe_VkExternalMemoryImageCreateInfoNV();
+ ~safe_VkExternalMemoryImageCreateInfoNV();
+ void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct);
+ void initialize(const safe_VkExternalMemoryImageCreateInfoNV* src);
+ VkExternalMemoryImageCreateInfoNV *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>(this); }
+ VkExternalMemoryImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const *>(this); }
+};
+
+struct safe_VkExportMemoryAllocateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsNV handleTypes;
+ safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct);
+ safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src);
+ safe_VkExportMemoryAllocateInfoNV();
+ ~safe_VkExportMemoryAllocateInfoNV();
+ void initialize(const VkExportMemoryAllocateInfoNV* in_struct);
+ void initialize(const safe_VkExportMemoryAllocateInfoNV* src);
+ VkExportMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoNV *>(this); }
+ VkExportMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoNV const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportMemoryWin32HandleInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsNV handleType;
+ HANDLE handle;
+ safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct);
+ safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src);
+ safe_VkImportMemoryWin32HandleInfoNV();
+ ~safe_VkImportMemoryWin32HandleInfoNV();
+ void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct);
+ void initialize(const safe_VkImportMemoryWin32HandleInfoNV* src);
+ VkImportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>(this); }
+ VkImportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkExportMemoryWin32HandleInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct);
+ safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src);
+ safe_VkExportMemoryWin32HandleInfoNV();
+ ~safe_VkExportMemoryWin32HandleInfoNV();
+ void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct);
+ void initialize(const safe_VkExportMemoryWin32HandleInfoNV* src);
+ VkExportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>(this); }
+ VkExportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t acquireCount;
+ VkDeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeoutMilliseconds;
+ uint32_t releaseCount;
+ VkDeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
+ safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct);
+ safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src);
+ safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
+ ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
+ void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct);
+ void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src);
+ VkWin32KeyedMutexAcquireReleaseInfoNV *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>(this); }
+ VkWin32KeyedMutexAcquireReleaseInfoNV const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV const *>(this); }
+};
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+struct safe_VkMemoryAllocateFlagsInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryAllocateFlagsKHX flags;
+ uint32_t deviceMask;
+ safe_VkMemoryAllocateFlagsInfoKHX(const VkMemoryAllocateFlagsInfoKHX* in_struct);
+ safe_VkMemoryAllocateFlagsInfoKHX(const safe_VkMemoryAllocateFlagsInfoKHX& src);
+ safe_VkMemoryAllocateFlagsInfoKHX();
+ ~safe_VkMemoryAllocateFlagsInfoKHX();
+ void initialize(const VkMemoryAllocateFlagsInfoKHX* in_struct);
+ void initialize(const safe_VkMemoryAllocateFlagsInfoKHX* src);
+ VkMemoryAllocateFlagsInfoKHX *ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfoKHX *>(this); }
+ VkMemoryAllocateFlagsInfoKHX const *ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfoKHX const *>(this); }
+};
+
+struct safe_VkBindBufferMemoryInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkDeviceMemory memory;
+ VkDeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ safe_VkBindBufferMemoryInfoKHX(const VkBindBufferMemoryInfoKHX* in_struct);
+ safe_VkBindBufferMemoryInfoKHX(const safe_VkBindBufferMemoryInfoKHX& src);
+ safe_VkBindBufferMemoryInfoKHX();
+ ~safe_VkBindBufferMemoryInfoKHX();
+ void initialize(const VkBindBufferMemoryInfoKHX* in_struct);
+ void initialize(const safe_VkBindBufferMemoryInfoKHX* src);
+ VkBindBufferMemoryInfoKHX *ptr() { return reinterpret_cast<VkBindBufferMemoryInfoKHX *>(this); }
+ VkBindBufferMemoryInfoKHX const *ptr() const { return reinterpret_cast<VkBindBufferMemoryInfoKHX const *>(this); }
+};
+
+struct safe_VkBindImageMemoryInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkDeviceMemory memory;
+ VkDeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ uint32_t SFRRectCount;
+ const VkRect2D* pSFRRects;
+ safe_VkBindImageMemoryInfoKHX(const VkBindImageMemoryInfoKHX* in_struct);
+ safe_VkBindImageMemoryInfoKHX(const safe_VkBindImageMemoryInfoKHX& src);
+ safe_VkBindImageMemoryInfoKHX();
+ ~safe_VkBindImageMemoryInfoKHX();
+ void initialize(const VkBindImageMemoryInfoKHX* in_struct);
+ void initialize(const safe_VkBindImageMemoryInfoKHX* src);
+ VkBindImageMemoryInfoKHX *ptr() { return reinterpret_cast<VkBindImageMemoryInfoKHX *>(this); }
+ VkBindImageMemoryInfoKHX const *ptr() const { return reinterpret_cast<VkBindImageMemoryInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupRenderPassBeginInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t deviceMask;
+ uint32_t deviceRenderAreaCount;
+ const VkRect2D* pDeviceRenderAreas;
+ safe_VkDeviceGroupRenderPassBeginInfoKHX(const VkDeviceGroupRenderPassBeginInfoKHX* in_struct);
+ safe_VkDeviceGroupRenderPassBeginInfoKHX(const safe_VkDeviceGroupRenderPassBeginInfoKHX& src);
+ safe_VkDeviceGroupRenderPassBeginInfoKHX();
+ ~safe_VkDeviceGroupRenderPassBeginInfoKHX();
+ void initialize(const VkDeviceGroupRenderPassBeginInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupRenderPassBeginInfoKHX* src);
+ VkDeviceGroupRenderPassBeginInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfoKHX *>(this); }
+ VkDeviceGroupRenderPassBeginInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupCommandBufferBeginInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t deviceMask;
+ safe_VkDeviceGroupCommandBufferBeginInfoKHX(const VkDeviceGroupCommandBufferBeginInfoKHX* in_struct);
+ safe_VkDeviceGroupCommandBufferBeginInfoKHX(const safe_VkDeviceGroupCommandBufferBeginInfoKHX& src);
+ safe_VkDeviceGroupCommandBufferBeginInfoKHX();
+ ~safe_VkDeviceGroupCommandBufferBeginInfoKHX();
+ void initialize(const VkDeviceGroupCommandBufferBeginInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupCommandBufferBeginInfoKHX* src);
+ VkDeviceGroupCommandBufferBeginInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfoKHX *>(this); }
+ VkDeviceGroupCommandBufferBeginInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupSubmitInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ const uint32_t* pWaitSemaphoreDeviceIndices;
+ uint32_t commandBufferCount;
+ const uint32_t* pCommandBufferDeviceMasks;
+ uint32_t signalSemaphoreCount;
+ const uint32_t* pSignalSemaphoreDeviceIndices;
+ safe_VkDeviceGroupSubmitInfoKHX(const VkDeviceGroupSubmitInfoKHX* in_struct);
+ safe_VkDeviceGroupSubmitInfoKHX(const safe_VkDeviceGroupSubmitInfoKHX& src);
+ safe_VkDeviceGroupSubmitInfoKHX();
+ ~safe_VkDeviceGroupSubmitInfoKHX();
+ void initialize(const VkDeviceGroupSubmitInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupSubmitInfoKHX* src);
+ VkDeviceGroupSubmitInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfoKHX *>(this); }
+ VkDeviceGroupSubmitInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupBindSparseInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t resourceDeviceIndex;
+ uint32_t memoryDeviceIndex;
+ safe_VkDeviceGroupBindSparseInfoKHX(const VkDeviceGroupBindSparseInfoKHX* in_struct);
+ safe_VkDeviceGroupBindSparseInfoKHX(const safe_VkDeviceGroupBindSparseInfoKHX& src);
+ safe_VkDeviceGroupBindSparseInfoKHX();
+ ~safe_VkDeviceGroupBindSparseInfoKHX();
+ void initialize(const VkDeviceGroupBindSparseInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupBindSparseInfoKHX* src);
+ VkDeviceGroupBindSparseInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfoKHX *>(this); }
+ VkDeviceGroupBindSparseInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupPresentCapabilitiesKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
+ VkDeviceGroupPresentModeFlagsKHX modes;
+ safe_VkDeviceGroupPresentCapabilitiesKHX(const VkDeviceGroupPresentCapabilitiesKHX* in_struct);
+ safe_VkDeviceGroupPresentCapabilitiesKHX(const safe_VkDeviceGroupPresentCapabilitiesKHX& src);
+ safe_VkDeviceGroupPresentCapabilitiesKHX();
+ ~safe_VkDeviceGroupPresentCapabilitiesKHX();
+ void initialize(const VkDeviceGroupPresentCapabilitiesKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHX* src);
+ VkDeviceGroupPresentCapabilitiesKHX *ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX *>(this); }
+ VkDeviceGroupPresentCapabilitiesKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX const *>(this); }
+};
+
+struct safe_VkImageSwapchainCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkSwapchainKHR swapchain;
+ safe_VkImageSwapchainCreateInfoKHX(const VkImageSwapchainCreateInfoKHX* in_struct);
+ safe_VkImageSwapchainCreateInfoKHX(const safe_VkImageSwapchainCreateInfoKHX& src);
+ safe_VkImageSwapchainCreateInfoKHX();
+ ~safe_VkImageSwapchainCreateInfoKHX();
+ void initialize(const VkImageSwapchainCreateInfoKHX* in_struct);
+ void initialize(const safe_VkImageSwapchainCreateInfoKHX* src);
+ VkImageSwapchainCreateInfoKHX *ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHX *>(this); }
+ VkImageSwapchainCreateInfoKHX const *ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHX const *>(this); }
+};
+
+struct safe_VkBindImageMemorySwapchainInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkSwapchainKHR swapchain;
+ uint32_t imageIndex;
+ safe_VkBindImageMemorySwapchainInfoKHX(const VkBindImageMemorySwapchainInfoKHX* in_struct);
+ safe_VkBindImageMemorySwapchainInfoKHX(const safe_VkBindImageMemorySwapchainInfoKHX& src);
+ safe_VkBindImageMemorySwapchainInfoKHX();
+ ~safe_VkBindImageMemorySwapchainInfoKHX();
+ void initialize(const VkBindImageMemorySwapchainInfoKHX* in_struct);
+ void initialize(const safe_VkBindImageMemorySwapchainInfoKHX* src);
+ VkBindImageMemorySwapchainInfoKHX *ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHX *>(this); }
+ VkBindImageMemorySwapchainInfoKHX const *ptr() const { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHX const *>(this); }
+};
+
+struct safe_VkAcquireNextImageInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkSwapchainKHR swapchain;
+ uint64_t timeout;
+ VkSemaphore semaphore;
+ VkFence fence;
+ uint32_t deviceMask;
+ safe_VkAcquireNextImageInfoKHX(const VkAcquireNextImageInfoKHX* in_struct);
+ safe_VkAcquireNextImageInfoKHX(const safe_VkAcquireNextImageInfoKHX& src);
+ safe_VkAcquireNextImageInfoKHX();
+ ~safe_VkAcquireNextImageInfoKHX();
+ void initialize(const VkAcquireNextImageInfoKHX* in_struct);
+ void initialize(const safe_VkAcquireNextImageInfoKHX* src);
+ VkAcquireNextImageInfoKHX *ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHX *>(this); }
+ VkAcquireNextImageInfoKHX const *ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupPresentInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t swapchainCount;
+ const uint32_t* pDeviceMasks;
+ VkDeviceGroupPresentModeFlagBitsKHX mode;
+ safe_VkDeviceGroupPresentInfoKHX(const VkDeviceGroupPresentInfoKHX* in_struct);
+ safe_VkDeviceGroupPresentInfoKHX(const safe_VkDeviceGroupPresentInfoKHX& src);
+ safe_VkDeviceGroupPresentInfoKHX();
+ ~safe_VkDeviceGroupPresentInfoKHX();
+ void initialize(const VkDeviceGroupPresentInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupPresentInfoKHX* src);
+ VkDeviceGroupPresentInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHX *>(this); }
+ VkDeviceGroupPresentInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupSwapchainCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceGroupPresentModeFlagsKHX modes;
+ safe_VkDeviceGroupSwapchainCreateInfoKHX(const VkDeviceGroupSwapchainCreateInfoKHX* in_struct);
+ safe_VkDeviceGroupSwapchainCreateInfoKHX(const safe_VkDeviceGroupSwapchainCreateInfoKHX& src);
+ safe_VkDeviceGroupSwapchainCreateInfoKHX();
+ ~safe_VkDeviceGroupSwapchainCreateInfoKHX();
+ void initialize(const VkDeviceGroupSwapchainCreateInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHX* src);
+ VkDeviceGroupSwapchainCreateInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHX *>(this); }
+ VkDeviceGroupSwapchainCreateInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHX const *>(this); }
+};
+
+struct safe_VkValidationFlagsEXT {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t disabledValidationCheckCount;
+ VkValidationCheckEXT* pDisabledValidationChecks;
+ safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct);
+ safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src);
+ safe_VkValidationFlagsEXT();
+ ~safe_VkValidationFlagsEXT();
+ void initialize(const VkValidationFlagsEXT* in_struct);
+ void initialize(const safe_VkValidationFlagsEXT* src);
+ VkValidationFlagsEXT *ptr() { return reinterpret_cast<VkValidationFlagsEXT *>(this); }
+ VkValidationFlagsEXT const *ptr() const { return reinterpret_cast<VkValidationFlagsEXT const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_VI_NN
+struct safe_VkViSurfaceCreateInfoNN {
+ VkStructureType sType;
+ const void* pNext;
+ VkViSurfaceCreateFlagsNN flags;
+ void* window;
+ safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct);
+ safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& src);
+ safe_VkViSurfaceCreateInfoNN();
+ ~safe_VkViSurfaceCreateInfoNN();
+ void initialize(const VkViSurfaceCreateInfoNN* in_struct);
+ void initialize(const safe_VkViSurfaceCreateInfoNN* src);
+ VkViSurfaceCreateInfoNN *ptr() { return reinterpret_cast<VkViSurfaceCreateInfoNN *>(this); }
+ VkViSurfaceCreateInfoNN const *ptr() const { return reinterpret_cast<VkViSurfaceCreateInfoNN const *>(this); }
+};
+#endif // VK_USE_PLATFORM_VI_NN
+
+struct safe_VkPhysicalDeviceGroupPropertiesKHX {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t physicalDeviceCount;
+ VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
+ VkBool32 subsetAllocation;
+ safe_VkPhysicalDeviceGroupPropertiesKHX(const VkPhysicalDeviceGroupPropertiesKHX* in_struct);
+ safe_VkPhysicalDeviceGroupPropertiesKHX(const safe_VkPhysicalDeviceGroupPropertiesKHX& src);
+ safe_VkPhysicalDeviceGroupPropertiesKHX();
+ ~safe_VkPhysicalDeviceGroupPropertiesKHX();
+ void initialize(const VkPhysicalDeviceGroupPropertiesKHX* in_struct);
+ void initialize(const safe_VkPhysicalDeviceGroupPropertiesKHX* src);
+ VkPhysicalDeviceGroupPropertiesKHX *ptr() { return reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX *>(this); }
+ VkPhysicalDeviceGroupPropertiesKHX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX const *>(this); }
+};
+
+struct safe_VkDeviceGroupDeviceCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t physicalDeviceCount;
+ VkPhysicalDevice* pPhysicalDevices;
+ safe_VkDeviceGroupDeviceCreateInfoKHX(const VkDeviceGroupDeviceCreateInfoKHX* in_struct);
+ safe_VkDeviceGroupDeviceCreateInfoKHX(const safe_VkDeviceGroupDeviceCreateInfoKHX& src);
+ safe_VkDeviceGroupDeviceCreateInfoKHX();
+ ~safe_VkDeviceGroupDeviceCreateInfoKHX();
+ void initialize(const VkDeviceGroupDeviceCreateInfoKHX* in_struct);
+ void initialize(const safe_VkDeviceGroupDeviceCreateInfoKHX* src);
+ VkDeviceGroupDeviceCreateInfoKHX *ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfoKHX *>(this); }
+ VkDeviceGroupDeviceCreateInfoKHX const *ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfoKHX const *>(this); }
+};
+
+struct safe_VkDeviceGeneratedCommandsFeaturesNVX {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 computeBindingPointSupport;
+ safe_VkDeviceGeneratedCommandsFeaturesNVX(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct);
+ safe_VkDeviceGeneratedCommandsFeaturesNVX(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src);
+ safe_VkDeviceGeneratedCommandsFeaturesNVX();
+ ~safe_VkDeviceGeneratedCommandsFeaturesNVX();
+ void initialize(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct);
+ void initialize(const safe_VkDeviceGeneratedCommandsFeaturesNVX* src);
+ VkDeviceGeneratedCommandsFeaturesNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX *>(this); }
+ VkDeviceGeneratedCommandsFeaturesNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX const *>(this); }
+};
+
+struct safe_VkDeviceGeneratedCommandsLimitsNVX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t maxIndirectCommandsLayoutTokenCount;
+ uint32_t maxObjectEntryCounts;
+ uint32_t minSequenceCountBufferOffsetAlignment;
+ uint32_t minSequenceIndexBufferOffsetAlignment;
+ uint32_t minCommandsTokenBufferOffsetAlignment;
+ safe_VkDeviceGeneratedCommandsLimitsNVX(const VkDeviceGeneratedCommandsLimitsNVX* in_struct);
+ safe_VkDeviceGeneratedCommandsLimitsNVX(const safe_VkDeviceGeneratedCommandsLimitsNVX& src);
+ safe_VkDeviceGeneratedCommandsLimitsNVX();
+ ~safe_VkDeviceGeneratedCommandsLimitsNVX();
+ void initialize(const VkDeviceGeneratedCommandsLimitsNVX* in_struct);
+ void initialize(const safe_VkDeviceGeneratedCommandsLimitsNVX* src);
+ VkDeviceGeneratedCommandsLimitsNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX *>(this); }
+ VkDeviceGeneratedCommandsLimitsNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX const *>(this); }
+};
+
+struct safe_VkIndirectCommandsLayoutCreateInfoNVX {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineBindPoint pipelineBindPoint;
+ VkIndirectCommandsLayoutUsageFlagsNVX flags;
+ uint32_t tokenCount;
+ const VkIndirectCommandsLayoutTokenNVX* pTokens;
+ safe_VkIndirectCommandsLayoutCreateInfoNVX(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct);
+ safe_VkIndirectCommandsLayoutCreateInfoNVX(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src);
+ safe_VkIndirectCommandsLayoutCreateInfoNVX();
+ ~safe_VkIndirectCommandsLayoutCreateInfoNVX();
+ void initialize(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct);
+ void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNVX* src);
+ VkIndirectCommandsLayoutCreateInfoNVX *ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX *>(this); }
+ VkIndirectCommandsLayoutCreateInfoNVX const *ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX const *>(this); }
+};
+
+struct safe_VkCmdProcessCommandsInfoNVX {
+ VkStructureType sType;
+ const void* pNext;
+ VkObjectTableNVX objectTable;
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout;
+ uint32_t indirectCommandsTokenCount;
+ VkIndirectCommandsTokenNVX* pIndirectCommandsTokens;
+ uint32_t maxSequencesCount;
+ VkCommandBuffer targetCommandBuffer;
+ VkBuffer sequencesCountBuffer;
+ VkDeviceSize sequencesCountOffset;
+ VkBuffer sequencesIndexBuffer;
+ VkDeviceSize sequencesIndexOffset;
+ safe_VkCmdProcessCommandsInfoNVX(const VkCmdProcessCommandsInfoNVX* in_struct);
+ safe_VkCmdProcessCommandsInfoNVX(const safe_VkCmdProcessCommandsInfoNVX& src);
+ safe_VkCmdProcessCommandsInfoNVX();
+ ~safe_VkCmdProcessCommandsInfoNVX();
+ void initialize(const VkCmdProcessCommandsInfoNVX* in_struct);
+ void initialize(const safe_VkCmdProcessCommandsInfoNVX* src);
+ VkCmdProcessCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdProcessCommandsInfoNVX *>(this); }
+ VkCmdProcessCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdProcessCommandsInfoNVX const *>(this); }
+};
+
+struct safe_VkCmdReserveSpaceForCommandsInfoNVX {
+ VkStructureType sType;
+ const void* pNext;
+ VkObjectTableNVX objectTable;
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout;
+ uint32_t maxSequencesCount;
+ safe_VkCmdReserveSpaceForCommandsInfoNVX(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct);
+ safe_VkCmdReserveSpaceForCommandsInfoNVX(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src);
+ safe_VkCmdReserveSpaceForCommandsInfoNVX();
+ ~safe_VkCmdReserveSpaceForCommandsInfoNVX();
+ void initialize(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct);
+ void initialize(const safe_VkCmdReserveSpaceForCommandsInfoNVX* src);
+ VkCmdReserveSpaceForCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX *>(this); }
+ VkCmdReserveSpaceForCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX const *>(this); }
+};
+
+struct safe_VkObjectTableCreateInfoNVX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t objectCount;
+ const VkObjectEntryTypeNVX* pObjectEntryTypes;
+ const uint32_t* pObjectEntryCounts;
+ const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+ uint32_t maxUniformBuffersPerDescriptor;
+ uint32_t maxStorageBuffersPerDescriptor;
+ uint32_t maxStorageImagesPerDescriptor;
+ uint32_t maxSampledImagesPerDescriptor;
+ uint32_t maxPipelineLayouts;
+ safe_VkObjectTableCreateInfoNVX(const VkObjectTableCreateInfoNVX* in_struct);
+ safe_VkObjectTableCreateInfoNVX(const safe_VkObjectTableCreateInfoNVX& src);
+ safe_VkObjectTableCreateInfoNVX();
+ ~safe_VkObjectTableCreateInfoNVX();
+ void initialize(const VkObjectTableCreateInfoNVX* in_struct);
+ void initialize(const safe_VkObjectTableCreateInfoNVX* src);
+ VkObjectTableCreateInfoNVX *ptr() { return reinterpret_cast<VkObjectTableCreateInfoNVX *>(this); }
+ VkObjectTableCreateInfoNVX const *ptr() const { return reinterpret_cast<VkObjectTableCreateInfoNVX const *>(this); }
+};
+
+struct safe_VkPipelineViewportWScalingStateCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 viewportWScalingEnable;
+ uint32_t viewportCount;
+ const VkViewportWScalingNV* pViewportWScalings;
+ safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct);
+ safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src);
+ safe_VkPipelineViewportWScalingStateCreateInfoNV();
+ ~safe_VkPipelineViewportWScalingStateCreateInfoNV();
+ void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct);
+ void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* src);
+ VkPipelineViewportWScalingStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>(this); }
+ VkPipelineViewportWScalingStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const *>(this); }
+};
+
+struct safe_VkSurfaceCapabilities2EXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ VkExtent2D currentExtent;
+ VkExtent2D minImageExtent;
+ VkExtent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkSurfaceTransformFlagBitsKHR currentTransform;
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+ VkImageUsageFlags supportedUsageFlags;
+ VkSurfaceCounterFlagsEXT supportedSurfaceCounters;
+ safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct);
+ safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& src);
+ safe_VkSurfaceCapabilities2EXT();
+ ~safe_VkSurfaceCapabilities2EXT();
+ void initialize(const VkSurfaceCapabilities2EXT* in_struct);
+ void initialize(const safe_VkSurfaceCapabilities2EXT* src);
+ VkSurfaceCapabilities2EXT *ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT *>(this); }
+ VkSurfaceCapabilities2EXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const *>(this); }
+};
+
+struct safe_VkDisplayPowerInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayPowerStateEXT powerState;
+ safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct);
+ safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& src);
+ safe_VkDisplayPowerInfoEXT();
+ ~safe_VkDisplayPowerInfoEXT();
+ void initialize(const VkDisplayPowerInfoEXT* in_struct);
+ void initialize(const safe_VkDisplayPowerInfoEXT* src);
+ VkDisplayPowerInfoEXT *ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT *>(this); }
+ VkDisplayPowerInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const *>(this); }
+};
+
+struct safe_VkDeviceEventInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceEventTypeEXT deviceEvent;
+ safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct);
+ safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& src);
+ safe_VkDeviceEventInfoEXT();
+ ~safe_VkDeviceEventInfoEXT();
+ void initialize(const VkDeviceEventInfoEXT* in_struct);
+ void initialize(const safe_VkDeviceEventInfoEXT* src);
+ VkDeviceEventInfoEXT *ptr() { return reinterpret_cast<VkDeviceEventInfoEXT *>(this); }
+ VkDeviceEventInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const *>(this); }
+};
+
+struct safe_VkDisplayEventInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayEventTypeEXT displayEvent;
+ safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct);
+ safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& src);
+ safe_VkDisplayEventInfoEXT();
+ ~safe_VkDisplayEventInfoEXT();
+ void initialize(const VkDisplayEventInfoEXT* in_struct);
+ void initialize(const safe_VkDisplayEventInfoEXT* src);
+ VkDisplayEventInfoEXT *ptr() { return reinterpret_cast<VkDisplayEventInfoEXT *>(this); }
+ VkDisplayEventInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const *>(this); }
+};
+
+struct safe_VkSwapchainCounterCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkSurfaceCounterFlagsEXT surfaceCounters;
+ safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct);
+ safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& src);
+ safe_VkSwapchainCounterCreateInfoEXT();
+ ~safe_VkSwapchainCounterCreateInfoEXT();
+ void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct);
+ void initialize(const safe_VkSwapchainCounterCreateInfoEXT* src);
+ VkSwapchainCounterCreateInfoEXT *ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>(this); }
+ VkSwapchainCounterCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkPresentTimesInfoGOOGLE {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t swapchainCount;
+ const VkPresentTimeGOOGLE* pTimes;
+ safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct);
+ safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& src);
+ safe_VkPresentTimesInfoGOOGLE();
+ ~safe_VkPresentTimesInfoGOOGLE();
+ void initialize(const VkPresentTimesInfoGOOGLE* in_struct);
+ void initialize(const safe_VkPresentTimesInfoGOOGLE* src);
+ VkPresentTimesInfoGOOGLE *ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE *>(this); }
+ VkPresentTimesInfoGOOGLE const *ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 perViewPositionAllComponents;
+ safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct);
+ safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src);
+ safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+ ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+ void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct);
+ void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* src);
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(this); }
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(this); }
+};
+
+struct safe_VkPipelineViewportSwizzleStateCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineViewportSwizzleStateCreateFlagsNV flags;
+ uint32_t viewportCount;
+ const VkViewportSwizzleNV* pViewportSwizzles;
+ safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct);
+ safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src);
+ safe_VkPipelineViewportSwizzleStateCreateInfoNV();
+ ~safe_VkPipelineViewportSwizzleStateCreateInfoNV();
+ void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct);
+ void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* src);
+ VkPipelineViewportSwizzleStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>(this); }
+ VkPipelineViewportSwizzleStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t maxDiscardRectangles;
+ safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct);
+ safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src);
+ safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
+ ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
+ void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct);
+ void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* src);
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(this); }
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const *>(this); }
+};
+
+struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
+ VkDiscardRectangleModeEXT discardRectangleMode;
+ uint32_t discardRectangleCount;
+ const VkRect2D* pDiscardRectangles;
+ safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct);
+ safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src);
+ safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
+ ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
+ void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct);
+ void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* src);
+ VkPipelineDiscardRectangleStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>(this); }
+ VkPipelineDiscardRectangleStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkHdrMetadataEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkXYColorEXT displayPrimaryRed;
+ VkXYColorEXT displayPrimaryGreen;
+ VkXYColorEXT displayPrimaryBlue;
+ VkXYColorEXT whitePoint;
+ float maxLuminance;
+ float minLuminance;
+ float maxContentLightLevel;
+ float maxFrameAverageLightLevel;
+ safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct);
+ safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src);
+ safe_VkHdrMetadataEXT();
+ ~safe_VkHdrMetadataEXT();
+ void initialize(const VkHdrMetadataEXT* in_struct);
+ void initialize(const safe_VkHdrMetadataEXT* src);
+ VkHdrMetadataEXT *ptr() { return reinterpret_cast<VkHdrMetadataEXT *>(this); }
+ VkHdrMetadataEXT const *ptr() const { return reinterpret_cast<VkHdrMetadataEXT const *>(this); }
+};
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+struct safe_VkIOSSurfaceCreateInfoMVK {
+ VkStructureType sType;
+ const void* pNext;
+ VkIOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
+ safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct);
+ safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& src);
+ safe_VkIOSSurfaceCreateInfoMVK();
+ ~safe_VkIOSSurfaceCreateInfoMVK();
+ void initialize(const VkIOSSurfaceCreateInfoMVK* in_struct);
+ void initialize(const safe_VkIOSSurfaceCreateInfoMVK* src);
+ VkIOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>(this); }
+ VkIOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK const *>(this); }
+};
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+struct safe_VkMacOSSurfaceCreateInfoMVK {
+ VkStructureType sType;
+ const void* pNext;
+ VkMacOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
+ safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct);
+ safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& src);
+ safe_VkMacOSSurfaceCreateInfoMVK();
+ ~safe_VkMacOSSurfaceCreateInfoMVK();
+ void initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct);
+ void initialize(const safe_VkMacOSSurfaceCreateInfoMVK* src);
+ VkMacOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>(this); }
+ VkMacOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK const *>(this); }
+};
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+struct safe_VkSamplerReductionModeCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkSamplerReductionModeEXT reductionMode;
+ safe_VkSamplerReductionModeCreateInfoEXT(const VkSamplerReductionModeCreateInfoEXT* in_struct);
+ safe_VkSamplerReductionModeCreateInfoEXT(const safe_VkSamplerReductionModeCreateInfoEXT& src);
+ safe_VkSamplerReductionModeCreateInfoEXT();
+ ~safe_VkSamplerReductionModeCreateInfoEXT();
+ void initialize(const VkSamplerReductionModeCreateInfoEXT* in_struct);
+ void initialize(const safe_VkSamplerReductionModeCreateInfoEXT* src);
+ VkSamplerReductionModeCreateInfoEXT *ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfoEXT *>(this); }
+ VkSamplerReductionModeCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 filterMinmaxSingleComponentFormats;
+ VkBool32 filterMinmaxImageComponentMapping;
+ safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct);
+ safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src);
+ safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT();
+ ~safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT();
+ void initialize(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct);
+ void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* src);
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(this); }
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 advancedBlendCoherentOperations;
+ safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct);
+ safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src);
+ safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+ ~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+ void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct);
+ void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* src);
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(this); }
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t advancedBlendMaxColorAttachments;
+ VkBool32 advancedBlendIndependentBlend;
+ VkBool32 advancedBlendNonPremultipliedSrcColor;
+ VkBool32 advancedBlendNonPremultipliedDstColor;
+ VkBool32 advancedBlendCorrelatedOverlap;
+ VkBool32 advancedBlendAllOperations;
+ safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct);
+ safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src);
+ safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+ ~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+ void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct);
+ void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* src);
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(this); }
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *>(this); }
+};
+
+struct safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 srcPremultiplied;
+ VkBool32 dstPremultiplied;
+ VkBlendOverlapEXT blendOverlap;
+ safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct);
+ safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src);
+ safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
+ ~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
+ void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct);
+ void initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* src);
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(this); }
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkPipelineCoverageToColorStateCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCoverageToColorStateCreateFlagsNV flags;
+ VkBool32 coverageToColorEnable;
+ uint32_t coverageToColorLocation;
+ safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct);
+ safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src);
+ safe_VkPipelineCoverageToColorStateCreateInfoNV();
+ ~safe_VkPipelineCoverageToColorStateCreateInfoNV();
+ void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct);
+ void initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* src);
+ VkPipelineCoverageToColorStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>(this); }
+ VkPipelineCoverageToColorStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV const *>(this); }
+};
+
+struct safe_VkPipelineCoverageModulationStateCreateInfoNV {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCoverageModulationStateCreateFlagsNV flags;
+ VkCoverageModulationModeNV coverageModulationMode;
+ VkBool32 coverageModulationTableEnable;
+ uint32_t coverageModulationTableCount;
+ const float* pCoverageModulationTable;
+ safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct);
+ safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& src);
+ safe_VkPipelineCoverageModulationStateCreateInfoNV();
+ ~safe_VkPipelineCoverageModulationStateCreateInfoNV();
+ void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct);
+ void initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* src);
+ VkPipelineCoverageModulationStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>(this); }
+ VkPipelineCoverageModulationStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV const *>(this); }
+};
diff --git a/build-fuchsia/generated/include/vk_struct_size_helper.c b/build-fuchsia/generated/include/vk_struct_size_helper.c
new file mode 100644
index 0000000..0e1f43d
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_struct_size_helper.c
@@ -0,0 +1,3260 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#include "vk_struct_size_helper.h"
+#include <string.h>
+#include <assert.h>
+
+// Function Definitions
+
+size_t vk_size_vkapplicationinfo(const VkApplicationInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkApplicationInfo);
+ struct_size += (struct_ptr->pApplicationName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->pApplicationName)) : 0;
+ struct_size += (struct_ptr->pEngineName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->pEngineName)) : 0;
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkinstancecreateinfo(const VkInstanceCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkInstanceCreateInfo);
+ struct_size += vk_size_vkapplicationinfo(struct_ptr->pApplicationInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->enabledLayerCount; i++) {
+ struct_size += (sizeof(char*) + (sizeof(char) * (1 + strlen(struct_ptr->ppEnabledLayerNames[i]))));
+ }
+ for (i = 0; i < struct_ptr->enabledExtensionCount; i++) {
+ struct_size += (sizeof(char*) + (sizeof(char) * (1 + strlen(struct_ptr->ppEnabledExtensionNames[i]))));
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkallocationcallbacks(const VkAllocationCallbacks* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkAllocationCallbacks);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceFeatures);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkformatproperties(const VkFormatProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFormatProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkextent3d(const VkExtent3D* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExtent3D);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageformatproperties(const VkImageFormatProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageFormatProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceLimits);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceSparseProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkqueuefamilyproperties(const VkQueueFamilyProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkQueueFamilyProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorytype(const VkMemoryType* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryType);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryheap(const VkMemoryHeap* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryHeap);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceMemoryProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceQueueCreateInfo);
+ struct_size += (struct_ptr->queueCount ) * sizeof(float);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicecreateinfo(const VkDeviceCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->queueCreateInfoCount; i++) {
+ struct_size += vk_size_vkdevicequeuecreateinfo(&struct_ptr->pQueueCreateInfos[i]);
+ }
+ for (i = 0; i < struct_ptr->enabledLayerCount; i++) {
+ struct_size += (sizeof(char*) + (sizeof(char) * (1 + strlen(struct_ptr->ppEnabledLayerNames[i]))));
+ }
+ for (i = 0; i < struct_ptr->enabledExtensionCount; i++) {
+ struct_size += (sizeof(char*) + (sizeof(char) * (1 + strlen(struct_ptr->ppEnabledExtensionNames[i]))));
+ }
+ struct_size += vk_size_vkphysicaldevicefeatures(struct_ptr->pEnabledFeatures);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkextensionproperties(const VkExtensionProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExtensionProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vklayerproperties(const VkLayerProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkLayerProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksubmitinfo(const VkSubmitInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSubmitInfo);
+ struct_size += (struct_ptr->waitSemaphoreCount ) * sizeof(VkSemaphore);
+ struct_size += (struct_ptr->waitSemaphoreCount ) * sizeof(VkPipelineStageFlags);
+ struct_size += (struct_ptr->commandBufferCount ) * sizeof(VkCommandBuffer);
+ struct_size += (struct_ptr->signalSemaphoreCount ) * sizeof(VkSemaphore);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryallocateinfo(const VkMemoryAllocateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryAllocateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmappedmemoryrange(const VkMappedMemoryRange* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMappedMemoryRange);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryrequirements(const VkMemoryRequirements* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryRequirements);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimageformatproperties(const VkSparseImageFormatProperties* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageFormatProperties);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageMemoryRequirements);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparsememorybind(const VkSparseMemoryBind* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseMemoryBind);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseBufferMemoryBindInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->bindCount; i++) {
+ struct_size += vk_size_vksparsememorybind(&struct_ptr->pBinds[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageOpaqueMemoryBindInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->bindCount; i++) {
+ struct_size += vk_size_vksparsememorybind(&struct_ptr->pBinds[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagesubresource(const VkImageSubresource* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageSubresource);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkoffset3d(const VkOffset3D* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkOffset3D);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimagememorybind(const VkSparseImageMemoryBind* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageMemoryBind);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageMemoryBindInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->bindCount; i++) {
+ struct_size += vk_size_vksparseimagememorybind(&struct_ptr->pBinds[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbindsparseinfo(const VkBindSparseInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBindSparseInfo);
+ struct_size += (struct_ptr->waitSemaphoreCount ) * sizeof(VkSemaphore);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->bufferBindCount; i++) {
+ struct_size += vk_size_vksparsebuffermemorybindinfo(&struct_ptr->pBufferBinds[i]);
+ }
+ for (i = 0; i < struct_ptr->imageOpaqueBindCount; i++) {
+ struct_size += vk_size_vksparseimageopaquememorybindinfo(&struct_ptr->pImageOpaqueBinds[i]);
+ }
+ for (i = 0; i < struct_ptr->imageBindCount; i++) {
+ struct_size += vk_size_vksparseimagememorybindinfo(&struct_ptr->pImageBinds[i]);
+ }
+ struct_size += (struct_ptr->signalSemaphoreCount ) * sizeof(VkSemaphore);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkfencecreateinfo(const VkFenceCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFenceCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSemaphoreCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkeventcreateinfo(const VkEventCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkEventCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkQueryPoolCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbuffercreateinfo(const VkBufferCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferCreateInfo);
+ struct_size += (struct_ptr->queueFamilyIndexCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferViewCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagecreateinfo(const VkImageCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageCreateInfo);
+ struct_size += (struct_ptr->queueFamilyIndexCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksubresourcelayout(const VkSubresourceLayout* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSubresourceLayout);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcomponentmapping(const VkComponentMapping* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkComponentMapping);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagesubresourcerange(const VkImageSubresourceRange* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageSubresourceRange);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageviewcreateinfo(const VkImageViewCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageViewCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkShaderModuleCreateInfo);
+ struct_size += (struct_ptr->codeSize/4 ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineCacheCreateInfo);
+ struct_size += (struct_ptr->initialDataSize ) * sizeof(void*);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkspecializationmapentry(const VkSpecializationMapEntry* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSpecializationMapEntry);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkspecializationinfo(const VkSpecializationInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSpecializationInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->mapEntryCount; i++) {
+ struct_size += vk_size_vkspecializationmapentry(&struct_ptr->pMapEntries[i]);
+ }
+ struct_size += (struct_ptr->dataSize ) * sizeof(void*);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineShaderStageCreateInfo);
+ struct_size += (struct_ptr->pName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->pName)) : 0;
+ struct_size += vk_size_vkspecializationinfo(struct_ptr->pSpecializationInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkVertexInputBindingDescription);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkVertexInputAttributeDescription);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineVertexInputStateCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->vertexBindingDescriptionCount; i++) {
+ struct_size += vk_size_vkvertexinputbindingdescription(&struct_ptr->pVertexBindingDescriptions[i]);
+ }
+ for (i = 0; i < struct_ptr->vertexAttributeDescriptionCount; i++) {
+ struct_size += vk_size_vkvertexinputattributedescription(&struct_ptr->pVertexAttributeDescriptions[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineInputAssemblyStateCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineTessellationStateCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkviewport(const VkViewport* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkViewport);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkoffset2d(const VkOffset2D* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkOffset2D);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkextent2d(const VkExtent2D* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExtent2D);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrect2d(const VkRect2D* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRect2D);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineViewportStateCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->viewportCount; i++) {
+ struct_size += vk_size_vkviewport(&struct_ptr->pViewports[i]);
+ }
+ for (i = 0; i < struct_ptr->scissorCount; i++) {
+ struct_size += vk_size_vkrect2d(&struct_ptr->pScissors[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineRasterizationStateCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineMultisampleStateCreateInfo);
+ struct_size += (struct_ptr->rasterizationSamples/32 + 1 ) * sizeof(VkSampleMask);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkstencilopstate(const VkStencilOpState* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkStencilOpState);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineDepthStencilStateCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineColorBlendAttachmentState);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineColorBlendStateCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->attachmentCount; i++) {
+ struct_size += vk_size_vkpipelinecolorblendattachmentstate(&struct_ptr->pAttachments[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineDynamicStateCreateInfo);
+ struct_size += (struct_ptr->dynamicStateCount ) * sizeof(VkDynamicState);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkGraphicsPipelineCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->stageCount; i++) {
+ struct_size += vk_size_vkpipelineshaderstagecreateinfo(&struct_ptr->pStages[i]);
+ }
+ struct_size += vk_size_vkpipelinevertexinputstatecreateinfo(struct_ptr->pVertexInputState);
+ struct_size += vk_size_vkpipelineinputassemblystatecreateinfo(struct_ptr->pInputAssemblyState);
+ struct_size += vk_size_vkpipelinetessellationstatecreateinfo(struct_ptr->pTessellationState);
+ struct_size += vk_size_vkpipelineviewportstatecreateinfo(struct_ptr->pViewportState);
+ struct_size += vk_size_vkpipelinerasterizationstatecreateinfo(struct_ptr->pRasterizationState);
+ struct_size += vk_size_vkpipelinemultisamplestatecreateinfo(struct_ptr->pMultisampleState);
+ struct_size += vk_size_vkpipelinedepthstencilstatecreateinfo(struct_ptr->pDepthStencilState);
+ struct_size += vk_size_vkpipelinecolorblendstatecreateinfo(struct_ptr->pColorBlendState);
+ struct_size += vk_size_vkpipelinedynamicstatecreateinfo(struct_ptr->pDynamicState);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkComputePipelineCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpushconstantrange(const VkPushConstantRange* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPushConstantRange);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineLayoutCreateInfo);
+ struct_size += (struct_ptr->setLayoutCount ) * sizeof(VkDescriptorSetLayout);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->pushConstantRangeCount; i++) {
+ struct_size += vk_size_vkpushconstantrange(&struct_ptr->pPushConstantRanges[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksamplercreateinfo(const VkSamplerCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSamplerCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorSetLayoutBinding);
+ struct_size += (struct_ptr->descriptorCount ) * sizeof(VkSampler);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorSetLayoutCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->bindingCount; i++) {
+ struct_size += vk_size_vkdescriptorsetlayoutbinding(&struct_ptr->pBindings[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorpoolsize(const VkDescriptorPoolSize* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorPoolSize);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorPoolCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->poolSizeCount; i++) {
+ struct_size += vk_size_vkdescriptorpoolsize(&struct_ptr->pPoolSizes[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorSetAllocateInfo);
+ struct_size += (struct_ptr->descriptorSetCount ) * sizeof(VkDescriptorSetLayout);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorimageinfo(const VkDescriptorImageInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorImageInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorBufferInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkwritedescriptorset(const VkWriteDescriptorSet* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkWriteDescriptorSet);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->descriptorCount; i++) {
+ struct_size += vk_size_vkdescriptorimageinfo(&struct_ptr->pImageInfo[i]);
+ }
+ for (i = 0; i < struct_ptr->descriptorCount; i++) {
+ struct_size += vk_size_vkdescriptorbufferinfo(&struct_ptr->pBufferInfo[i]);
+ }
+ struct_size += (struct_ptr->descriptorCount ) * sizeof(VkBufferView);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcopydescriptorset(const VkCopyDescriptorSet* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCopyDescriptorSet);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkframebuffercreateinfo(const VkFramebufferCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFramebufferCreateInfo);
+ struct_size += (struct_ptr->attachmentCount ) * sizeof(VkImageView);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkattachmentdescription(const VkAttachmentDescription* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkAttachmentDescription);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkattachmentreference(const VkAttachmentReference* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkAttachmentReference);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksubpassdescription(const VkSubpassDescription* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSubpassDescription);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->inputAttachmentCount; i++) {
+ struct_size += vk_size_vkattachmentreference(&struct_ptr->pInputAttachments[i]);
+ }
+ for (i = 0; i < struct_ptr->colorAttachmentCount; i++) {
+ struct_size += vk_size_vkattachmentreference(&struct_ptr->pColorAttachments[i]);
+ }
+ for (i = 0; i < struct_ptr->colorAttachmentCount; i++) {
+ struct_size += vk_size_vkattachmentreference(&struct_ptr->pResolveAttachments[i]);
+ }
+ struct_size += vk_size_vkattachmentreference(struct_ptr->pDepthStencilAttachment);
+ struct_size += (struct_ptr->preserveAttachmentCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksubpassdependency(const VkSubpassDependency* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSubpassDependency);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRenderPassCreateInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->attachmentCount; i++) {
+ struct_size += vk_size_vkattachmentdescription(&struct_ptr->pAttachments[i]);
+ }
+ for (i = 0; i < struct_ptr->subpassCount; i++) {
+ struct_size += vk_size_vksubpassdescription(&struct_ptr->pSubpasses[i]);
+ }
+ for (i = 0; i < struct_ptr->dependencyCount; i++) {
+ struct_size += vk_size_vksubpassdependency(&struct_ptr->pDependencies[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCommandPoolCreateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCommandBufferAllocateInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCommandBufferInheritanceInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCommandBufferBeginInfo);
+ struct_size += vk_size_vkcommandbufferinheritanceinfo(struct_ptr->pInheritanceInfo);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbuffercopy(const VkBufferCopy* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferCopy);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagesubresourcelayers(const VkImageSubresourceLayers* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageSubresourceLayers);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagecopy(const VkImageCopy* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageCopy);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageblit(const VkImageBlit* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageBlit);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbufferimagecopy(const VkBufferImageCopy* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferImageCopy);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkclearcolorvalue(const VkClearColorValue* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkClearColorValue);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcleardepthstencilvalue(const VkClearDepthStencilValue* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkClearDepthStencilValue);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkclearvalue(const VkClearValue* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkClearValue);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkclearattachment(const VkClearAttachment* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkClearAttachment);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkclearrect(const VkClearRect* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkClearRect);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageresolve(const VkImageResolve* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageResolve);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorybarrier(const VkMemoryBarrier* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryBarrier);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbuffermemorybarrier(const VkBufferMemoryBarrier* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferMemoryBarrier);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagememorybarrier(const VkImageMemoryBarrier* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageMemoryBarrier);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrenderpassbegininfo(const VkRenderPassBeginInfo* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRenderPassBeginInfo);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->clearValueCount; i++) {
+ struct_size += vk_size_vkclearvalue(&struct_ptr->pClearValues[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdispatchindirectcommand(const VkDispatchIndirectCommand* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDispatchIndirectCommand);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDrawIndexedIndirectCommand);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdrawindirectcommand(const VkDrawIndirectCommand* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDrawIndirectCommand);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSurfaceCapabilitiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksurfaceformatkhr(const VkSurfaceFormatKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSurfaceFormatKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSwapchainCreateInfoKHR);
+ struct_size += (struct_ptr->queueFamilyIndexCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpresentinfokhr(const VkPresentInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPresentInfoKHR);
+ struct_size += (struct_ptr->waitSemaphoreCount ) * sizeof(VkSemaphore);
+ struct_size += (struct_ptr->swapchainCount ) * sizeof(VkSwapchainKHR);
+ struct_size += (struct_ptr->swapchainCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->swapchainCount ) * sizeof(VkResult);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayPropertiesKHR);
+ struct_size += (struct_ptr->displayName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->displayName)) : 0;
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayModeParametersKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayModePropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayModeCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayPlaneCapabilitiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayPlanePropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplaySurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayPresentInfoKHR);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+size_t vk_size_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkXlibSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+size_t vk_size_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkXcbSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+size_t vk_size_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkWaylandSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+size_t vk_size_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMirSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+size_t vk_size_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkAndroidSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkWin32SurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+size_t vk_size_vkmagmasurfacecreateinfokhr(const VkMagmaSurfaceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMagmaSurfaceCreateInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+
+size_t vk_size_vkphysicaldevicefeatures2khr(const VkPhysicalDeviceFeatures2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceFeatures2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceproperties2khr(const VkPhysicalDeviceProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkformatproperties2khr(const VkFormatProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFormatProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageformatproperties2khr(const VkImageFormatProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageFormatProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceimageformatinfo2khr(const VkPhysicalDeviceImageFormatInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceImageFormatInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkqueuefamilyproperties2khr(const VkQueueFamilyProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkQueueFamilyProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicememoryproperties2khr(const VkPhysicalDeviceMemoryProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceMemoryProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimageformatproperties2khr(const VkSparseImageFormatProperties2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageFormatProperties2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicesparseimageformatinfo2khr(const VkPhysicalDeviceSparseImageFormatInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceSparseImageFormatInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalmemorypropertieskhr(const VkExternalMemoryPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalMemoryPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceexternalimageformatinfokhr(const VkPhysicalDeviceExternalImageFormatInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceExternalImageFormatInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalimageformatpropertieskhr(const VkExternalImageFormatPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalImageFormatPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceexternalbufferinfokhr(const VkPhysicalDeviceExternalBufferInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceExternalBufferInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalbufferpropertieskhr(const VkExternalBufferPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalBufferPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceidpropertieskhr(const VkPhysicalDeviceIDPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceIDPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalmemoryimagecreateinfokhr(const VkExternalMemoryImageCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalMemoryImageCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalmemorybuffercreateinfokhr(const VkExternalMemoryBufferCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalMemoryBufferCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexportmemoryallocateinfokhr(const VkExportMemoryAllocateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportMemoryAllocateInfoKHR);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportmemorywin32handleinfokhr(const VkImportMemoryWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportMemoryWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportmemorywin32handleinfokhr(const VkExportMemoryWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportMemoryWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkmemorywin32handlepropertieskhr(const VkMemoryWin32HandlePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryWin32HandlePropertiesKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkmemorygetwin32handleinfokhr(const VkMemoryGetWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryGetWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+size_t vk_size_vkimportmemoryfdinfokhr(const VkImportMemoryFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportMemoryFdInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryfdpropertieskhr(const VkMemoryFdPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryFdPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorygetfdinfokhr(const VkMemoryGetFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryGetFdInfoKHR);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32keyedmutexacquirereleaseinfokhr(const VkWin32KeyedMutexAcquireReleaseInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(VkDeviceMemory);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(uint64_t);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->releaseCount ) * sizeof(VkDeviceMemory);
+ struct_size += (struct_ptr->releaseCount ) * sizeof(uint64_t);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+size_t vk_size_vkphysicaldeviceexternalsemaphoreinfokhr(const VkPhysicalDeviceExternalSemaphoreInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceExternalSemaphoreInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalsemaphorepropertieskhr(const VkExternalSemaphorePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalSemaphorePropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexportsemaphorecreateinfokhr(const VkExportSemaphoreCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportSemaphoreCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportsemaphorewin32handleinfokhr(const VkImportSemaphoreWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportSemaphoreWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportsemaphorewin32handleinfokhr(const VkExportSemaphoreWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportSemaphoreWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkd3d12fencesubmitinfokhr(const VkD3D12FenceSubmitInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkD3D12FenceSubmitInfoKHR);
+ struct_size += (struct_ptr->waitSemaphoreValuesCount ) * sizeof(uint64_t);
+ struct_size += (struct_ptr->signalSemaphoreValuesCount ) * sizeof(uint64_t);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vksemaphoregetwin32handleinfokhr(const VkSemaphoreGetWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSemaphoreGetWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+size_t vk_size_vkimportsemaphorefdinfokhr(const VkImportSemaphoreFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportSemaphoreFdInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksemaphoregetfdinfokhr(const VkSemaphoreGetFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSemaphoreGetFdInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicepushdescriptorpropertieskhr(const VkPhysicalDevicePushDescriptorPropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevice16bitstoragefeatureskhr(const VkPhysicalDevice16BitStorageFeaturesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDevice16BitStorageFeaturesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrectlayerkhr(const VkRectLayerKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRectLayerKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpresentregionkhr(const VkPresentRegionKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPresentRegionKHR);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->rectangleCount; i++) {
+ struct_size += vk_size_vkrectlayerkhr(&struct_ptr->pRectangles[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpresentregionskhr(const VkPresentRegionsKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPresentRegionsKHR);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->swapchainCount; i++) {
+ struct_size += vk_size_vkpresentregionkhr(&struct_ptr->pRegions[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorupdatetemplateentrykhr(const VkDescriptorUpdateTemplateEntryKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorUpdateTemplateEntryKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdescriptorupdatetemplatecreateinfokhr(const VkDescriptorUpdateTemplateCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDescriptorUpdateTemplateCreateInfoKHR);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->descriptorUpdateEntryCount; i++) {
+ struct_size += vk_size_vkdescriptorupdatetemplateentrykhr(&struct_ptr->pDescriptorUpdateEntries[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksharedpresentsurfacecapabilitieskhr(const VkSharedPresentSurfaceCapabilitiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSharedPresentSurfaceCapabilitiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceexternalfenceinfokhr(const VkPhysicalDeviceExternalFenceInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceExternalFenceInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalfencepropertieskhr(const VkExternalFencePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalFencePropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexportfencecreateinfokhr(const VkExportFenceCreateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportFenceCreateInfoKHR);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportfencewin32handleinfokhr(const VkImportFenceWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportFenceWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportfencewin32handleinfokhr(const VkExportFenceWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportFenceWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkfencegetwin32handleinfokhr(const VkFenceGetWin32HandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFenceGetWin32HandleInfoKHR);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+size_t vk_size_vkimportfencefdinfokhr(const VkImportFenceFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportFenceFdInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkfencegetfdinfokhr(const VkFenceGetFdInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkFenceGetFdInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicesurfaceinfo2khr(const VkPhysicalDeviceSurfaceInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceSurfaceInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksurfacecapabilities2khr(const VkSurfaceCapabilities2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSurfaceCapabilities2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksurfaceformat2khr(const VkSurfaceFormat2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSurfaceFormat2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicevariablepointerfeatureskhr(const VkPhysicalDeviceVariablePointerFeaturesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceVariablePointerFeaturesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorydedicatedrequirementskhr(const VkMemoryDedicatedRequirementsKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryDedicatedRequirementsKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorydedicatedallocateinfokhr(const VkMemoryDedicatedAllocateInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryDedicatedAllocateInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbuffermemoryrequirementsinfo2khr(const VkBufferMemoryRequirementsInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBufferMemoryRequirementsInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagememoryrequirementsinfo2khr(const VkImageMemoryRequirementsInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageMemoryRequirementsInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimagesparsememoryrequirementsinfo2khr(const VkImageSparseMemoryRequirementsInfo2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageSparseMemoryRequirementsInfo2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryrequirements2khr(const VkMemoryRequirements2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryRequirements2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksparseimagememoryrequirements2khr(const VkSparseImageMemoryRequirements2KHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSparseImageMemoryRequirements2KHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimportmemoryfuchsiahandleinfokhr(const VkImportMemoryFuchsiaHandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportMemoryFuchsiaHandleInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemoryfuchsiahandlepropertieskhr(const VkMemoryFuchsiaHandlePropertiesKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryFuchsiaHandlePropertiesKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkmemorygetfuchsiahandleinfokhr(const VkMemoryGetFuchsiaHandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryGetFuchsiaHandleInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimportsemaphorefuchsiahandleinfokhr(const VkImportSemaphoreFuchsiaHandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportSemaphoreFuchsiaHandleInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksemaphoregetfuchsiahandleinfokhr(const VkSemaphoreGetFuchsiaHandleInfoKHR* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSemaphoreGetFuchsiaHandleInfoKHR);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDebugReportCallbackCreateInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineRasterizationStateRasterizationOrderAMD);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDebugMarkerObjectNameInfoEXT);
+ struct_size += (struct_ptr->pObjectName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->pObjectName)) : 0;
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDebugMarkerObjectTagInfoEXT);
+ struct_size += (struct_ptr->tagSize ) * sizeof(void*);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDebugMarkerMarkerInfoEXT);
+ struct_size += (struct_ptr->pMarkerName != NULL) ? sizeof(char)*(1+strlen(struct_ptr->pMarkerName)) : 0;
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdedicatedallocationimagecreateinfonv(const VkDedicatedAllocationImageCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDedicatedAllocationImageCreateInfoNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdedicatedallocationbuffercreateinfonv(const VkDedicatedAllocationBufferCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDedicatedAllocationBufferCreateInfoNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdedicatedallocationmemoryallocateinfonv(const VkDedicatedAllocationMemoryAllocateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDedicatedAllocationMemoryAllocateInfoNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vktexturelodgatherformatpropertiesamd(const VkTextureLODGatherFormatPropertiesAMD* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkTextureLODGatherFormatPropertiesAMD);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrenderpassmultiviewcreateinfokhx(const VkRenderPassMultiviewCreateInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRenderPassMultiviewCreateInfoKHX);
+ struct_size += (struct_ptr->subpassCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->dependencyCount ) * sizeof(int32_t);
+ struct_size += (struct_ptr->correlationMaskCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicemultiviewfeatureskhx(const VkPhysicalDeviceMultiviewFeaturesKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceMultiviewFeaturesKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicemultiviewpropertieskhx(const VkPhysicalDeviceMultiviewPropertiesKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceMultiviewPropertiesKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalimageformatpropertiesnv(const VkExternalImageFormatPropertiesNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalImageFormatPropertiesNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexternalmemoryimagecreateinfonv(const VkExternalMemoryImageCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExternalMemoryImageCreateInfoNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkexportmemoryallocateinfonv(const VkExportMemoryAllocateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportMemoryAllocateInfoNV);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportmemorywin32handleinfonv(const VkImportMemoryWin32HandleInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImportMemoryWin32HandleInfoNV);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportmemorywin32handleinfonv(const VkExportMemoryWin32HandleInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkExportMemoryWin32HandleInfoNV);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32keyedmutexacquirereleaseinfonv(const VkWin32KeyedMutexAcquireReleaseInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(VkDeviceMemory);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(uint64_t);
+ struct_size += (struct_ptr->acquireCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->releaseCount ) * sizeof(VkDeviceMemory);
+ struct_size += (struct_ptr->releaseCount ) * sizeof(uint64_t);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+size_t vk_size_vkmemoryallocateflagsinfokhx(const VkMemoryAllocateFlagsInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMemoryAllocateFlagsInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbindbuffermemoryinfokhx(const VkBindBufferMemoryInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBindBufferMemoryInfoKHX);
+ struct_size += (struct_ptr->deviceIndexCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbindimagememoryinfokhx(const VkBindImageMemoryInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBindImageMemoryInfoKHX);
+ struct_size += (struct_ptr->deviceIndexCount ) * sizeof(uint32_t);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->SFRRectCount; i++) {
+ struct_size += vk_size_vkrect2d(&struct_ptr->pSFRRects[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegrouprenderpassbegininfokhx(const VkDeviceGroupRenderPassBeginInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupRenderPassBeginInfoKHX);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->deviceRenderAreaCount; i++) {
+ struct_size += vk_size_vkrect2d(&struct_ptr->pDeviceRenderAreas[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegroupcommandbufferbegininfokhx(const VkDeviceGroupCommandBufferBeginInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupCommandBufferBeginInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegroupsubmitinfokhx(const VkDeviceGroupSubmitInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupSubmitInfoKHX);
+ struct_size += (struct_ptr->waitSemaphoreCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->commandBufferCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->signalSemaphoreCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegroupbindsparseinfokhx(const VkDeviceGroupBindSparseInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupBindSparseInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegrouppresentcapabilitieskhx(const VkDeviceGroupPresentCapabilitiesKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupPresentCapabilitiesKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkimageswapchaincreateinfokhx(const VkImageSwapchainCreateInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkImageSwapchainCreateInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkbindimagememoryswapchaininfokhx(const VkBindImageMemorySwapchainInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkBindImageMemorySwapchainInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkacquirenextimageinfokhx(const VkAcquireNextImageInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkAcquireNextImageInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegrouppresentinfokhx(const VkDeviceGroupPresentInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupPresentInfoKHX);
+ struct_size += (struct_ptr->swapchainCount ) * sizeof(uint32_t);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegroupswapchaincreateinfokhx(const VkDeviceGroupSwapchainCreateInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupSwapchainCreateInfoKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkvalidationflagsext(const VkValidationFlagsEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkValidationFlagsEXT);
+ struct_size += (struct_ptr->disabledValidationCheckCount ) * sizeof(VkValidationCheckEXT);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_VI_NN
+size_t vk_size_vkvisurfacecreateinfonn(const VkViSurfaceCreateInfoNN* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkViSurfaceCreateInfoNN);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_VI_NN
+
+size_t vk_size_vkphysicaldevicegrouppropertieskhx(const VkPhysicalDeviceGroupPropertiesKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceGroupPropertiesKHX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegroupdevicecreateinfokhx(const VkDeviceGroupDeviceCreateInfoKHX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGroupDeviceCreateInfoKHX);
+ struct_size += (struct_ptr->physicalDeviceCount ) * sizeof(VkPhysicalDevice);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegeneratedcommandsfeaturesnvx(const VkDeviceGeneratedCommandsFeaturesNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGeneratedCommandsFeaturesNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdevicegeneratedcommandslimitsnvx(const VkDeviceGeneratedCommandsLimitsNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceGeneratedCommandsLimitsNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkindirectcommandstokennvx(const VkIndirectCommandsTokenNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkIndirectCommandsTokenNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkindirectcommandslayouttokennvx(const VkIndirectCommandsLayoutTokenNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkIndirectCommandsLayoutTokenNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkindirectcommandslayoutcreateinfonvx(const VkIndirectCommandsLayoutCreateInfoNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkIndirectCommandsLayoutCreateInfoNVX);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->tokenCount; i++) {
+ struct_size += vk_size_vkindirectcommandslayouttokennvx(&struct_ptr->pTokens[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcmdprocesscommandsinfonvx(const VkCmdProcessCommandsInfoNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCmdProcessCommandsInfoNVX);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->indirectCommandsTokenCount; i++) {
+ struct_size += vk_size_vkindirectcommandstokennvx(&struct_ptr->pIndirectCommandsTokens[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkcmdreservespaceforcommandsinfonvx(const VkCmdReserveSpaceForCommandsInfoNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkCmdReserveSpaceForCommandsInfoNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttablecreateinfonvx(const VkObjectTableCreateInfoNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTableCreateInfoNVX);
+ struct_size += (struct_ptr->objectCount ) * sizeof(VkObjectEntryTypeNVX);
+ struct_size += (struct_ptr->objectCount ) * sizeof(uint32_t);
+ struct_size += (struct_ptr->objectCount ) * sizeof(VkObjectEntryUsageFlagsNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttableentrynvx(const VkObjectTableEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTableEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttablepipelineentrynvx(const VkObjectTablePipelineEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTablePipelineEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttabledescriptorsetentrynvx(const VkObjectTableDescriptorSetEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTableDescriptorSetEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttablevertexbufferentrynvx(const VkObjectTableVertexBufferEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTableVertexBufferEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttableindexbufferentrynvx(const VkObjectTableIndexBufferEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTableIndexBufferEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkobjecttablepushconstantentrynvx(const VkObjectTablePushConstantEntryNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkObjectTablePushConstantEntryNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkviewportwscalingnv(const VkViewportWScalingNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkViewportWScalingNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelineviewportwscalingstatecreateinfonv(const VkPipelineViewportWScalingStateCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineViewportWScalingStateCreateInfoNV);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->viewportCount; i++) {
+ struct_size += vk_size_vkviewportwscalingnv(&struct_ptr->pViewportWScalings[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vksurfacecapabilities2ext(const VkSurfaceCapabilities2EXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSurfaceCapabilities2EXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplaypowerinfoext(const VkDisplayPowerInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayPowerInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdeviceeventinfoext(const VkDeviceEventInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDeviceEventInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkdisplayeventinfoext(const VkDisplayEventInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkDisplayEventInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkswapchaincountercreateinfoext(const VkSwapchainCounterCreateInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSwapchainCounterCreateInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkrefreshcycledurationgoogle(const VkRefreshCycleDurationGOOGLE* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkRefreshCycleDurationGOOGLE);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpastpresentationtiminggoogle(const VkPastPresentationTimingGOOGLE* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPastPresentationTimingGOOGLE);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpresenttimegoogle(const VkPresentTimeGOOGLE* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPresentTimeGOOGLE);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpresenttimesinfogoogle(const VkPresentTimesInfoGOOGLE* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPresentTimesInfoGOOGLE);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->swapchainCount; i++) {
+ struct_size += vk_size_vkpresenttimegoogle(&struct_ptr->pTimes[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicemultiviewperviewattributespropertiesnvx(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkviewportswizzlenv(const VkViewportSwizzleNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkViewportSwizzleNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelineviewportswizzlestatecreateinfonv(const VkPipelineViewportSwizzleStateCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineViewportSwizzleStateCreateInfoNV);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->viewportCount; i++) {
+ struct_size += vk_size_vkviewportswizzlenv(&struct_ptr->pViewportSwizzles[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicediscardrectanglepropertiesext(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinediscardrectanglestatecreateinfoext(const VkPipelineDiscardRectangleStateCreateInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT);
+ uint32_t i = 0;
+ for (i = 0; i < struct_ptr->discardRectangleCount; i++) {
+ struct_size += vk_size_vkrect2d(&struct_ptr->pDiscardRectangles[i]);
+ }
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkxycolorext(const VkXYColorEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkXYColorEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkhdrmetadataext(const VkHdrMetadataEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkHdrMetadataEXT);
+ }
+ return struct_size;
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+size_t vk_size_vkiossurfacecreateinfomvk(const VkIOSSurfaceCreateInfoMVK* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkIOSSurfaceCreateInfoMVK);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+size_t vk_size_vkmacossurfacecreateinfomvk(const VkMacOSSurfaceCreateInfoMVK* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkMacOSSurfaceCreateInfoMVK);
+ }
+ return struct_size;
+}
+#endif // VK_USE_PLATFORM_MACOS_MVK
+
+size_t vk_size_vksamplerreductionmodecreateinfoext(const VkSamplerReductionModeCreateInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkSamplerReductionModeCreateInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldevicesamplerfilterminmaxpropertiesext(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceblendoperationadvancedfeaturesext(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkphysicaldeviceblendoperationadvancedpropertiesext(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecolorblendadvancedstatecreateinfoext(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecoveragetocolorstatecreateinfonv(const VkPipelineCoverageToColorStateCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineCoverageToColorStateCreateInfoNV);
+ }
+ return struct_size;
+}
+
+size_t vk_size_vkpipelinecoveragemodulationstatecreateinfonv(const VkPipelineCoverageModulationStateCreateInfoNV* struct_ptr) {
+ size_t struct_size = 0;
+ if (struct_ptr) {
+ struct_size = sizeof(VkPipelineCoverageModulationStateCreateInfoNV);
+ struct_size += (struct_ptr->coverageModulationTableCount ) * sizeof(float);
+ }
+ return struct_size;
+}
+
+size_t get_struct_chain_size(const void* struct_ptr) {
+ // Use VkApplicationInfo as struct until actual type is resolved
+ VkApplicationInfo* pNext = (VkApplicationInfo*)struct_ptr;
+ size_t struct_size = 0;
+ while (pNext) {
+ switch (pNext->sType) {
+ case VK_STRUCTURE_TYPE_APPLICATION_INFO: {
+ struct_size += vk_size_vkapplicationinfo((VkApplicationInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: {
+ struct_size += vk_size_vkinstancecreateinfo((VkInstanceCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: {
+ struct_size += vk_size_vkdevicequeuecreateinfo((VkDeviceQueueCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ struct_size += vk_size_vkdevicecreateinfo((VkDeviceCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBMIT_INFO: {
+ struct_size += vk_size_vksubmitinfo((VkSubmitInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ struct_size += vk_size_vkmemoryallocateinfo((VkMemoryAllocateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: {
+ struct_size += vk_size_vkmappedmemoryrange((VkMappedMemoryRange*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: {
+ struct_size += vk_size_vkbindsparseinfo((VkBindSparseInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: {
+ struct_size += vk_size_vkfencecreateinfo((VkFenceCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: {
+ struct_size += vk_size_vksemaphorecreateinfo((VkSemaphoreCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: {
+ struct_size += vk_size_vkeventcreateinfo((VkEventCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: {
+ struct_size += vk_size_vkquerypoolcreateinfo((VkQueryPoolCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: {
+ struct_size += vk_size_vkbuffercreateinfo((VkBufferCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: {
+ struct_size += vk_size_vkbufferviewcreateinfo((VkBufferViewCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: {
+ struct_size += vk_size_vkimagecreateinfo((VkImageCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: {
+ struct_size += vk_size_vkimageviewcreateinfo((VkImageViewCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+ struct_size += vk_size_vkshadermodulecreateinfo((VkShaderModuleCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinecachecreateinfo((VkPipelineCacheCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelineshaderstagecreateinfo((VkPipelineShaderStageCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinevertexinputstatecreateinfo((VkPipelineVertexInputStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelineinputassemblystatecreateinfo((VkPipelineInputAssemblyStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinetessellationstatecreateinfo((VkPipelineTessellationStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelineviewportstatecreateinfo((VkPipelineViewportStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinerasterizationstatecreateinfo((VkPipelineRasterizationStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinemultisamplestatecreateinfo((VkPipelineMultisampleStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinedepthstencilstatecreateinfo((VkPipelineDepthStencilStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinecolorblendstatecreateinfo((VkPipelineColorBlendStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinedynamicstatecreateinfo((VkPipelineDynamicStateCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: {
+ struct_size += vk_size_vkgraphicspipelinecreateinfo((VkGraphicsPipelineCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: {
+ struct_size += vk_size_vkcomputepipelinecreateinfo((VkComputePipelineCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: {
+ struct_size += vk_size_vkpipelinelayoutcreateinfo((VkPipelineLayoutCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: {
+ struct_size += vk_size_vksamplercreateinfo((VkSamplerCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: {
+ struct_size += vk_size_vkdescriptorsetlayoutcreateinfo((VkDescriptorSetLayoutCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: {
+ struct_size += vk_size_vkdescriptorpoolcreateinfo((VkDescriptorPoolCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: {
+ struct_size += vk_size_vkdescriptorsetallocateinfo((VkDescriptorSetAllocateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: {
+ struct_size += vk_size_vkwritedescriptorset((VkWriteDescriptorSet*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: {
+ struct_size += vk_size_vkcopydescriptorset((VkCopyDescriptorSet*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: {
+ struct_size += vk_size_vkframebuffercreateinfo((VkFramebufferCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ struct_size += vk_size_vkrenderpasscreateinfo((VkRenderPassCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: {
+ struct_size += vk_size_vkcommandpoolcreateinfo((VkCommandPoolCreateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: {
+ struct_size += vk_size_vkcommandbufferallocateinfo((VkCommandBufferAllocateInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: {
+ struct_size += vk_size_vkcommandbufferinheritanceinfo((VkCommandBufferInheritanceInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: {
+ struct_size += vk_size_vkcommandbufferbegininfo((VkCommandBufferBeginInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
+ struct_size += vk_size_vkmemorybarrier((VkMemoryBarrier*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
+ struct_size += vk_size_vkbuffermemorybarrier((VkBufferMemoryBarrier*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
+ struct_size += vk_size_vkimagememorybarrier((VkImageMemoryBarrier*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: {
+ struct_size += vk_size_vkrenderpassbegininfo((VkRenderPassBeginInfo*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkswapchaincreateinfokhr((VkSwapchainCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: {
+ struct_size += vk_size_vkpresentinfokhr((VkPresentInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkdisplaymodecreateinfokhr((VkDisplayModeCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkdisplaysurfacecreateinfokhr((VkDisplaySurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ struct_size += vk_size_vkdisplaypresentinfokhr((VkDisplayPresentInfoKHR*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkxlibsurfacecreateinfokhr((VkXlibSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkxcbsurfacecreateinfokhr((VkXcbSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkwaylandsurfacecreateinfokhr((VkWaylandSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkmirsurfacecreateinfokhr((VkMirSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkandroidsurfacecreateinfokhr((VkAndroidSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkwin32surfacecreateinfokhr((VkWin32SurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+ case VK_STRUCTURE_TYPE_MAGMA_SURFACE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkmagmasurfacecreateinfokhr((VkMagmaSurfaceCreateInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
+ struct_size += vk_size_vkphysicaldevicefeatures2khr((VkPhysicalDeviceFeatures2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vkphysicaldeviceproperties2khr((VkPhysicalDeviceProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vkformatproperties2khr((VkFormatProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vkimageformatproperties2khr((VkImageFormatProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: {
+ struct_size += vk_size_vkphysicaldeviceimageformatinfo2khr((VkPhysicalDeviceImageFormatInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vkqueuefamilyproperties2khr((VkQueueFamilyProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vkphysicaldevicememoryproperties2khr((VkPhysicalDeviceMemoryProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: {
+ struct_size += vk_size_vksparseimageformatproperties2khr((VkSparseImageFormatProperties2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: {
+ struct_size += vk_size_vkphysicaldevicesparseimageformatinfo2khr((VkPhysicalDeviceSparseImageFormatInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: {
+ struct_size += vk_size_vkphysicaldeviceexternalimageformatinfokhr((VkPhysicalDeviceExternalImageFormatInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: {
+ struct_size += vk_size_vkexternalimageformatpropertieskhr((VkExternalImageFormatPropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: {
+ struct_size += vk_size_vkphysicaldeviceexternalbufferinfokhr((VkPhysicalDeviceExternalBufferInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: {
+ struct_size += vk_size_vkexternalbufferpropertieskhr((VkExternalBufferPropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: {
+ struct_size += vk_size_vkphysicaldeviceidpropertieskhr((VkPhysicalDeviceIDPropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkexternalmemoryimagecreateinfokhr((VkExternalMemoryImageCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkexternalmemorybuffercreateinfokhr((VkExternalMemoryBufferCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: {
+ struct_size += vk_size_vkexportmemoryallocateinfokhr((VkExportMemoryAllocateInfoKHR*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkimportmemorywin32handleinfokhr((VkImportMemoryWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkexportmemorywin32handleinfokhr((VkExportMemoryWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: {
+ struct_size += vk_size_vkmemorywin32handlepropertieskhr((VkMemoryWin32HandlePropertiesKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkmemorygetwin32handleinfokhr((VkMemoryGetWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ struct_size += vk_size_vkimportmemoryfdinfokhr((VkImportMemoryFdInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: {
+ struct_size += vk_size_vkmemoryfdpropertieskhr((VkMemoryFdPropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: {
+ struct_size += vk_size_vkmemorygetfdinfokhr((VkMemoryGetFdInfoKHR*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ struct_size += vk_size_vkwin32keyedmutexacquirereleaseinfokhr((VkWin32KeyedMutexAcquireReleaseInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: {
+ struct_size += vk_size_vkphysicaldeviceexternalsemaphoreinfokhr((VkPhysicalDeviceExternalSemaphoreInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: {
+ struct_size += vk_size_vkexternalsemaphorepropertieskhr((VkExternalSemaphorePropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkexportsemaphorecreateinfokhr((VkExportSemaphoreCreateInfoKHR*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkimportsemaphorewin32handleinfokhr((VkImportSemaphoreWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkexportsemaphorewin32handleinfokhr((VkExportSemaphoreWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ struct_size += vk_size_vkd3d12fencesubmitinfokhr((VkD3D12FenceSubmitInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vksemaphoregetwin32handleinfokhr((VkSemaphoreGetWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: {
+ struct_size += vk_size_vkimportsemaphorefdinfokhr((VkImportSemaphoreFdInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: {
+ struct_size += vk_size_vksemaphoregetfdinfokhr((VkSemaphoreGetFdInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ struct_size += vk_size_vkphysicaldevicepushdescriptorpropertieskhr((VkPhysicalDevicePushDescriptorPropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: {
+ struct_size += vk_size_vkphysicaldevice16bitstoragefeatureskhr((VkPhysicalDevice16BitStorageFeaturesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ struct_size += vk_size_vkpresentregionskhr((VkPresentRegionsKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkdescriptorupdatetemplatecreateinfokhr((VkDescriptorUpdateTemplateCreateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ struct_size += vk_size_vksharedpresentsurfacecapabilitieskhr((VkSharedPresentSurfaceCapabilitiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: {
+ struct_size += vk_size_vkphysicaldeviceexternalfenceinfokhr((VkPhysicalDeviceExternalFenceInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: {
+ struct_size += vk_size_vkexternalfencepropertieskhr((VkExternalFencePropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: {
+ struct_size += vk_size_vkexportfencecreateinfokhr((VkExportFenceCreateInfoKHR*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkimportfencewin32handleinfokhr((VkImportFenceWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkexportfencewin32handleinfokhr((VkExportFenceWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkfencegetwin32handleinfokhr((VkFenceGetWin32HandleInfoKHR*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: {
+ struct_size += vk_size_vkimportfencefdinfokhr((VkImportFenceFdInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: {
+ struct_size += vk_size_vkfencegetfdinfokhr((VkFenceGetFdInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: {
+ struct_size += vk_size_vkphysicaldevicesurfaceinfo2khr((VkPhysicalDeviceSurfaceInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: {
+ struct_size += vk_size_vksurfacecapabilities2khr((VkSurfaceCapabilities2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: {
+ struct_size += vk_size_vksurfaceformat2khr((VkSurfaceFormat2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: {
+ struct_size += vk_size_vkphysicaldevicevariablepointerfeatureskhr((VkPhysicalDeviceVariablePointerFeaturesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: {
+ struct_size += vk_size_vkmemorydedicatedrequirementskhr((VkMemoryDedicatedRequirementsKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: {
+ struct_size += vk_size_vkmemorydedicatedallocateinfokhr((VkMemoryDedicatedAllocateInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: {
+ struct_size += vk_size_vkbuffermemoryrequirementsinfo2khr((VkBufferMemoryRequirementsInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: {
+ struct_size += vk_size_vkimagememoryrequirementsinfo2khr((VkImageMemoryRequirementsInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: {
+ struct_size += vk_size_vkimagesparsememoryrequirementsinfo2khr((VkImageSparseMemoryRequirementsInfo2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: {
+ struct_size += vk_size_vkmemoryrequirements2khr((VkMemoryRequirements2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: {
+ struct_size += vk_size_vksparseimagememoryrequirements2khr((VkSparseImageMemoryRequirements2KHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FUCHSIA_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkimportmemoryfuchsiahandleinfokhr((VkImportMemoryFuchsiaHandleInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_FUCHSIA_HANDLE_PROPERTIES_KHR: {
+ struct_size += vk_size_vkmemoryfuchsiahandlepropertieskhr((VkMemoryFuchsiaHandlePropertiesKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_GET_FUCHSIA_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkmemorygetfuchsiahandleinfokhr((VkMemoryGetFuchsiaHandleInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FUCHSIA_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vkimportsemaphorefuchsiahandleinfokhr((VkImportSemaphoreFuchsiaHandleInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FUCHSIA_HANDLE_INFO_KHR: {
+ struct_size += vk_size_vksemaphoregetfuchsiahandleinfokhr((VkSemaphoreGetFuchsiaHandleInfoKHR*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ struct_size += vk_size_vkdebugreportcallbackcreateinfoext((VkDebugReportCallbackCreateInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ struct_size += vk_size_vkpipelinerasterizationstaterasterizationorderamd((VkPipelineRasterizationStateRasterizationOrderAMD*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: {
+ struct_size += vk_size_vkdebugmarkerobjectnameinfoext((VkDebugMarkerObjectNameInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: {
+ struct_size += vk_size_vkdebugmarkerobjecttaginfoext((VkDebugMarkerObjectTagInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: {
+ struct_size += vk_size_vkdebugmarkermarkerinfoext((VkDebugMarkerMarkerInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkdedicatedallocationimagecreateinfonv((VkDedicatedAllocationImageCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ struct_size += vk_size_vkdedicatedallocationbuffercreateinfonv((VkDedicatedAllocationBufferCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ struct_size += vk_size_vkdedicatedallocationmemoryallocateinfonv((VkDedicatedAllocationMemoryAllocateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ struct_size += vk_size_vktexturelodgatherformatpropertiesamd((VkTextureLODGatherFormatPropertiesAMD*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX: {
+ struct_size += vk_size_vkrenderpassmultiviewcreateinfokhx((VkRenderPassMultiviewCreateInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX: {
+ struct_size += vk_size_vkphysicaldevicemultiviewfeatureskhx((VkPhysicalDeviceMultiviewFeaturesKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX: {
+ struct_size += vk_size_vkphysicaldevicemultiviewpropertieskhx((VkPhysicalDeviceMultiviewPropertiesKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkexternalmemoryimagecreateinfonv((VkExternalMemoryImageCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ struct_size += vk_size_vkexportmemoryallocateinfonv((VkExportMemoryAllocateInfoNV*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ struct_size += vk_size_vkimportmemorywin32handleinfonv((VkImportMemoryWin32HandleInfoNV*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ struct_size += vk_size_vkexportmemorywin32handleinfonv((VkExportMemoryWin32HandleInfoNV*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ struct_size += vk_size_vkwin32keyedmutexacquirereleaseinfonv((VkWin32KeyedMutexAcquireReleaseInfoNV*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_WIN32_KHR
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX: {
+ struct_size += vk_size_vkmemoryallocateflagsinfokhx((VkMemoryAllocateFlagsInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX: {
+ struct_size += vk_size_vkbindbuffermemoryinfokhx((VkBindBufferMemoryInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX: {
+ struct_size += vk_size_vkbindimagememoryinfokhx((VkBindImageMemoryInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX: {
+ struct_size += vk_size_vkdevicegrouprenderpassbegininfokhx((VkDeviceGroupRenderPassBeginInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX: {
+ struct_size += vk_size_vkdevicegroupcommandbufferbegininfokhx((VkDeviceGroupCommandBufferBeginInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX: {
+ struct_size += vk_size_vkdevicegroupsubmitinfokhx((VkDeviceGroupSubmitInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX: {
+ struct_size += vk_size_vkdevicegroupbindsparseinfokhx((VkDeviceGroupBindSparseInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX: {
+ struct_size += vk_size_vkdevicegrouppresentcapabilitieskhx((VkDeviceGroupPresentCapabilitiesKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX: {
+ struct_size += vk_size_vkimageswapchaincreateinfokhx((VkImageSwapchainCreateInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX: {
+ struct_size += vk_size_vkbindimagememoryswapchaininfokhx((VkBindImageMemorySwapchainInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX: {
+ struct_size += vk_size_vkacquirenextimageinfokhx((VkAcquireNextImageInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX: {
+ struct_size += vk_size_vkdevicegrouppresentinfokhx((VkDeviceGroupPresentInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX: {
+ struct_size += vk_size_vkdevicegroupswapchaincreateinfokhx((VkDeviceGroupSwapchainCreateInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ struct_size += vk_size_vkvalidationflagsext((VkValidationFlagsEXT*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_VI_NN
+ case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: {
+ struct_size += vk_size_vkvisurfacecreateinfonn((VkViSurfaceCreateInfoNN*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_VI_NN
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX: {
+ struct_size += vk_size_vkphysicaldevicegrouppropertieskhx((VkPhysicalDeviceGroupPropertiesKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX: {
+ struct_size += vk_size_vkdevicegroupdevicecreateinfokhx((VkDeviceGroupDeviceCreateInfoKHX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX: {
+ struct_size += vk_size_vkdevicegeneratedcommandsfeaturesnvx((VkDeviceGeneratedCommandsFeaturesNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX: {
+ struct_size += vk_size_vkdevicegeneratedcommandslimitsnvx((VkDeviceGeneratedCommandsLimitsNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: {
+ struct_size += vk_size_vkindirectcommandslayoutcreateinfonvx((VkIndirectCommandsLayoutCreateInfoNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX: {
+ struct_size += vk_size_vkcmdprocesscommandsinfonvx((VkCmdProcessCommandsInfoNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: {
+ struct_size += vk_size_vkcmdreservespaceforcommandsinfonvx((VkCmdReserveSpaceForCommandsInfoNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX: {
+ struct_size += vk_size_vkobjecttablecreateinfonvx((VkObjectTableCreateInfoNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkpipelineviewportwscalingstatecreateinfonv((VkPipelineViewportWScalingStateCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: {
+ struct_size += vk_size_vksurfacecapabilities2ext((VkSurfaceCapabilities2EXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: {
+ struct_size += vk_size_vkdisplaypowerinfoext((VkDisplayPowerInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: {
+ struct_size += vk_size_vkdeviceeventinfoext((VkDeviceEventInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: {
+ struct_size += vk_size_vkdisplayeventinfoext((VkDisplayEventInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ struct_size += vk_size_vkswapchaincountercreateinfoext((VkSwapchainCounterCreateInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ struct_size += vk_size_vkpresenttimesinfogoogle((VkPresentTimesInfoGOOGLE*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ struct_size += vk_size_vkphysicaldevicemultiviewperviewattributespropertiesnvx((VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkpipelineviewportswizzlestatecreateinfonv((VkPipelineViewportSwizzleStateCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ struct_size += vk_size_vkphysicaldevicediscardrectanglepropertiesext((VkPhysicalDeviceDiscardRectanglePropertiesEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ struct_size += vk_size_vkpipelinediscardrectanglestatecreateinfoext((VkPipelineDiscardRectangleStateCreateInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: {
+ struct_size += vk_size_vkhdrmetadataext((VkHdrMetadataEXT*)pNext);
+ break;
+ }
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: {
+ struct_size += vk_size_vkiossurfacecreateinfomvk((VkIOSSurfaceCreateInfoMVK*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: {
+ struct_size += vk_size_vkmacossurfacecreateinfomvk((VkMacOSSurfaceCreateInfoMVK*)pNext);
+ break;
+ }
+#endif // VK_USE_PLATFORM_MACOS_MVK
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: {
+ struct_size += vk_size_vksamplerreductionmodecreateinfoext((VkSamplerReductionModeCreateInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: {
+ struct_size += vk_size_vkphysicaldevicesamplerfilterminmaxpropertiesext((VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ struct_size += vk_size_vkphysicaldeviceblendoperationadvancedfeaturesext((VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ struct_size += vk_size_vkphysicaldeviceblendoperationadvancedpropertiesext((VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ struct_size += vk_size_vkpipelinecolorblendadvancedstatecreateinfoext((VkPipelineColorBlendAdvancedStateCreateInfoEXT*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkpipelinecoveragetocolorstatecreateinfonv((VkPipelineCoverageToColorStateCreateInfoNV*)pNext);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ struct_size += vk_size_vkpipelinecoveragemodulationstatecreateinfonv((VkPipelineCoverageModulationStateCreateInfoNV*)pNext);
+ break;
+ }
+ default:
+ assert(0);
+ struct_size += 0;
+ }
+ pNext = (VkApplicationInfo*)pNext->pNext;
+ }
+ return struct_size;
+}
diff --git a/build-fuchsia/generated/include/vk_struct_size_helper.h b/build-fuchsia/generated/include/vk_struct_size_helper.h
new file mode 100644
index 0000000..52e0fb9
--- /dev/null
+++ b/build-fuchsia/generated/include/vk_struct_size_helper.h
@@ -0,0 +1,363 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See helper_file_generator.py for modifications
+
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google 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 <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ *
+ ****************************************************************************/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <vulkan/vulkan.h>
+
+// Function Prototypes
+size_t get_struct_chain_size(const void* struct_ptr);
+size_t vk_size_vkapplicationinfo(const VkApplicationInfo* struct_ptr);
+size_t vk_size_vkinstancecreateinfo(const VkInstanceCreateInfo* struct_ptr);
+size_t vk_size_vkallocationcallbacks(const VkAllocationCallbacks* struct_ptr);
+size_t vk_size_vkphysicaldevicefeatures(const VkPhysicalDeviceFeatures* struct_ptr);
+size_t vk_size_vkformatproperties(const VkFormatProperties* struct_ptr);
+size_t vk_size_vkextent3d(const VkExtent3D* struct_ptr);
+size_t vk_size_vkimageformatproperties(const VkImageFormatProperties* struct_ptr);
+size_t vk_size_vkphysicaldevicelimits(const VkPhysicalDeviceLimits* struct_ptr);
+size_t vk_size_vkphysicaldevicesparseproperties(const VkPhysicalDeviceSparseProperties* struct_ptr);
+size_t vk_size_vkphysicaldeviceproperties(const VkPhysicalDeviceProperties* struct_ptr);
+size_t vk_size_vkqueuefamilyproperties(const VkQueueFamilyProperties* struct_ptr);
+size_t vk_size_vkmemorytype(const VkMemoryType* struct_ptr);
+size_t vk_size_vkmemoryheap(const VkMemoryHeap* struct_ptr);
+size_t vk_size_vkphysicaldevicememoryproperties(const VkPhysicalDeviceMemoryProperties* struct_ptr);
+size_t vk_size_vkdevicequeuecreateinfo(const VkDeviceQueueCreateInfo* struct_ptr);
+size_t vk_size_vkdevicecreateinfo(const VkDeviceCreateInfo* struct_ptr);
+size_t vk_size_vkextensionproperties(const VkExtensionProperties* struct_ptr);
+size_t vk_size_vklayerproperties(const VkLayerProperties* struct_ptr);
+size_t vk_size_vksubmitinfo(const VkSubmitInfo* struct_ptr);
+size_t vk_size_vkmemoryallocateinfo(const VkMemoryAllocateInfo* struct_ptr);
+size_t vk_size_vkmappedmemoryrange(const VkMappedMemoryRange* struct_ptr);
+size_t vk_size_vkmemoryrequirements(const VkMemoryRequirements* struct_ptr);
+size_t vk_size_vksparseimageformatproperties(const VkSparseImageFormatProperties* struct_ptr);
+size_t vk_size_vksparseimagememoryrequirements(const VkSparseImageMemoryRequirements* struct_ptr);
+size_t vk_size_vksparsememorybind(const VkSparseMemoryBind* struct_ptr);
+size_t vk_size_vksparsebuffermemorybindinfo(const VkSparseBufferMemoryBindInfo* struct_ptr);
+size_t vk_size_vksparseimageopaquememorybindinfo(const VkSparseImageOpaqueMemoryBindInfo* struct_ptr);
+size_t vk_size_vkimagesubresource(const VkImageSubresource* struct_ptr);
+size_t vk_size_vkoffset3d(const VkOffset3D* struct_ptr);
+size_t vk_size_vksparseimagememorybind(const VkSparseImageMemoryBind* struct_ptr);
+size_t vk_size_vksparseimagememorybindinfo(const VkSparseImageMemoryBindInfo* struct_ptr);
+size_t vk_size_vkbindsparseinfo(const VkBindSparseInfo* struct_ptr);
+size_t vk_size_vkfencecreateinfo(const VkFenceCreateInfo* struct_ptr);
+size_t vk_size_vksemaphorecreateinfo(const VkSemaphoreCreateInfo* struct_ptr);
+size_t vk_size_vkeventcreateinfo(const VkEventCreateInfo* struct_ptr);
+size_t vk_size_vkquerypoolcreateinfo(const VkQueryPoolCreateInfo* struct_ptr);
+size_t vk_size_vkbuffercreateinfo(const VkBufferCreateInfo* struct_ptr);
+size_t vk_size_vkbufferviewcreateinfo(const VkBufferViewCreateInfo* struct_ptr);
+size_t vk_size_vkimagecreateinfo(const VkImageCreateInfo* struct_ptr);
+size_t vk_size_vksubresourcelayout(const VkSubresourceLayout* struct_ptr);
+size_t vk_size_vkcomponentmapping(const VkComponentMapping* struct_ptr);
+size_t vk_size_vkimagesubresourcerange(const VkImageSubresourceRange* struct_ptr);
+size_t vk_size_vkimageviewcreateinfo(const VkImageViewCreateInfo* struct_ptr);
+size_t vk_size_vkshadermodulecreateinfo(const VkShaderModuleCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinecachecreateinfo(const VkPipelineCacheCreateInfo* struct_ptr);
+size_t vk_size_vkspecializationmapentry(const VkSpecializationMapEntry* struct_ptr);
+size_t vk_size_vkspecializationinfo(const VkSpecializationInfo* struct_ptr);
+size_t vk_size_vkpipelineshaderstagecreateinfo(const VkPipelineShaderStageCreateInfo* struct_ptr);
+size_t vk_size_vkvertexinputbindingdescription(const VkVertexInputBindingDescription* struct_ptr);
+size_t vk_size_vkvertexinputattributedescription(const VkVertexInputAttributeDescription* struct_ptr);
+size_t vk_size_vkpipelinevertexinputstatecreateinfo(const VkPipelineVertexInputStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelineinputassemblystatecreateinfo(const VkPipelineInputAssemblyStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinetessellationstatecreateinfo(const VkPipelineTessellationStateCreateInfo* struct_ptr);
+size_t vk_size_vkviewport(const VkViewport* struct_ptr);
+size_t vk_size_vkoffset2d(const VkOffset2D* struct_ptr);
+size_t vk_size_vkextent2d(const VkExtent2D* struct_ptr);
+size_t vk_size_vkrect2d(const VkRect2D* struct_ptr);
+size_t vk_size_vkpipelineviewportstatecreateinfo(const VkPipelineViewportStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinerasterizationstatecreateinfo(const VkPipelineRasterizationStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinemultisamplestatecreateinfo(const VkPipelineMultisampleStateCreateInfo* struct_ptr);
+size_t vk_size_vkstencilopstate(const VkStencilOpState* struct_ptr);
+size_t vk_size_vkpipelinedepthstencilstatecreateinfo(const VkPipelineDepthStencilStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinecolorblendattachmentstate(const VkPipelineColorBlendAttachmentState* struct_ptr);
+size_t vk_size_vkpipelinecolorblendstatecreateinfo(const VkPipelineColorBlendStateCreateInfo* struct_ptr);
+size_t vk_size_vkpipelinedynamicstatecreateinfo(const VkPipelineDynamicStateCreateInfo* struct_ptr);
+size_t vk_size_vkgraphicspipelinecreateinfo(const VkGraphicsPipelineCreateInfo* struct_ptr);
+size_t vk_size_vkcomputepipelinecreateinfo(const VkComputePipelineCreateInfo* struct_ptr);
+size_t vk_size_vkpushconstantrange(const VkPushConstantRange* struct_ptr);
+size_t vk_size_vkpipelinelayoutcreateinfo(const VkPipelineLayoutCreateInfo* struct_ptr);
+size_t vk_size_vksamplercreateinfo(const VkSamplerCreateInfo* struct_ptr);
+size_t vk_size_vkdescriptorsetlayoutbinding(const VkDescriptorSetLayoutBinding* struct_ptr);
+size_t vk_size_vkdescriptorsetlayoutcreateinfo(const VkDescriptorSetLayoutCreateInfo* struct_ptr);
+size_t vk_size_vkdescriptorpoolsize(const VkDescriptorPoolSize* struct_ptr);
+size_t vk_size_vkdescriptorpoolcreateinfo(const VkDescriptorPoolCreateInfo* struct_ptr);
+size_t vk_size_vkdescriptorsetallocateinfo(const VkDescriptorSetAllocateInfo* struct_ptr);
+size_t vk_size_vkdescriptorimageinfo(const VkDescriptorImageInfo* struct_ptr);
+size_t vk_size_vkdescriptorbufferinfo(const VkDescriptorBufferInfo* struct_ptr);
+size_t vk_size_vkwritedescriptorset(const VkWriteDescriptorSet* struct_ptr);
+size_t vk_size_vkcopydescriptorset(const VkCopyDescriptorSet* struct_ptr);
+size_t vk_size_vkframebuffercreateinfo(const VkFramebufferCreateInfo* struct_ptr);
+size_t vk_size_vkattachmentdescription(const VkAttachmentDescription* struct_ptr);
+size_t vk_size_vkattachmentreference(const VkAttachmentReference* struct_ptr);
+size_t vk_size_vksubpassdescription(const VkSubpassDescription* struct_ptr);
+size_t vk_size_vksubpassdependency(const VkSubpassDependency* struct_ptr);
+size_t vk_size_vkrenderpasscreateinfo(const VkRenderPassCreateInfo* struct_ptr);
+size_t vk_size_vkcommandpoolcreateinfo(const VkCommandPoolCreateInfo* struct_ptr);
+size_t vk_size_vkcommandbufferallocateinfo(const VkCommandBufferAllocateInfo* struct_ptr);
+size_t vk_size_vkcommandbufferinheritanceinfo(const VkCommandBufferInheritanceInfo* struct_ptr);
+size_t vk_size_vkcommandbufferbegininfo(const VkCommandBufferBeginInfo* struct_ptr);
+size_t vk_size_vkbuffercopy(const VkBufferCopy* struct_ptr);
+size_t vk_size_vkimagesubresourcelayers(const VkImageSubresourceLayers* struct_ptr);
+size_t vk_size_vkimagecopy(const VkImageCopy* struct_ptr);
+size_t vk_size_vkimageblit(const VkImageBlit* struct_ptr);
+size_t vk_size_vkbufferimagecopy(const VkBufferImageCopy* struct_ptr);
+size_t vk_size_vkclearcolorvalue(const VkClearColorValue* struct_ptr);
+size_t vk_size_vkcleardepthstencilvalue(const VkClearDepthStencilValue* struct_ptr);
+size_t vk_size_vkclearvalue(const VkClearValue* struct_ptr);
+size_t vk_size_vkclearattachment(const VkClearAttachment* struct_ptr);
+size_t vk_size_vkclearrect(const VkClearRect* struct_ptr);
+size_t vk_size_vkimageresolve(const VkImageResolve* struct_ptr);
+size_t vk_size_vkmemorybarrier(const VkMemoryBarrier* struct_ptr);
+size_t vk_size_vkbuffermemorybarrier(const VkBufferMemoryBarrier* struct_ptr);
+size_t vk_size_vkimagememorybarrier(const VkImageMemoryBarrier* struct_ptr);
+size_t vk_size_vkrenderpassbegininfo(const VkRenderPassBeginInfo* struct_ptr);
+size_t vk_size_vkdispatchindirectcommand(const VkDispatchIndirectCommand* struct_ptr);
+size_t vk_size_vkdrawindexedindirectcommand(const VkDrawIndexedIndirectCommand* struct_ptr);
+size_t vk_size_vkdrawindirectcommand(const VkDrawIndirectCommand* struct_ptr);
+size_t vk_size_vksurfacecapabilitieskhr(const VkSurfaceCapabilitiesKHR* struct_ptr);
+size_t vk_size_vksurfaceformatkhr(const VkSurfaceFormatKHR* struct_ptr);
+size_t vk_size_vkswapchaincreateinfokhr(const VkSwapchainCreateInfoKHR* struct_ptr);
+size_t vk_size_vkpresentinfokhr(const VkPresentInfoKHR* struct_ptr);
+size_t vk_size_vkdisplaypropertieskhr(const VkDisplayPropertiesKHR* struct_ptr);
+size_t vk_size_vkdisplaymodeparameterskhr(const VkDisplayModeParametersKHR* struct_ptr);
+size_t vk_size_vkdisplaymodepropertieskhr(const VkDisplayModePropertiesKHR* struct_ptr);
+size_t vk_size_vkdisplaymodecreateinfokhr(const VkDisplayModeCreateInfoKHR* struct_ptr);
+size_t vk_size_vkdisplayplanecapabilitieskhr(const VkDisplayPlaneCapabilitiesKHR* struct_ptr);
+size_t vk_size_vkdisplayplanepropertieskhr(const VkDisplayPlanePropertiesKHR* struct_ptr);
+size_t vk_size_vkdisplaysurfacecreateinfokhr(const VkDisplaySurfaceCreateInfoKHR* struct_ptr);
+size_t vk_size_vkdisplaypresentinfokhr(const VkDisplayPresentInfoKHR* struct_ptr);
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+size_t vk_size_vkxlibsurfacecreateinfokhr(const VkXlibSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+size_t vk_size_vkxcbsurfacecreateinfokhr(const VkXcbSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+size_t vk_size_vkwaylandsurfacecreateinfokhr(const VkWaylandSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+size_t vk_size_vkmirsurfacecreateinfokhr(const VkMirSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+size_t vk_size_vkandroidsurfacecreateinfokhr(const VkAndroidSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32surfacecreateinfokhr(const VkWin32SurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_MAGMA_KHR
+size_t vk_size_vkmagmasurfacecreateinfokhr(const VkMagmaSurfaceCreateInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_MAGMA_KHR
+size_t vk_size_vkphysicaldevicefeatures2khr(const VkPhysicalDeviceFeatures2KHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceproperties2khr(const VkPhysicalDeviceProperties2KHR* struct_ptr);
+size_t vk_size_vkformatproperties2khr(const VkFormatProperties2KHR* struct_ptr);
+size_t vk_size_vkimageformatproperties2khr(const VkImageFormatProperties2KHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceimageformatinfo2khr(const VkPhysicalDeviceImageFormatInfo2KHR* struct_ptr);
+size_t vk_size_vkqueuefamilyproperties2khr(const VkQueueFamilyProperties2KHR* struct_ptr);
+size_t vk_size_vkphysicaldevicememoryproperties2khr(const VkPhysicalDeviceMemoryProperties2KHR* struct_ptr);
+size_t vk_size_vksparseimageformatproperties2khr(const VkSparseImageFormatProperties2KHR* struct_ptr);
+size_t vk_size_vkphysicaldevicesparseimageformatinfo2khr(const VkPhysicalDeviceSparseImageFormatInfo2KHR* struct_ptr);
+size_t vk_size_vkexternalmemorypropertieskhr(const VkExternalMemoryPropertiesKHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceexternalimageformatinfokhr(const VkPhysicalDeviceExternalImageFormatInfoKHR* struct_ptr);
+size_t vk_size_vkexternalimageformatpropertieskhr(const VkExternalImageFormatPropertiesKHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceexternalbufferinfokhr(const VkPhysicalDeviceExternalBufferInfoKHR* struct_ptr);
+size_t vk_size_vkexternalbufferpropertieskhr(const VkExternalBufferPropertiesKHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceidpropertieskhr(const VkPhysicalDeviceIDPropertiesKHR* struct_ptr);
+size_t vk_size_vkexternalmemoryimagecreateinfokhr(const VkExternalMemoryImageCreateInfoKHR* struct_ptr);
+size_t vk_size_vkexternalmemorybuffercreateinfokhr(const VkExternalMemoryBufferCreateInfoKHR* struct_ptr);
+size_t vk_size_vkexportmemoryallocateinfokhr(const VkExportMemoryAllocateInfoKHR* struct_ptr);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportmemorywin32handleinfokhr(const VkImportMemoryWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportmemorywin32handleinfokhr(const VkExportMemoryWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkmemorywin32handlepropertieskhr(const VkMemoryWin32HandlePropertiesKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkmemorygetwin32handleinfokhr(const VkMemoryGetWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportmemoryfdinfokhr(const VkImportMemoryFdInfoKHR* struct_ptr);
+size_t vk_size_vkmemoryfdpropertieskhr(const VkMemoryFdPropertiesKHR* struct_ptr);
+size_t vk_size_vkmemorygetfdinfokhr(const VkMemoryGetFdInfoKHR* struct_ptr);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32keyedmutexacquirereleaseinfokhr(const VkWin32KeyedMutexAcquireReleaseInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkphysicaldeviceexternalsemaphoreinfokhr(const VkPhysicalDeviceExternalSemaphoreInfoKHR* struct_ptr);
+size_t vk_size_vkexternalsemaphorepropertieskhr(const VkExternalSemaphorePropertiesKHR* struct_ptr);
+size_t vk_size_vkexportsemaphorecreateinfokhr(const VkExportSemaphoreCreateInfoKHR* struct_ptr);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportsemaphorewin32handleinfokhr(const VkImportSemaphoreWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportsemaphorewin32handleinfokhr(const VkExportSemaphoreWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkd3d12fencesubmitinfokhr(const VkD3D12FenceSubmitInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vksemaphoregetwin32handleinfokhr(const VkSemaphoreGetWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportsemaphorefdinfokhr(const VkImportSemaphoreFdInfoKHR* struct_ptr);
+size_t vk_size_vksemaphoregetfdinfokhr(const VkSemaphoreGetFdInfoKHR* struct_ptr);
+size_t vk_size_vkphysicaldevicepushdescriptorpropertieskhr(const VkPhysicalDevicePushDescriptorPropertiesKHR* struct_ptr);
+size_t vk_size_vkphysicaldevice16bitstoragefeatureskhr(const VkPhysicalDevice16BitStorageFeaturesKHR* struct_ptr);
+size_t vk_size_vkrectlayerkhr(const VkRectLayerKHR* struct_ptr);
+size_t vk_size_vkpresentregionkhr(const VkPresentRegionKHR* struct_ptr);
+size_t vk_size_vkpresentregionskhr(const VkPresentRegionsKHR* struct_ptr);
+size_t vk_size_vkdescriptorupdatetemplateentrykhr(const VkDescriptorUpdateTemplateEntryKHR* struct_ptr);
+size_t vk_size_vkdescriptorupdatetemplatecreateinfokhr(const VkDescriptorUpdateTemplateCreateInfoKHR* struct_ptr);
+size_t vk_size_vksharedpresentsurfacecapabilitieskhr(const VkSharedPresentSurfaceCapabilitiesKHR* struct_ptr);
+size_t vk_size_vkphysicaldeviceexternalfenceinfokhr(const VkPhysicalDeviceExternalFenceInfoKHR* struct_ptr);
+size_t vk_size_vkexternalfencepropertieskhr(const VkExternalFencePropertiesKHR* struct_ptr);
+size_t vk_size_vkexportfencecreateinfokhr(const VkExportFenceCreateInfoKHR* struct_ptr);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportfencewin32handleinfokhr(const VkImportFenceWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportfencewin32handleinfokhr(const VkExportFenceWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkfencegetwin32handleinfokhr(const VkFenceGetWin32HandleInfoKHR* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportfencefdinfokhr(const VkImportFenceFdInfoKHR* struct_ptr);
+size_t vk_size_vkfencegetfdinfokhr(const VkFenceGetFdInfoKHR* struct_ptr);
+size_t vk_size_vkphysicaldevicesurfaceinfo2khr(const VkPhysicalDeviceSurfaceInfo2KHR* struct_ptr);
+size_t vk_size_vksurfacecapabilities2khr(const VkSurfaceCapabilities2KHR* struct_ptr);
+size_t vk_size_vksurfaceformat2khr(const VkSurfaceFormat2KHR* struct_ptr);
+size_t vk_size_vkphysicaldevicevariablepointerfeatureskhr(const VkPhysicalDeviceVariablePointerFeaturesKHR* struct_ptr);
+size_t vk_size_vkmemorydedicatedrequirementskhr(const VkMemoryDedicatedRequirementsKHR* struct_ptr);
+size_t vk_size_vkmemorydedicatedallocateinfokhr(const VkMemoryDedicatedAllocateInfoKHR* struct_ptr);
+size_t vk_size_vkbuffermemoryrequirementsinfo2khr(const VkBufferMemoryRequirementsInfo2KHR* struct_ptr);
+size_t vk_size_vkimagememoryrequirementsinfo2khr(const VkImageMemoryRequirementsInfo2KHR* struct_ptr);
+size_t vk_size_vkimagesparsememoryrequirementsinfo2khr(const VkImageSparseMemoryRequirementsInfo2KHR* struct_ptr);
+size_t vk_size_vkmemoryrequirements2khr(const VkMemoryRequirements2KHR* struct_ptr);
+size_t vk_size_vksparseimagememoryrequirements2khr(const VkSparseImageMemoryRequirements2KHR* struct_ptr);
+size_t vk_size_vkimportmemoryfuchsiahandleinfokhr(const VkImportMemoryFuchsiaHandleInfoKHR* struct_ptr);
+size_t vk_size_vkmemoryfuchsiahandlepropertieskhr(const VkMemoryFuchsiaHandlePropertiesKHR* struct_ptr);
+size_t vk_size_vkmemorygetfuchsiahandleinfokhr(const VkMemoryGetFuchsiaHandleInfoKHR* struct_ptr);
+size_t vk_size_vkimportsemaphorefuchsiahandleinfokhr(const VkImportSemaphoreFuchsiaHandleInfoKHR* struct_ptr);
+size_t vk_size_vksemaphoregetfuchsiahandleinfokhr(const VkSemaphoreGetFuchsiaHandleInfoKHR* struct_ptr);
+size_t vk_size_vkdebugreportcallbackcreateinfoext(const VkDebugReportCallbackCreateInfoEXT* struct_ptr);
+size_t vk_size_vkpipelinerasterizationstaterasterizationorderamd(const VkPipelineRasterizationStateRasterizationOrderAMD* struct_ptr);
+size_t vk_size_vkdebugmarkerobjectnameinfoext(const VkDebugMarkerObjectNameInfoEXT* struct_ptr);
+size_t vk_size_vkdebugmarkerobjecttaginfoext(const VkDebugMarkerObjectTagInfoEXT* struct_ptr);
+size_t vk_size_vkdebugmarkermarkerinfoext(const VkDebugMarkerMarkerInfoEXT* struct_ptr);
+size_t vk_size_vkdedicatedallocationimagecreateinfonv(const VkDedicatedAllocationImageCreateInfoNV* struct_ptr);
+size_t vk_size_vkdedicatedallocationbuffercreateinfonv(const VkDedicatedAllocationBufferCreateInfoNV* struct_ptr);
+size_t vk_size_vkdedicatedallocationmemoryallocateinfonv(const VkDedicatedAllocationMemoryAllocateInfoNV* struct_ptr);
+size_t vk_size_vktexturelodgatherformatpropertiesamd(const VkTextureLODGatherFormatPropertiesAMD* struct_ptr);
+size_t vk_size_vkrenderpassmultiviewcreateinfokhx(const VkRenderPassMultiviewCreateInfoKHX* struct_ptr);
+size_t vk_size_vkphysicaldevicemultiviewfeatureskhx(const VkPhysicalDeviceMultiviewFeaturesKHX* struct_ptr);
+size_t vk_size_vkphysicaldevicemultiviewpropertieskhx(const VkPhysicalDeviceMultiviewPropertiesKHX* struct_ptr);
+size_t vk_size_vkexternalimageformatpropertiesnv(const VkExternalImageFormatPropertiesNV* struct_ptr);
+size_t vk_size_vkexternalmemoryimagecreateinfonv(const VkExternalMemoryImageCreateInfoNV* struct_ptr);
+size_t vk_size_vkexportmemoryallocateinfonv(const VkExportMemoryAllocateInfoNV* struct_ptr);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkimportmemorywin32handleinfonv(const VkImportMemoryWin32HandleInfoNV* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkexportmemorywin32handleinfonv(const VkExportMemoryWin32HandleInfoNV* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkwin32keyedmutexacquirereleaseinfonv(const VkWin32KeyedMutexAcquireReleaseInfoNV* struct_ptr);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+size_t vk_size_vkmemoryallocateflagsinfokhx(const VkMemoryAllocateFlagsInfoKHX* struct_ptr);
+size_t vk_size_vkbindbuffermemoryinfokhx(const VkBindBufferMemoryInfoKHX* struct_ptr);
+size_t vk_size_vkbindimagememoryinfokhx(const VkBindImageMemoryInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegrouprenderpassbegininfokhx(const VkDeviceGroupRenderPassBeginInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegroupcommandbufferbegininfokhx(const VkDeviceGroupCommandBufferBeginInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegroupsubmitinfokhx(const VkDeviceGroupSubmitInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegroupbindsparseinfokhx(const VkDeviceGroupBindSparseInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegrouppresentcapabilitieskhx(const VkDeviceGroupPresentCapabilitiesKHX* struct_ptr);
+size_t vk_size_vkimageswapchaincreateinfokhx(const VkImageSwapchainCreateInfoKHX* struct_ptr);
+size_t vk_size_vkbindimagememoryswapchaininfokhx(const VkBindImageMemorySwapchainInfoKHX* struct_ptr);
+size_t vk_size_vkacquirenextimageinfokhx(const VkAcquireNextImageInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegrouppresentinfokhx(const VkDeviceGroupPresentInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegroupswapchaincreateinfokhx(const VkDeviceGroupSwapchainCreateInfoKHX* struct_ptr);
+size_t vk_size_vkvalidationflagsext(const VkValidationFlagsEXT* struct_ptr);
+#ifdef VK_USE_PLATFORM_VI_NN
+size_t vk_size_vkvisurfacecreateinfonn(const VkViSurfaceCreateInfoNN* struct_ptr);
+#endif // VK_USE_PLATFORM_VI_NN
+size_t vk_size_vkphysicaldevicegrouppropertieskhx(const VkPhysicalDeviceGroupPropertiesKHX* struct_ptr);
+size_t vk_size_vkdevicegroupdevicecreateinfokhx(const VkDeviceGroupDeviceCreateInfoKHX* struct_ptr);
+size_t vk_size_vkdevicegeneratedcommandsfeaturesnvx(const VkDeviceGeneratedCommandsFeaturesNVX* struct_ptr);
+size_t vk_size_vkdevicegeneratedcommandslimitsnvx(const VkDeviceGeneratedCommandsLimitsNVX* struct_ptr);
+size_t vk_size_vkindirectcommandstokennvx(const VkIndirectCommandsTokenNVX* struct_ptr);
+size_t vk_size_vkindirectcommandslayouttokennvx(const VkIndirectCommandsLayoutTokenNVX* struct_ptr);
+size_t vk_size_vkindirectcommandslayoutcreateinfonvx(const VkIndirectCommandsLayoutCreateInfoNVX* struct_ptr);
+size_t vk_size_vkcmdprocesscommandsinfonvx(const VkCmdProcessCommandsInfoNVX* struct_ptr);
+size_t vk_size_vkcmdreservespaceforcommandsinfonvx(const VkCmdReserveSpaceForCommandsInfoNVX* struct_ptr);
+size_t vk_size_vkobjecttablecreateinfonvx(const VkObjectTableCreateInfoNVX* struct_ptr);
+size_t vk_size_vkobjecttableentrynvx(const VkObjectTableEntryNVX* struct_ptr);
+size_t vk_size_vkobjecttablepipelineentrynvx(const VkObjectTablePipelineEntryNVX* struct_ptr);
+size_t vk_size_vkobjecttabledescriptorsetentrynvx(const VkObjectTableDescriptorSetEntryNVX* struct_ptr);
+size_t vk_size_vkobjecttablevertexbufferentrynvx(const VkObjectTableVertexBufferEntryNVX* struct_ptr);
+size_t vk_size_vkobjecttableindexbufferentrynvx(const VkObjectTableIndexBufferEntryNVX* struct_ptr);
+size_t vk_size_vkobjecttablepushconstantentrynvx(const VkObjectTablePushConstantEntryNVX* struct_ptr);
+size_t vk_size_vkviewportwscalingnv(const VkViewportWScalingNV* struct_ptr);
+size_t vk_size_vkpipelineviewportwscalingstatecreateinfonv(const VkPipelineViewportWScalingStateCreateInfoNV* struct_ptr);
+size_t vk_size_vksurfacecapabilities2ext(const VkSurfaceCapabilities2EXT* struct_ptr);
+size_t vk_size_vkdisplaypowerinfoext(const VkDisplayPowerInfoEXT* struct_ptr);
+size_t vk_size_vkdeviceeventinfoext(const VkDeviceEventInfoEXT* struct_ptr);
+size_t vk_size_vkdisplayeventinfoext(const VkDisplayEventInfoEXT* struct_ptr);
+size_t vk_size_vkswapchaincountercreateinfoext(const VkSwapchainCounterCreateInfoEXT* struct_ptr);
+size_t vk_size_vkrefreshcycledurationgoogle(const VkRefreshCycleDurationGOOGLE* struct_ptr);
+size_t vk_size_vkpastpresentationtiminggoogle(const VkPastPresentationTimingGOOGLE* struct_ptr);
+size_t vk_size_vkpresenttimegoogle(const VkPresentTimeGOOGLE* struct_ptr);
+size_t vk_size_vkpresenttimesinfogoogle(const VkPresentTimesInfoGOOGLE* struct_ptr);
+size_t vk_size_vkphysicaldevicemultiviewperviewattributespropertiesnvx(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* struct_ptr);
+size_t vk_size_vkviewportswizzlenv(const VkViewportSwizzleNV* struct_ptr);
+size_t vk_size_vkpipelineviewportswizzlestatecreateinfonv(const VkPipelineViewportSwizzleStateCreateInfoNV* struct_ptr);
+size_t vk_size_vkphysicaldevicediscardrectanglepropertiesext(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* struct_ptr);
+size_t vk_size_vkpipelinediscardrectanglestatecreateinfoext(const VkPipelineDiscardRectangleStateCreateInfoEXT* struct_ptr);
+size_t vk_size_vkxycolorext(const VkXYColorEXT* struct_ptr);
+size_t vk_size_vkhdrmetadataext(const VkHdrMetadataEXT* struct_ptr);
+#ifdef VK_USE_PLATFORM_IOS_MVK
+size_t vk_size_vkiossurfacecreateinfomvk(const VkIOSSurfaceCreateInfoMVK* struct_ptr);
+#endif // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+size_t vk_size_vkmacossurfacecreateinfomvk(const VkMacOSSurfaceCreateInfoMVK* struct_ptr);
+#endif // VK_USE_PLATFORM_MACOS_MVK
+size_t vk_size_vksamplerreductionmodecreateinfoext(const VkSamplerReductionModeCreateInfoEXT* struct_ptr);
+size_t vk_size_vkphysicaldevicesamplerfilterminmaxpropertiesext(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* struct_ptr);
+size_t vk_size_vkphysicaldeviceblendoperationadvancedfeaturesext(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* struct_ptr);
+size_t vk_size_vkphysicaldeviceblendoperationadvancedpropertiesext(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* struct_ptr);
+size_t vk_size_vkpipelinecolorblendadvancedstatecreateinfoext(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* struct_ptr);
+size_t vk_size_vkpipelinecoveragetocolorstatecreateinfonv(const VkPipelineCoverageToColorStateCreateInfoNV* struct_ptr);
+size_t vk_size_vkpipelinecoveragemodulationstatecreateinfonv(const VkPipelineCoverageModulationStateCreateInfoNV* struct_ptr);
+#ifdef __cplusplus
+}
+#endif
diff --git a/loader/BUILD.gn b/loader/BUILD.gn
index 28ef924..78c5111 100644
--- a/loader/BUILD.gn
+++ b/loader/BUILD.gn
@@ -23,7 +23,10 @@
# The Vulkan loader is named libvulkan
output_name = "vulkan"
- configs += [ "../:vulkan_build_config" ]
+ configs += [
+ "../:vulkan_build_config",
+ "../:include_extra_vulkan_headers",
+ ]
include_dirs = [ "." ]
@@ -33,8 +36,6 @@
"-DDATADIR=\"/usr/share\"",
]
- deps = [ "../:extra_vulkan_headers", "../:generate_extra_vulkan_headers" ]
-
sources = [
"cJSON.c",
"debug_report.c",
