From a6a44aa0ca798fc725be7075fb1c06d3fd7aa1f4 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 12:04:00 +0200 Subject: [PATCH 01/17] Start adding a validation tool for GPU key invariance. --- cli/CMakeLists.txt | 6 + cli/fossilize_validate_cache_roundtrip.cpp | 627 +++++++++++++++++++++ 2 files changed, 633 insertions(+) create mode 100644 cli/fossilize_validate_cache_roundtrip.cpp diff --git a/cli/CMakeLists.txt b/cli/CMakeLists.txt index 7867c7c0..37bcdf99 100644 --- a/cli/CMakeLists.txt +++ b/cli/CMakeLists.txt @@ -65,3 +65,9 @@ add_fossilize_cli(fossilize-opt fossilize_opt.cpp) target_link_libraries(fossilize-opt SPIRV-Tools-opt) add_fossilize_cli(fossilize-synth fossilize_synth.cpp) target_link_libraries(fossilize-synth spirv-cross-c) + +if ((NOT WIN32) AND (NOT ANDROID)) + # For now, this tools is only relevant for Mesa CI purposes. + # Can be ported over as needed. + add_fossilize_cli(fossilize-validate-cache-roundtrip fossilize_validate_cache_roundtrip.cpp) +endif() diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp new file mode 100644 index 00000000..78c5b007 --- /dev/null +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -0,0 +1,627 @@ +/* Copyright (c) 2026 Hans-Kristian Arntzen for Valve Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "volk.h" +#include "cli_parser.hpp" +#include "fossilize.hpp" +#include "fossilize_db.hpp" +#include "logging.hpp" +#include +#include +#include +#include +#include +#include + +using namespace Fossilize; + +static void print_help() +{ + LOGI("fossilize-validate-cache-roundtrip [--help] [--fossilize-replay ]\n"); +} + +static constexpr VkApplicationInfo app_info = { + VK_STRUCTURE_TYPE_APPLICATION_INFO, nullptr, + "fossilize-validate-cache-roundtrip", 1, + "fossilize-cli", 1, + VK_API_VERSION_1_1, +}; + +// Basic idea, with a custom dumb device with minimal features enables, study if the full replayer roundtrips properly. +static VkInstance create_instance() +{ + if (volkInitialize() != VK_SUCCESS) + return VK_NULL_HANDLE; + + uint32_t instance_version; + if (vkEnumerateInstanceVersion(&instance_version) != VK_SUCCESS || instance_version < VK_API_VERSION_1_1) + return VK_NULL_HANDLE; + + VkInstanceCreateInfo instance_info = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }; + instance_info.pApplicationInfo = &app_info; + + VkInstance instance; + if (vkCreateInstance(&instance_info, nullptr, &instance) != VK_SUCCESS) + { + LOGE("Failed to create instance.\n"); + return VK_NULL_HANDLE; + } + + volkLoadInstance(instance); + + return instance; +} + +static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures &features) +{ + // Just pick the first GPU. Could be improved if needed. + uint32_t count = 1; + VkPhysicalDevice gpu; + if (vkEnumeratePhysicalDevices(instance, &count, &gpu) < 0) + return VK_NULL_HANDLE; + + // We don't care about Vulkan 1.0 devices. + VkPhysicalDeviceProperties props = {}; + vkGetPhysicalDeviceProperties(gpu, &props); + if (props.apiVersion < VK_API_VERSION_1_1) + return VK_NULL_HANDLE; + + VkDeviceCreateInfo device_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; + VkDeviceQueueCreateInfo queue_create_info = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }; + const float queue_prio = 1.0f; + queue_create_info.queueCount = 1; + // Don't care what this queue does. + queue_create_info.queueFamilyIndex = 0; + queue_create_info.pQueuePriorities = &queue_prio; + device_info.pQueueCreateInfos = &queue_create_info; + device_info.pEnabledFeatures = &features; + + VkDevice device; + if (vkCreateDevice(gpu, &device_info, nullptr, &device) != VK_SUCCESS) + return VK_NULL_HANDLE; + volkLoadDevice(device); + + return device; +} + +static VkPipelineCache create_pipeline_cache(VkDevice device) +{ + VkPipelineCacheCreateInfo create_info = { VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO }; + VkPipelineCache cache; + if (vkCreatePipelineCache(device, &create_info, nullptr, &cache) != VK_SUCCESS) + return VK_NULL_HANDLE; + return cache; +} + +static const uint32_t vert_spirv[] = { + 0x07230203, 0x00010000, 0x000d000b, 0x00000029, + 0x00000000, 0x00020011, 0x00000001, 0x0006000b, + 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, + 0x00000000, 0x0003000e, 0x00000000, 0x00000001, + 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x00000008, 0x00000016, 0x00030003, + 0x00000002, 0x000001c2, 0x000a0004, 0x475f4c47, + 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, + 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, + 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, + 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, + 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, + 0x00060005, 0x00000008, 0x565f6c67, 0x65747265, + 0x646e4978, 0x00007865, 0x00060005, 0x00000014, + 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, + 0x00060006, 0x00000014, 0x00000000, 0x505f6c67, + 0x7469736f, 0x006e6f69, 0x00070006, 0x00000014, + 0x00000001, 0x505f6c67, 0x746e696f, 0x657a6953, + 0x00000000, 0x00070006, 0x00000014, 0x00000002, + 0x435f6c67, 0x4470696c, 0x61747369, 0x0065636e, + 0x00070006, 0x00000014, 0x00000003, 0x435f6c67, + 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, + 0x00000016, 0x00000000, 0x00040047, 0x00000008, + 0x0000000b, 0x0000002a, 0x00030047, 0x00000014, + 0x00000002, 0x00050048, 0x00000014, 0x00000000, + 0x0000000b, 0x00000000, 0x00050048, 0x00000014, + 0x00000001, 0x0000000b, 0x00000001, 0x00050048, + 0x00000014, 0x00000002, 0x0000000b, 0x00000003, + 0x00050048, 0x00000014, 0x00000003, 0x0000000b, + 0x00000004, 0x00020013, 0x00000002, 0x00030021, + 0x00000003, 0x00000002, 0x00040015, 0x00000006, + 0x00000020, 0x00000001, 0x00040020, 0x00000007, + 0x00000001, 0x00000006, 0x0004003b, 0x00000007, + 0x00000008, 0x00000001, 0x0004002b, 0x00000006, + 0x0000000a, 0x00000000, 0x00020014, 0x0000000b, + 0x00030016, 0x0000000f, 0x00000020, 0x00040017, + 0x00000010, 0x0000000f, 0x00000004, 0x00040015, + 0x00000011, 0x00000020, 0x00000000, 0x0004002b, + 0x00000011, 0x00000012, 0x00000001, 0x0004001c, + 0x00000013, 0x0000000f, 0x00000012, 0x0006001e, + 0x00000014, 0x00000010, 0x0000000f, 0x00000013, + 0x00000013, 0x00040020, 0x00000015, 0x00000003, + 0x00000014, 0x0004003b, 0x00000015, 0x00000016, + 0x00000003, 0x0004002b, 0x0000000f, 0x00000017, + 0xbf800000, 0x0004002b, 0x0000000f, 0x00000018, + 0x00000000, 0x0004002b, 0x0000000f, 0x00000019, + 0x3f800000, 0x0007002c, 0x00000010, 0x0000001a, + 0x00000017, 0x00000017, 0x00000018, 0x00000019, + 0x00040020, 0x0000001b, 0x00000003, 0x00000010, + 0x0004002b, 0x00000006, 0x0000001f, 0x00000001, + 0x0004002b, 0x0000000f, 0x00000023, 0x40400000, + 0x0007002c, 0x00000010, 0x00000024, 0x00000017, + 0x00000023, 0x00000018, 0x00000019, 0x0007002c, + 0x00000010, 0x00000027, 0x00000023, 0x00000019, + 0x00000018, 0x00000019, 0x00050036, 0x00000002, + 0x00000004, 0x00000000, 0x00000003, 0x000200f8, + 0x00000005, 0x0004003d, 0x00000006, 0x00000009, + 0x00000008, 0x000500aa, 0x0000000b, 0x0000000c, + 0x00000009, 0x0000000a, 0x000300f7, 0x0000000e, + 0x00000000, 0x000400fa, 0x0000000c, 0x0000000d, + 0x0000001d, 0x000200f8, 0x0000000d, 0x00050041, + 0x0000001b, 0x0000001c, 0x00000016, 0x0000000a, + 0x0003003e, 0x0000001c, 0x0000001a, 0x000200f9, + 0x0000000e, 0x000200f8, 0x0000001d, 0x0004003d, + 0x00000006, 0x0000001e, 0x00000008, 0x000500aa, + 0x0000000b, 0x00000020, 0x0000001e, 0x0000001f, + 0x000300f7, 0x00000022, 0x00000000, 0x000400fa, + 0x00000020, 0x00000021, 0x00000026, 0x000200f8, + 0x00000021, 0x00050041, 0x0000001b, 0x00000025, + 0x00000016, 0x0000000a, 0x0003003e, 0x00000025, + 0x00000024, 0x000200f9, 0x00000022, 0x000200f8, + 0x00000026, 0x00050041, 0x0000001b, 0x00000028, + 0x00000016, 0x0000000a, 0x0003003e, 0x00000028, + 0x00000027, 0x000200f9, 0x00000022, 0x000200f8, + 0x00000022, 0x000200f9, 0x0000000e, 0x000200f8, + 0x0000000e, 0x000100fd, 0x00010038, +}; + +static const uint32_t frag_spirv[] = { + 0x07230203, 0x00010000, 0x000d000b, 0x00000012, + 0x00000000, 0x00020011, 0x00000001, 0x0006000b, + 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, + 0x00000000, 0x0003000e, 0x00000000, 0x00000001, + 0x0006000f, 0x00000004, 0x00000004, 0x6e69616d, + 0x00000000, 0x00000009, 0x00030010, 0x00000004, + 0x00000007, 0x00030003, 0x00000002, 0x000001c2, + 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, + 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, + 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, + 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, + 0x74636572, 0x00657669, 0x00040005, 0x00000004, + 0x6e69616d, 0x00000000, 0x00050005, 0x00000009, + 0x67617246, 0x6f6c6f43, 0x00000072, 0x00050005, + 0x0000000a, 0x69676552, 0x72657473, 0x00000073, + 0x00050006, 0x0000000a, 0x00000000, 0x6f6c6f63, + 0x00000072, 0x00030005, 0x0000000c, 0x00000000, + 0x00040047, 0x00000009, 0x0000001e, 0x00000000, + 0x00030047, 0x0000000a, 0x00000002, 0x00050048, + 0x0000000a, 0x00000000, 0x00000023, 0x00000000, + 0x00020013, 0x00000002, 0x00030021, 0x00000003, + 0x00000002, 0x00030016, 0x00000006, 0x00000020, + 0x00040017, 0x00000007, 0x00000006, 0x00000004, + 0x00040020, 0x00000008, 0x00000003, 0x00000007, + 0x0004003b, 0x00000008, 0x00000009, 0x00000003, + 0x0003001e, 0x0000000a, 0x00000007, 0x00040020, + 0x0000000b, 0x00000009, 0x0000000a, 0x0004003b, + 0x0000000b, 0x0000000c, 0x00000009, 0x00040015, + 0x0000000d, 0x00000020, 0x00000001, 0x0004002b, + 0x0000000d, 0x0000000e, 0x00000000, 0x00040020, + 0x0000000f, 0x00000009, 0x00000007, 0x00050036, + 0x00000002, 0x00000004, 0x00000000, 0x00000003, + 0x000200f8, 0x00000005, 0x00050041, 0x0000000f, + 0x00000010, 0x0000000c, 0x0000000e, 0x0004003d, + 0x00000007, 0x00000011, 0x00000010, 0x0003003e, + 0x00000009, 0x00000011, 0x000100fd, 0x00010038 +}; + +static const uint32_t compute_spirv[] = { + 0x07230203, 0x00010000, 0x000d000b, 0x00000012, + 0x00000000, 0x00020011, 0x00000001, 0x0006000b, + 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, + 0x00000000, 0x0003000e, 0x00000000, 0x00000001, + 0x0005000f, 0x00000005, 0x00000004, 0x6e69616d, + 0x00000000, 0x00060010, 0x00000004, 0x00000011, + 0x00000001, 0x00000001, 0x00000001, 0x00030003, + 0x00000002, 0x000001c2, 0x000a0004, 0x475f4c47, + 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, + 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, + 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, + 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, + 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, + 0x00030005, 0x00000009, 0x00706d74, 0x00030005, + 0x0000000a, 0x004f4255, 0x00040006, 0x0000000a, + 0x00000000, 0x00000061, 0x00030005, 0x0000000c, + 0x00000000, 0x00030047, 0x0000000a, 0x00000002, + 0x00050048, 0x0000000a, 0x00000000, 0x00000023, + 0x00000000, 0x00020013, 0x00000002, 0x00030021, + 0x00000003, 0x00000002, 0x00030016, 0x00000006, + 0x00000020, 0x00040017, 0x00000007, 0x00000006, + 0x00000004, 0x00040020, 0x00000008, 0x00000007, + 0x00000007, 0x0003001e, 0x0000000a, 0x00000007, + 0x00040020, 0x0000000b, 0x00000009, 0x0000000a, + 0x0004003b, 0x0000000b, 0x0000000c, 0x00000009, + 0x00040015, 0x0000000d, 0x00000020, 0x00000001, + 0x0004002b, 0x0000000d, 0x0000000e, 0x00000000, + 0x00040020, 0x0000000f, 0x00000009, 0x00000007, + 0x00050036, 0x00000002, 0x00000004, 0x00000000, + 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, + 0x00000008, 0x00000009, 0x00000007, 0x00050041, + 0x0000000f, 0x00000010, 0x0000000c, 0x0000000e, + 0x0004003d, 0x00000007, 0x00000011, 0x00000010, + 0x0003003e, 0x00000009, 0x00000011, 0x000100fd, + 0x00010038 +}; + +static bool create_graphics_pipeline(VkDevice device, VkPipelineCache cache, StateRecorder &recorder) +{ + VkPipelineLayoutCreateInfo layout_info = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; + VkPushConstantRange push_range = {}; + push_range.size = 16; + push_range.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + layout_info.pPushConstantRanges = &push_range; + layout_info.pushConstantRangeCount = 1; + + VkPipelineLayout layout; + if (vkCreatePipelineLayout(device, &layout_info, nullptr, &layout) != VK_SUCCESS) + return false; + if (!recorder.record_pipeline_layout(layout, layout_info)) + return false; + + VkRenderPassCreateInfo render_pass_info = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO }; + VkAttachmentDescription att = {}; + render_pass_info.attachmentCount = 1; + render_pass_info.subpassCount = 1; + att.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + att.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + att.format = VK_FORMAT_R8G8B8A8_UNORM; + att.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + att.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + att.samples = VK_SAMPLE_COUNT_1_BIT; + render_pass_info.pAttachments = &att; + + VkSubpassDescription subpass = {}; + VkAttachmentReference ref = {}; + ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + ref.attachment = 0; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &ref; + render_pass_info.pSubpasses = &subpass; + VkRenderPass render_pass; + if (vkCreateRenderPass(device, &render_pass_info, nullptr, &render_pass) != VK_SUCCESS) + return false; + if (!recorder.record_render_pass(render_pass, render_pass_info)) + return false; + + VkShaderModule vert_module, frag_module; + VkShaderModuleCreateInfo module_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO }; + + module_info.pCode = vert_spirv; + module_info.codeSize = sizeof(vert_spirv); + if (vkCreateShaderModule(device, &module_info, nullptr, &vert_module) != VK_SUCCESS) + return false; + if (!recorder.record_shader_module(vert_module, module_info)) + return false; + + module_info.pCode = frag_spirv; + module_info.codeSize = sizeof(frag_spirv); + if (vkCreateShaderModule(device, &module_info, nullptr, &frag_module) != VK_SUCCESS) + return false; + if (!recorder.record_shader_module(frag_module, module_info)) + return false; + + VkPipelineShaderStageCreateInfo stages[2] = {}; + stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stages[0].module = vert_module; + stages[0].pName = "main"; + stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; + stages[1].module = frag_module; + stages[1].pName = "main"; + stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; + + VkPipelineDynamicStateCreateInfo dynamic_state_info = { VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; + dynamic_state_info.dynamicStateCount = 2; + static const VkDynamicState dynamic_states[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; + dynamic_state_info.pDynamicStates = dynamic_states; + + VkGraphicsPipelineCreateInfo pipeline_info = { VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO }; + pipeline_info.layout = layout; + pipeline_info.basePipelineIndex = -1; + pipeline_info.renderPass = render_pass; + pipeline_info.subpass = 0; + pipeline_info.pStages = stages; + pipeline_info.stageCount = 2; + pipeline_info.pDynamicState = &dynamic_state_info; + + VkPipelineColorBlendStateCreateInfo color_blend_state = { VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; + VkPipelineColorBlendAttachmentState attachment_state = {}; + attachment_state.colorWriteMask = 0xf; + color_blend_state.attachmentCount = 1; + color_blend_state.pAttachments = &attachment_state; + pipeline_info.pColorBlendState = &color_blend_state; + + VkPipelineRasterizationStateCreateInfo raster_state = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; + raster_state.polygonMode = VK_POLYGON_MODE_FILL; + raster_state.lineWidth = 1.0f; + pipeline_info.pRasterizationState = &raster_state; + + VkPipelineMultisampleStateCreateInfo msaa_state = { VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; + msaa_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + pipeline_info.pMultisampleState = &msaa_state; + + VkPipelineVertexInputStateCreateInfo vertex_input = { VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO }; + pipeline_info.pVertexInputState = &vertex_input; + + VkPipelineViewportStateCreateInfo vp_info = { VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; + vp_info.viewportCount = 1; + vp_info.scissorCount = 1; + pipeline_info.pViewportState = &vp_info; + + VkPipelineInputAssemblyStateCreateInfo ia_info = { VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; + ia_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + pipeline_info.pInputAssemblyState = &ia_info; + + VkPipeline pipeline; + if (vkCreateGraphicsPipelines(device, cache, 1, &pipeline_info, nullptr, &pipeline) != VK_SUCCESS) + return false; + if (!recorder.record_graphics_pipeline(pipeline, pipeline_info, nullptr, 0)) + return false; + + vkDestroyRenderPass(device, render_pass, nullptr); + vkDestroyPipelineLayout(device, layout, nullptr); + vkDestroyPipeline(device, pipeline, nullptr); + vkDestroyShaderModule(device, vert_module, nullptr); + vkDestroyShaderModule(device, frag_module, nullptr); + return true; +} + +static bool create_compute_pipeline(VkDevice device, VkPipelineCache cache, StateRecorder &recorder) +{ + VkPipelineLayoutCreateInfo layout_info = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; + VkPushConstantRange push_range = {}; + push_range.size = 16; + push_range.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + layout_info.pPushConstantRanges = &push_range; + layout_info.pushConstantRangeCount = 1; + + VkPipelineLayout layout; + if (vkCreatePipelineLayout(device, &layout_info, nullptr, &layout) != VK_SUCCESS) + return false; + if (!recorder.record_pipeline_layout(layout, layout_info)) + return false; + + VkShaderModuleCreateInfo module_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO }; + module_info.pCode = compute_spirv; + module_info.codeSize = sizeof(compute_spirv); + VkShaderModule shader_module; + if (vkCreateShaderModule(device, &module_info, nullptr, &shader_module) != VK_SUCCESS) + return false; + if (!recorder.record_shader_module(shader_module, module_info)) + return false; + + VkComputePipelineCreateInfo compute_info = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO }; + compute_info.basePipelineIndex = -1; + compute_info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + compute_info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; + compute_info.layout = layout; + compute_info.stage.module = shader_module; + compute_info.stage.pName = "main"; + + VkPipeline pipeline; + if (vkCreateComputePipelines(device, cache, 1, &compute_info, nullptr, &pipeline) != VK_SUCCESS) + return false; + if (!recorder.record_compute_pipeline(pipeline, compute_info, nullptr, 0)) + return false; + vkDestroyPipelineLayout(device, layout, nullptr); + vkDestroyPipeline(device, pipeline, nullptr); + vkDestroyShaderModule(device, shader_module, nullptr); + + return true; +} + +static bool record_foz_and_cache(VkDevice device, VkPipelineCache cache, StateRecorder &recorder) +{ + if (!create_compute_pipeline(device, cache, recorder)) + return false; + if (!create_graphics_pipeline(device, cache, recorder)) + return false; + + return true; +} + +static bool serialize_pipeline_cache(VkDevice device, VkPipelineCache cache, const char *path) +{ + size_t size; + if (vkGetPipelineCacheData(device, cache, &size, nullptr) != VK_SUCCESS) + return false; + std::unique_ptr data(new uint8_t[size]); + if (vkGetPipelineCacheData(device, cache, &size, data.get()) != VK_SUCCESS) + return false; + + FILE *file = fopen(path, "wb"); + if (!file) + return false; + + if (fwrite(data.get(), 1, size, file) != size) + { + fclose(file); + return false; + } + + fclose(file); + return true; +} + +static bool check_replayer_roundtrip(const std::string &replayer, const char *foz_path, const char *cache_bin) +{ + int pipe_fd[2]; + if (pipe(pipe_fd) < 0) + return false; + pid_t pid = fork(); + + if (pid) + { + close(pipe_fd[1]); + FILE *file = fdopen(pipe_fd[0], "r"); + if (!file) + { + kill(pid, SIGKILL); + LOGE("fdopen failed somehow.\n"); + return false; + } + + unsigned hits = 0; + unsigned misses = 0; + + char line[1024]; + while (fgets(line, sizeof(line), file)) + { + const auto parse_number_end_of_line = [](const char *str) + { + const char *ptr = str + strlen(str); + ptr--; + if (*ptr == '\n') + ptr--; + while (isdigit(*ptr)) + ptr--; + return strtoul(ptr, nullptr, 0); + }; + + // Crude parsing of console output. + if (strstr(line, "Pipeline cache hits reported")) + hits = parse_number_end_of_line(line); + else if (strstr(line, "Pipeline cache misses reported")) + misses = parse_number_end_of_line(line); + else if (strncmp(line, "Fossilize ERROR:", strlen("Fossilize ERROR:")) == 0) + fprintf(stderr, "%s", line); + } + + fclose(file); + + int wait_status; + if (waitpid(pid, &wait_status, 0) < 0) + { + LOGE("Failed to wait for child process\n"); + return false; + } + + if (!WIFEXITED(wait_status) || WEXITSTATUS(wait_status) != 0) + { + LOGE("Child process did not exit normally.\n"); + return false; + } + + if (hits == 0 && misses != 0) + { + LOGE("Pipeline cache missed! Roundtrip does not work!\n"); + return false; + } + else if (hits != 0 && misses == 0) + { + LOGI("Roundtrip success :D\n"); + } + else if (hits == 0 && misses == 0) + { + LOGE("No hits or misses reported. Something went wrong.\n"); + return false; + } + } + else + { + close(pipe_fd[0]); + if (dup2(pipe_fd[1], STDOUT_FILENO) < 0) + _exit(EXIT_FAILURE); + if (dup2(pipe_fd[1], STDERR_FILENO) < 0) + _exit(EXIT_FAILURE); + close(pipe_fd[1]); + + if (execl(replayer.c_str(), replayer.c_str(), + foz_path, "--num-threads", "1", "--on-disk-pipeline-cache", + cache_bin, static_cast(nullptr)) < 0) + { + LOGE("Failed to spawn child process \"%s\".\n", replayer.c_str()); + _exit(EXIT_FAILURE); + } + } + + return true; +} + +int main(int argc, char **argv) +{ + std::string fossilize_replay = "fossilize-replay"; + CLICallbacks cbs; + + cbs.add("--help", [&](CLIParser &parser) { parser.end(); }); + cbs.add("--fossilize-replay", [&](CLIParser &parser) { fossilize_replay = parser.next_string(); }); + + CLIParser parser(std::move(cbs), argc - 1, argv + 1); + if (!parser.parse()) + { + print_help(); + return EXIT_FAILURE; + } + else if (parser.is_ended_state()) + { + print_help(); + return EXIT_SUCCESS; + } + + VkInstance instance = create_instance(); + VkPhysicalDeviceFeatures features = {}; + VkDevice device = create_device(instance, features); + VkPipelineCache cache = create_pipeline_cache(device); + + char tmp_foz[PATH_MAX]; + char tmp_bin[PATH_MAX]; + snprintf(tmp_foz, sizeof(tmp_foz), "/tmp/tmp_pipeline_cache.%u.foz", getpid()); + snprintf(tmp_bin, sizeof(tmp_bin), "/tmp/tmp_pipeline_cache.%u.bin", getpid()); + + bool ret; + { + std::unique_ptr db(create_database(tmp_foz, DatabaseMode::OverWrite)); + StateRecorder recorder; + recorder.init_recording_synchronized(db.get()); + recorder.set_database_enable_application_feature_links(false); + + if (!recorder.record_application_info(app_info)) + return EXIT_FAILURE; + if (!recorder.record_physical_device_features(features)) + return EXIT_FAILURE; + + ret = record_foz_and_cache(device, cache, recorder); + } + + if (ret) + ret = serialize_pipeline_cache(device, cache, tmp_bin); + + vkDestroyPipelineCache(device, cache, nullptr); + vkDestroyDevice(device, nullptr); + vkDestroyInstance(instance, nullptr); + + if (ret) + ret = check_replayer_roundtrip(fossilize_replay, tmp_foz, tmp_bin); + + unlink(tmp_foz); + unlink(tmp_bin); + + if (!ret) + return EXIT_FAILURE; +} \ No newline at end of file From 6b61a23d5fa5b18f7f538f061778f0f102a7da9e Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 12:50:17 +0200 Subject: [PATCH 02/17] Disable cooperative matrix robustness in replayer. Pragmatic reasons since it's not used in the wild, and conflicts with certain RADV versions. --- cli/fossilize_feature_filter.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cli/fossilize_feature_filter.cpp b/cli/fossilize_feature_filter.cpp index 8b151815..68254c9a 100644 --- a/cli/fossilize_feature_filter.cpp +++ b/cli/fossilize_feature_filter.cpp @@ -87,6 +87,8 @@ static void filter_feature_enablement( VkPhysicalDeviceFeatures2 &pdf, VulkanFeatures &features, const VkPhysicalDeviceFeatures2 *target_features) { + features.cooperative_matrix.cooperativeMatrixRobustBufferAccess = VK_FALSE; + // These feature bits conflict according to validation layers. if (features.fragment_shading_rate.pipelineFragmentShadingRate == VK_TRUE || features.fragment_shading_rate.attachmentFragmentShadingRate == VK_TRUE || From b4fb0a57c37a9cb35195dea27792b70638627ff3 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 12:53:37 +0200 Subject: [PATCH 03/17] Update volk. --- cli/volk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/volk b/cli/volk index 65e811e4..8a2387af 160000 --- a/cli/volk +++ b/cli/volk @@ -1 +1 @@ -Subproject commit 65e811e401bc09a9525265aea584db898d67e54f +Subproject commit 8a2387afabdf1336f132e0a8bf38701df9838130 From 9658a549e5d870091c118c6dcb1be596e28f8eab Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:03:31 +0200 Subject: [PATCH 04/17] Add option to log the pipeline binary global key. This can be used to fish out breakage. --- cli/fossilize_validate_cache_roundtrip.cpp | 45 ++++++++++++++++++++-- 1 file changed, 41 insertions(+), 4 deletions(-) diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index 78c5b007..58b51b28 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -36,7 +36,7 @@ using namespace Fossilize; static void print_help() { - LOGI("fossilize-validate-cache-roundtrip [--help] [--fossilize-replay ]\n"); + LOGI("fossilize-validate-cache-roundtrip [--help] [--fossilize-replay ] [--pipeline-binary-key]\n"); } static constexpr VkApplicationInfo app_info = { @@ -71,7 +71,7 @@ static VkInstance create_instance() return instance; } -static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures &features) +static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures &features, bool pipeline_binary_key) { // Just pick the first GPU. Could be improved if needed. uint32_t count = 1; @@ -93,13 +93,48 @@ static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeature queue_create_info.queueFamilyIndex = 0; queue_create_info.pQueuePriorities = &queue_prio; device_info.pQueueCreateInfos = &queue_create_info; - device_info.pEnabledFeatures = &features; + + VkPhysicalDevicePipelineBinaryFeaturesKHR binary = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR }; + VkPhysicalDeviceFeatures2 features2 = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, &binary, features }; + + if (pipeline_binary_key) + { + device_info.pNext = &features2; + static const char *extensions[] = { + VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, + VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, + VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, + VK_KHR_MAINTENANCE_5_EXTENSION_NAME, + VK_KHR_PIPELINE_BINARY_EXTENSION_NAME + }; + device_info.ppEnabledExtensionNames = extensions; + device_info.enabledExtensionCount = 5; + } + else + { + device_info.pEnabledFeatures = &features; + } VkDevice device; if (vkCreateDevice(gpu, &device_info, nullptr, &device) != VK_SUCCESS) return VK_NULL_HANDLE; volkLoadDevice(device); + if (pipeline_binary_key) + { + VkPipelineBinaryKeyKHR key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + if (vkGetPipelineKeyKHR(device, nullptr, &key) != VK_SUCCESS) + { + LOGE("Failed to get the global pipeline binary key.\n"); + return VK_NULL_HANDLE; + } + uint32_t key_values[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR / sizeof(uint32_t)] = {}; + memcpy(key_values, key.key, key.keySize); + LOGI("Global pipeline binary key: %08x%08x%08x%08x%08x%08x%08x%08x\n", + key_values[0], key_values[1], key_values[2], key_values[3], + key_values[4], key_values[5], key_values[6], key_values[7]); + } + return device; } @@ -567,10 +602,12 @@ static bool check_replayer_roundtrip(const std::string &replayer, const char *fo int main(int argc, char **argv) { std::string fossilize_replay = "fossilize-replay"; + bool pipeline_binary_key = false; CLICallbacks cbs; cbs.add("--help", [&](CLIParser &parser) { parser.end(); }); cbs.add("--fossilize-replay", [&](CLIParser &parser) { fossilize_replay = parser.next_string(); }); + cbs.add("--pipeline-binary-key", [&](CLIParser &) { pipeline_binary_key = true; }); CLIParser parser(std::move(cbs), argc - 1, argv + 1); if (!parser.parse()) @@ -586,7 +623,7 @@ int main(int argc, char **argv) VkInstance instance = create_instance(); VkPhysicalDeviceFeatures features = {}; - VkDevice device = create_device(instance, features); + VkDevice device = create_device(instance, features, pipeline_binary_key); VkPipelineCache cache = create_pipeline_cache(device); char tmp_foz[PATH_MAX]; From 5b23748f3a09a13854e177c50f24e34d464e9705 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:15:34 +0200 Subject: [PATCH 05/17] Emit robustness2 when robustness1 is used in roundtripper. --- cli/fossilize_validate_cache_roundtrip.cpp | 46 ++++++++++++++++------ 1 file changed, 34 insertions(+), 12 deletions(-) diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index 58b51b28..5d8040a2 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -36,7 +36,10 @@ using namespace Fossilize; static void print_help() { - LOGI("fossilize-validate-cache-roundtrip [--help] [--fossilize-replay ] [--pipeline-binary-key]\n"); + LOGI("fossilize-validate-cache-roundtrip\n" + "\t[--help]\n" + "\t[--fossilize-replay ]\n" + "\t[--pipeline-binary-key]\n"); } static constexpr VkApplicationInfo app_info = { @@ -94,25 +97,39 @@ static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeature queue_create_info.pQueuePriorities = &queue_prio; device_info.pQueueCreateInfos = &queue_create_info; - VkPhysicalDevicePipelineBinaryFeaturesKHR binary = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR }; + VkPhysicalDevicePipelineBinaryFeaturesKHR binary = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, nullptr, VK_TRUE + }; + + VkPhysicalDeviceRobustness2FeaturesEXT robustness2 = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, nullptr, + VK_TRUE, VK_TRUE, VK_TRUE + }; + + if (features.robustBufferAccess) + binary.pNext = &robustness2; + VkPhysicalDeviceFeatures2 features2 = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, &binary, features }; + device_info.pNext = &features2; + + static const char *extensions[] = { + VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, + VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, + VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, + VK_KHR_MAINTENANCE_5_EXTENSION_NAME, + VK_KHR_PIPELINE_BINARY_EXTENSION_NAME, + VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, + }; if (pipeline_binary_key) { - device_info.pNext = &features2; - static const char *extensions[] = { - VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, - VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, - VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, - VK_KHR_MAINTENANCE_5_EXTENSION_NAME, - VK_KHR_PIPELINE_BINARY_EXTENSION_NAME - }; device_info.ppEnabledExtensionNames = extensions; - device_info.enabledExtensionCount = 5; + device_info.enabledExtensionCount = features.robustBufferAccess ? 6 : 5; } else { - device_info.pEnabledFeatures = &features; + device_info.ppEnabledExtensionNames = extensions + 5; + device_info.enabledExtensionCount = 1; } VkDevice device; @@ -603,11 +620,13 @@ int main(int argc, char **argv) { std::string fossilize_replay = "fossilize-replay"; bool pipeline_binary_key = false; + bool robustness = false; CLICallbacks cbs; cbs.add("--help", [&](CLIParser &parser) { parser.end(); }); cbs.add("--fossilize-replay", [&](CLIParser &parser) { fossilize_replay = parser.next_string(); }); cbs.add("--pipeline-binary-key", [&](CLIParser &) { pipeline_binary_key = true; }); + cbs.add("--robustness", [&](CLIParser &) { robustness = true; }); CLIParser parser(std::move(cbs), argc - 1, argv + 1); if (!parser.parse()) @@ -622,7 +641,10 @@ int main(int argc, char **argv) } VkInstance instance = create_instance(); + VkPhysicalDeviceFeatures features = {}; + features.robustBufferAccess = robustness; + VkDevice device = create_device(instance, features, pipeline_binary_key); VkPipelineCache cache = create_pipeline_cache(device); From bb48381ea0529683908398669b5bb9dfe7bc6153 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:28:38 +0200 Subject: [PATCH 06/17] Remove ancient use of device layers. --- cli/device.cpp | 31 ------------------------------- 1 file changed, 31 deletions(-) diff --git a/cli/device.cpp b/cli/device.cpp index 8f5de60e..b262b35c 100644 --- a/cli/device.cpp +++ b/cli/device.cpp @@ -450,35 +450,6 @@ bool VulkanDevice::init_device(const Options &opts) } } - vector active_device_layers; - if (opts.enable_validation) - { - uint32_t device_layer_count = 0; - if (vkEnumerateDeviceLayerProperties(gpu, &device_layer_count, nullptr) != VK_SUCCESS) - return false; - vector device_layers(device_layer_count); - if (device_layer_count && vkEnumerateDeviceLayerProperties(gpu, &device_layer_count, device_layers.data()) != VK_SUCCESS) - return false; - - if (find_layer(device_layers, "VK_LAYER_KHRONOS_validation")) - { - active_device_layers.push_back("VK_LAYER_KHRONOS_validation"); - - uint32_t validation_ext_count = 0; - vkEnumerateDeviceExtensionProperties(gpu, "VK_LAYER_KHRONOS_validation", &validation_ext_count, nullptr); - vector validation_extensions(validation_ext_count); - vkEnumerateDeviceExtensionProperties(gpu, "VK_LAYER_KHRONOS_validation", &validation_ext_count, validation_extensions.data()); - validation_cache = find_extension(validation_extensions, VK_EXT_VALIDATION_CACHE_EXTENSION_NAME); - if (validation_cache) - active_device_extensions.push_back(VK_EXT_VALIDATION_CACHE_EXTENSION_NAME); - } - else - { - LOGE("Cannot find VK_LAYER_KHRONOS_validation layer.\n"); - return false; - } - } - supports_pipeline_feedback = find_if(begin(active_device_extensions), end(active_device_extensions), [](const char *ext) { return strcmp(ext, VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME) == 0; }) != end(active_device_extensions); @@ -498,8 +469,6 @@ bool VulkanDevice::init_device(const Options &opts) device_info.pEnabledFeatures = has_device_features2 ? nullptr : &gpu_features2.features; device_info.pQueueCreateInfos = &queue_info; device_info.queueCreateInfoCount = 1; - device_info.enabledLayerCount = uint32_t(active_device_layers.size()); - device_info.ppEnabledLayerNames = active_device_layers.empty() ? nullptr : active_device_layers.data(); device_info.enabledExtensionCount = uint32_t(active_device_extensions.size()); device_info.ppEnabledExtensionNames = active_device_extensions.empty() ? nullptr : active_device_extensions.data(); From 7450d915bdbbebfed264ede3295ac3d47f5dc23e Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:29:00 +0200 Subject: [PATCH 07/17] Add more extensions to ban-list on ancient core versions. --- cli/device.cpp | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/cli/device.cpp b/cli/device.cpp index b262b35c..f878fa72 100644 --- a/cli/device.cpp +++ b/cli/device.cpp @@ -74,11 +74,22 @@ static bool filter_extension(const char *ext, bool want_amd_shader_info, VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME, VK_KHR_RAY_QUERY_EXTENSION_NAME, VK_KHR_MAINTENANCE_4_EXTENSION_NAME, + VK_KHR_MAINTENANCE_5_EXTENSION_NAME, + VK_KHR_MAINTENANCE_6_EXTENSION_NAME, + VK_KHR_MAINTENANCE_7_EXTENSION_NAME, + VK_KHR_MAINTENANCE_8_EXTENSION_NAME, + VK_KHR_MAINTENANCE_9_EXTENSION_NAME, + VK_KHR_MAINTENANCE_10_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME, VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME, VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, + VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME, + }; + + static const char *vulkan_12_only_extensions[] = { + VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME, }; bool ext_is_vulkan_11_only = false; @@ -91,6 +102,16 @@ static bool filter_extension(const char *ext, bool want_amd_shader_info, } } + bool ext_is_vulkan_12_only = false; + for (auto *candidate : vulkan_12_only_extensions) + { + if (strcmp(candidate, ext) == 0) + { + ext_is_vulkan_12_only = true; + break; + } + } + if (strcmp(ext, VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME) == 0) { // AMD_negative_viewport_height: Obsolete, illegal to enable along maintenance1. @@ -111,6 +132,10 @@ static bool filter_extension(const char *ext, bool want_amd_shader_info, { return false; } + else if (api_version < VK_API_VERSION_1_2 && ext_is_vulkan_12_only) + { + return false; + } else if (strcmp(ext, VK_AMD_SHADER_INFO_EXTENSION_NAME) == 0 && !want_amd_shader_info) { // Mesa disables the pipeline cache when VK_AMD_shader_info is used, so disable this extension unless we need it. From b8197566b2987e1ad68ca7c5ca451c8c0afb2596 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:38:51 +0200 Subject: [PATCH 08/17] Update Vulkan header. --- khronos/vulkan/vulkan_core.h | 1769 ++++++++++++++++++++++++++++++---- 1 file changed, 1595 insertions(+), 174 deletions(-) diff --git a/khronos/vulkan/vulkan_core.h b/khronos/vulkan/vulkan_core.h index 1ab0ef86..042cf481 100644 --- a/khronos/vulkan/vulkan_core.h +++ b/khronos/vulkan/vulkan_core.h @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 344 +#define VK_HEADER_VERSION 351 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -640,6 +640,13 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD = 1000133000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD = 1000133001, + VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD = 1000133002, + VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD = 1000133003, + VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD = 1000133004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD = 1000133005, + VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD = 1000133006, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000, #endif @@ -739,6 +746,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM = 1000172000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM = 1000173000, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, @@ -797,6 +805,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR = 1000231000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR = 1000233000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR = 1000233001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR = 1000233002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, @@ -877,6 +889,14 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM = 1000302000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM = 1000302001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM = 1000302002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM = 1000303000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM = 1000304000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM = 1000304001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT = 1000305000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT = 1000305001, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, #endif @@ -924,6 +944,22 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR = 1000318000, + VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR = 1000318001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR = 1000318002, + VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR = 1000318003, + VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR = 1000318004, + VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR = 1000318005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR = 1000318006, + VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR = 1000318007, + VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR = 1000318008, + VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR = 1000318009, + VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR = 1000318010, + VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR = 1000318011, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT = 1000318012, + VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT = 1000318013, + VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD = 1000318014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR = 1000318015, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, @@ -1038,6 +1074,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, + VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM = 1000417003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM = 1000417004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, @@ -1212,6 +1250,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM = 1000508000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, @@ -1334,6 +1373,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR = 1000573000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR = 1000573001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR = 1000573002, + VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR = 1000573003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000, VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, @@ -1370,6 +1413,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM = 1000605002, VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM = 1000605003, VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM = 1000605004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM = 1000607000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM = 1000607001, + VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM = 1000607002, + VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM = 1000607003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, @@ -1377,17 +1424,17 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, -#endif VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR = 1000623000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR = 1000623001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR = 1000623002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR = 1000623003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, @@ -1399,15 +1446,32 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM = 1000631000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM = 1000631001, + VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM = 1000631003, + VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM = 1000631004, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM = 1000631005, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM = 1000631002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM = 1000631006, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM = 1000631007, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM = 1000631008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT = 1000635000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT = 1000635001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000, VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV = 1000645000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV = 1000645001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR = 1000657000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR = 1000657001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC = 1000664000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE = 1000673000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC = 1000674000, + VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC = 1000674001, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM = 1000676002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT = 1000678000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias @@ -1706,6 +1770,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_GPA_SESSION_AMD = 1000133000, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, @@ -1729,6 +1794,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, + VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM = 1000607000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, @@ -2154,6 +2220,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_TIME_ELAPSED_QCOM = 1000173000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, @@ -2684,6 +2751,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000, + VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR = 0x00400000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, @@ -3138,10 +3206,10 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, - VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, #endif + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000, // VK_PIPELINE_CREATE_DISPATCH_BASE is a legacy alias VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, @@ -3154,6 +3222,7 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -3162,6 +3231,7 @@ typedef VkFlags VkPipelineCreateFlags; typedef enum VkPipelineLayoutCreateFlagBits { VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, + VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR = 0x00000004, VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineLayoutCreateFlagBits; typedef VkFlags VkPipelineLayoutCreateFlags; @@ -3641,9 +3711,9 @@ typedef struct VkDeviceCreateInfo { VkDeviceCreateFlags flags; uint32_t queueCreateInfoCount; const VkDeviceQueueCreateInfo* pQueueCreateInfos; - // enabledLayerCount is legacy and ignored + // enabledLayerCount is legacy and not used uint32_t enabledLayerCount; - // ppEnabledLayerNames is legacy and ignored + // ppEnabledLayerNames is legacy and not used const char* const* ppEnabledLayerNames; uint32_t enabledExtensionCount; const char* const* ppEnabledExtensionNames; @@ -7248,6 +7318,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM = 0x100000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; @@ -7294,6 +7365,9 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x80000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM = 0x100000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM = 0x200000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM = 0x400000000000000ULL; typedef enum VkPipelineCreationFeedbackFlagBits { @@ -8162,6 +8236,8 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL; #endif static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL; @@ -8186,8 +8262,6 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STO static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; #ifdef VK_ENABLE_BETA_EXTENSIONS static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL; #endif @@ -8225,6 +8299,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_ #endif static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x1000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; @@ -8251,17 +8326,21 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BI static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; +#endif static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM = 0x8000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR = 0x20000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ULL; typedef struct VkPhysicalDeviceVulkan14Features { @@ -8873,6 +8952,7 @@ typedef enum VkSurfaceTransformFlagBitsKHR { VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; typedef enum VkCompositeAlphaFlagBitsKHR { VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, @@ -8882,7 +8962,6 @@ typedef enum VkCompositeAlphaFlagBitsKHR { VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkCompositeAlphaFlagBitsKHR; typedef VkFlags VkCompositeAlphaFlagsKHR; -typedef VkFlags VkSurfaceTransformFlagsKHR; typedef struct VkSurfaceCapabilitiesKHR { uint32_t minImageCount; uint32_t maxImageCount; @@ -11690,6 +11769,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( #endif +// VK_KHR_shader_constant_data is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_constant_data 1 +#define VK_KHR_SHADER_CONSTANT_DATA_SPEC_VERSION 1 +#define VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME "VK_KHR_shader_constant_data" +typedef struct VkPhysicalDeviceShaderConstantDataFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderConstantData; +} VkPhysicalDeviceShaderConstantDataFeaturesKHR; + + + // VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_dynamic_rendering_local_read 1 #define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 @@ -11718,6 +11809,31 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( #endif +// VK_KHR_shader_abort is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_abort 1 +#define VK_KHR_SHADER_ABORT_SPEC_VERSION 1 +#define VK_KHR_SHADER_ABORT_EXTENSION_NAME "VK_KHR_shader_abort" +typedef struct VkPhysicalDeviceShaderAbortFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderAbort; +} VkPhysicalDeviceShaderAbortFeaturesKHR; + +typedef struct VkDeviceFaultShaderAbortMessageInfoKHR { + VkStructureType sType; + void* pNext; + uint64_t messageDataSize; + void* pMessageData; +} VkDeviceFaultShaderAbortMessageInfoKHR; + +typedef struct VkPhysicalDeviceShaderAbortPropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxShaderAbortMessageSize; +} VkPhysicalDeviceShaderAbortPropertiesKHR; + + + // VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_shader_quad_control 1 #define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 @@ -12326,6 +12442,376 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( #endif +// VK_KHR_device_address_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_address_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) +#define VK_KHR_DEVICE_ADDRESS_COMMANDS_SPEC_VERSION 1 +#define VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME "VK_KHR_device_address_commands" + +typedef enum VkAccelerationStructureTypeKHR { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR = 1000623000, + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureTypeKHR; + +typedef enum VkAddressCommandFlagBitsKHR { + VK_ADDRESS_COMMAND_PROTECTED_BIT_KHR = 0x00000001, + VK_ADDRESS_COMMAND_FULLY_BOUND_BIT_KHR = 0x00000002, + VK_ADDRESS_COMMAND_STORAGE_BUFFER_USAGE_BIT_KHR = 0x00000004, + VK_ADDRESS_COMMAND_UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR = 0x00000008, + VK_ADDRESS_COMMAND_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR = 0x00000010, + VK_ADDRESS_COMMAND_UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR = 0x00000020, + VK_ADDRESS_COMMAND_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAddressCommandFlagBitsKHR; +typedef VkFlags VkAddressCommandFlagsKHR; + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; + +typedef enum VkAccelerationStructureCreateFlagBitsKHR { + VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCreateFlagBitsKHR; +typedef VkFlags VkAccelerationStructureCreateFlagsKHR; +typedef struct VkDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; +} VkDeviceAddressRangeKHR; + +typedef struct VkStridedDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; + VkDeviceSize stride; +} VkStridedDeviceAddressRangeKHR; + +typedef struct VkDeviceMemoryCopyKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR srcRange; + VkAddressCommandFlagsKHR srcFlags; + VkDeviceAddressRangeKHR dstRange; + VkAddressCommandFlagsKHR dstFlags; +} VkDeviceMemoryCopyKHR; + +typedef struct VkCopyDeviceMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t regionCount; + const VkDeviceMemoryCopyKHR* pRegions; +} VkCopyDeviceMemoryInfoKHR; + +typedef struct VkDeviceMemoryImageCopyKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + uint32_t addressRowLength; + uint32_t addressImageHeight; + VkImageSubresourceLayers imageSubresource; + VkImageLayout imageLayout; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkDeviceMemoryImageCopyKHR; + +typedef struct VkCopyDeviceMemoryImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + uint32_t regionCount; + const VkDeviceMemoryImageCopyKHR* pRegions; +} VkCopyDeviceMemoryImageInfoKHR; + +typedef struct VkMemoryRangeBarrierKHR { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkMemoryRangeBarrierKHR; + +typedef struct VkMemoryRangeBarriersInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryRangeBarrierCount; + const VkMemoryRangeBarrierKHR* pMemoryRangeBarriers; +} VkMemoryRangeBarriersInfoKHR; + +typedef struct VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 deviceAddressCommands; +} VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR; + +typedef struct VkBindIndexBuffer3InfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkIndexType indexType; +} VkBindIndexBuffer3InfoKHR; + +typedef struct VkBindVertexBuffer3InfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 setStride; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkBindVertexBuffer3InfoKHR; + +typedef struct VkDrawIndirect2InfoKHR { + VkStructureType sType; + const void* pNext; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + uint32_t drawCount; +} VkDrawIndirect2InfoKHR; + +typedef struct VkDrawIndirectCount2InfoKHR { + VkStructureType sType; + const void* pNext; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkDeviceAddressRangeKHR countAddressRange; + VkAddressCommandFlagsKHR countAddressFlags; + uint32_t maxDrawCount; +} VkDrawIndirectCount2InfoKHR; + +typedef struct VkDispatchIndirect2InfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkDispatchIndirect2InfoKHR; + +typedef struct VkConditionalRenderingBeginInfo2EXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfo2EXT; + +typedef struct VkBindTransformFeedbackBuffer2InfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkBindTransformFeedbackBuffer2InfoEXT; + +typedef struct VkMemoryMarkerInfoAMD { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2KHR stage; + VkDeviceAddressRangeKHR dstRange; + VkAddressCommandFlagsKHR dstFlags; + uint32_t marker; +} VkMemoryMarkerInfoAMD; + +typedef struct VkAccelerationStructureCreateInfo2KHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkAccelerationStructureTypeKHR type; +} VkAccelerationStructureCreateInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer3KHR)(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers3KHR)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateMemoryKHR)(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillMemoryKHR)(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResultsToMemoryKHR)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, const VkStridedDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkQueryResultFlags queryResultFlags); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRendering2EXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedback2EXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedback2EXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCount2EXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, uint32_t counterOffset, uint32_t vertexStride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirect2EXT)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCount2EXT)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMarkerToMemoryAMD)(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructure2KHR)(VkDevice device, const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer3KHR( + VkCommandBuffer commandBuffer, + const VkBindIndexBuffer3InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers3KHR( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBindVertexBuffer3InfoKHR* pBindingInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDispatchIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateMemoryKHR( + VkCommandBuffer commandBuffer, + const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkDeviceSize dataSize, + const void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdFillMemoryKHR( + VkCommandBuffer commandBuffer, + const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + uint32_t data); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResultsToMemoryKHR( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + const VkStridedDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkQueryResultFlags queryResultFlags); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRendering2EXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedback2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedback2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCount2EXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, + uint32_t counterOffset, + uint32_t vertexStride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirect2EXT( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCount2EXT( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMarkerToMemoryAMD( + VkCommandBuffer commandBuffer, + const VkMemoryMarkerInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructure2KHR( + VkDevice device, + const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); +#endif +#endif + + // VK_KHR_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_fragment_shader_barycentric 1 #define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 @@ -13605,12 +14091,6 @@ typedef enum VkAddressCopyFlagBitsKHR { VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkAddressCopyFlagBitsKHR; typedef VkFlags VkAddressCopyFlagsKHR; -typedef struct VkStridedDeviceAddressRangeKHR { - VkDeviceAddress address; - VkDeviceSize size; - VkDeviceSize stride; -} VkStridedDeviceAddressRangeKHR; - typedef struct VkCopyMemoryIndirectCommandKHR { VkDeviceAddress srcAddress; VkDeviceAddress dstAddress; @@ -13866,32 +14346,150 @@ typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR { -// VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance8 1 -#define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8" -typedef VkFlags64 VkAccessFlags3KHR; - -// Flag bits for VkAccessFlagBits3KHR -typedef VkFlags64 VkAccessFlagBits3KHR; -static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL; - -typedef struct VkMemoryBarrierAccessFlags3KHR { - VkStructureType sType; - const void* pNext; - VkAccessFlags3KHR srcAccessMask3; - VkAccessFlags3KHR dstAccessMask3; -} VkMemoryBarrierAccessFlags3KHR; - -typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { +// VK_KHR_device_fault is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_fault 1 +#define VK_KHR_DEVICE_FAULT_SPEC_VERSION 1 +#define VK_KHR_DEVICE_FAULT_EXTENSION_NAME "VK_KHR_device_fault" + +typedef enum VkDeviceFaultAddressTypeKHR { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultAddressTypeKHR; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionKHR { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionKHR; + +typedef enum VkDeviceFaultFlagBitsKHR { + VK_DEVICE_FAULT_FLAG_DEVICE_LOST_KHR = 0x00000001, + VK_DEVICE_FAULT_FLAG_MEMORY_ADDRESS_KHR = 0x00000002, + VK_DEVICE_FAULT_FLAG_INSTRUCTION_ADDRESS_KHR = 0x00000004, + VK_DEVICE_FAULT_FLAG_VENDOR_KHR = 0x00000008, + VK_DEVICE_FAULT_FLAG_WATCHDOG_TIMEOUT_KHR = 0x00000010, + VK_DEVICE_FAULT_FLAG_OVERFLOW_KHR = 0x00000020, + VK_DEVICE_FAULT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultFlagBitsKHR; +typedef VkFlags VkDeviceFaultFlagsKHR; +typedef struct VkPhysicalDeviceFaultFeaturesKHR { VkStructureType sType; void* pNext; - VkBool32 maintenance8; -} VkPhysicalDeviceMaintenance8FeaturesKHR; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; + VkBool32 deviceFaultReportMasked; + VkBool32 deviceFaultDeviceLostOnMasked; +} VkPhysicalDeviceFaultFeaturesKHR; +typedef struct VkPhysicalDeviceFaultPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxDeviceFaultCount; +} VkPhysicalDeviceFaultPropertiesKHR; +typedef struct VkDeviceFaultAddressInfoKHR { + VkDeviceFaultAddressTypeKHR addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoKHR; -// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls. +typedef struct VkDeviceFaultVendorInfoKHR { + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoKHR; + +typedef struct VkDeviceFaultInfoKHR { + VkStructureType sType; + void* pNext; + VkDeviceFaultFlagsKHR flags; + uint64_t groupId; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoKHR faultAddressInfo; + VkDeviceFaultAddressInfoKHR instructionAddressInfo; + VkDeviceFaultVendorInfoKHR vendorInfo; +} VkDeviceFaultInfoKHR; + +typedef struct VkDeviceFaultDebugInfoKHR { + VkStructureType sType; + void* pNext; + uint32_t vendorBinarySize; + void* pVendorBinaryData; +} VkDeviceFaultDebugInfoKHR; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneKHR { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionKHR headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultReportsKHR)(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts, VkDeviceFaultInfoKHR* pFaultInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultDebugInfoKHR)(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultReportsKHR( + VkDevice device, + uint64_t timeout, + uint32_t* pFaultCounts, + VkDeviceFaultInfoKHR* pFaultInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultDebugInfoKHR( + VkDevice device, + VkDeviceFaultDebugInfoKHR* pDebugInfo); +#endif +#endif + + +// VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance8 1 +#define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8" +typedef VkFlags64 VkAccessFlags3KHR; + +// Flag bits for VkAccessFlagBits3KHR +typedef VkFlags64 VkAccessFlagBits3KHR; +static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL; + +typedef struct VkMemoryBarrierAccessFlags3KHR { + VkStructureType sType; + const void* pNext; + VkAccessFlags3KHR srcAccessMask3; + VkAccessFlags3KHR dstAccessMask3; +} VkMemoryBarrierAccessFlags3KHR; + +typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance8; +} VkPhysicalDeviceMaintenance8FeaturesKHR; + + + +// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_shader_fma 1 #define VK_KHR_SHADER_FMA_SPEC_VERSION 1 #define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma" @@ -14014,6 +14612,86 @@ typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { +// VK_KHR_opacity_micromap is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_opacity_micromap 1 +#define VK_KHR_OPACITY_MICROMAP_SPEC_VERSION 1 +#define VK_KHR_OPACITY_MICROMAP_EXTENSION_NAME "VK_KHR_opacity_micromap" + +typedef enum VkOpacityMicromapFormatKHR { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR = 2, + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkOpacityMicromapFormatKHR; + +typedef enum VkOpacityMicromapSpecialIndexKHR { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_KHR = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexKHR; + +typedef enum VkAccelerationStructureSerializedBlockTypeKHR { + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR = 0, + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureSerializedBlockTypeKHR; +typedef struct VkMicromapUsageKHR { + uint32_t count; + uint32_t subdivisionLevel; + VkOpacityMicromapFormatKHR format; +} VkMicromapUsageKHR; + +typedef struct VkAccelerationStructureGeometryMicromapDataKHR { + VkStructureType sType; + const void* pNext; + uint32_t usageCountsCount; + const VkMicromapUsageKHR* pUsageCounts; + const VkMicromapUsageKHR* const* ppUsageCounts; + VkDeviceAddress data; + VkDeviceAddress triangleArray; + VkDeviceSize triangleArrayStride; +} VkAccelerationStructureGeometryMicromapDataKHR; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 micromap; +} VkPhysicalDeviceOpacityMicromapFeaturesKHR; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + uint32_t maxOpacityLossy4StateSubdivisionLevel; + uint64_t maxMicromapTriangles; +} VkPhysicalDeviceOpacityMicromapPropertiesKHR; + +typedef struct VkMicromapTriangleKHR { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleKHR; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapKHR { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceAddress indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + VkAccelerationStructureKHR micromap; +} VkAccelerationStructureTrianglesOpacityMicromapKHR; + + + // VK_KHR_maintenance10 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance10 1 #define VK_KHR_MAINTENANCE_10_SPEC_VERSION 1 @@ -14077,6 +14755,24 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR( #endif +// VK_KHR_maintenance11 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance11 1 +#define VK_KHR_MAINTENANCE_11_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_11_EXTENSION_NAME "VK_KHR_maintenance11" +typedef struct VkPhysicalDeviceMaintenance11FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance11; +} VkPhysicalDeviceMaintenance11FeaturesKHR; + +typedef struct VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent3D optimalImageTransferGranularity; +} VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR; + + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -14852,12 +15548,6 @@ typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT; #define VK_EXT_conditional_rendering 1 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" - -typedef enum VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, - VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConditionalRenderingFlagBitsEXT; -typedef VkFlags VkConditionalRenderingFlagsEXT; typedef struct VkConditionalRenderingBeginInfoEXT { VkStructureType sType; const void* pNext; @@ -15548,6 +16238,285 @@ typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFil #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" +// VK_AMD_gpa_interface is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_gpa_interface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkGpaSessionAMD) +#define VK_AMD_GPA_INTERFACE_SPEC_VERSION 1 +#define VK_AMD_GPA_INTERFACE_EXTENSION_NAME "VK_AMD_gpa_interface" + +typedef enum VkGpaPerfBlockAMD { + VK_GPA_PERF_BLOCK_CPF_AMD = 0, + VK_GPA_PERF_BLOCK_IA_AMD = 1, + VK_GPA_PERF_BLOCK_VGT_AMD = 2, + VK_GPA_PERF_BLOCK_PA_AMD = 3, + VK_GPA_PERF_BLOCK_SC_AMD = 4, + VK_GPA_PERF_BLOCK_SPI_AMD = 5, + VK_GPA_PERF_BLOCK_SQ_AMD = 6, + VK_GPA_PERF_BLOCK_SX_AMD = 7, + VK_GPA_PERF_BLOCK_TA_AMD = 8, + VK_GPA_PERF_BLOCK_TD_AMD = 9, + VK_GPA_PERF_BLOCK_TCP_AMD = 10, + VK_GPA_PERF_BLOCK_TCC_AMD = 11, + VK_GPA_PERF_BLOCK_TCA_AMD = 12, + VK_GPA_PERF_BLOCK_DB_AMD = 13, + VK_GPA_PERF_BLOCK_CB_AMD = 14, + VK_GPA_PERF_BLOCK_GDS_AMD = 15, + VK_GPA_PERF_BLOCK_SRBM_AMD = 16, + VK_GPA_PERF_BLOCK_GRBM_AMD = 17, + VK_GPA_PERF_BLOCK_GRBM_SE_AMD = 18, + VK_GPA_PERF_BLOCK_RLC_AMD = 19, + VK_GPA_PERF_BLOCK_DMA_AMD = 20, + VK_GPA_PERF_BLOCK_MC_AMD = 21, + VK_GPA_PERF_BLOCK_CPG_AMD = 22, + VK_GPA_PERF_BLOCK_CPC_AMD = 23, + VK_GPA_PERF_BLOCK_WD_AMD = 24, + VK_GPA_PERF_BLOCK_TCS_AMD = 25, + VK_GPA_PERF_BLOCK_ATC_AMD = 26, + VK_GPA_PERF_BLOCK_ATC_L2_AMD = 27, + VK_GPA_PERF_BLOCK_MC_VM_L2_AMD = 28, + VK_GPA_PERF_BLOCK_EA_AMD = 29, + VK_GPA_PERF_BLOCK_RPB_AMD = 30, + VK_GPA_PERF_BLOCK_RMI_AMD = 31, + VK_GPA_PERF_BLOCK_UMCCH_AMD = 32, + VK_GPA_PERF_BLOCK_GE_AMD = 33, + VK_GPA_PERF_BLOCK_GL1A_AMD = 34, + VK_GPA_PERF_BLOCK_GL1C_AMD = 35, + VK_GPA_PERF_BLOCK_GL1CG_AMD = 36, + VK_GPA_PERF_BLOCK_GL2A_AMD = 37, + VK_GPA_PERF_BLOCK_GL2C_AMD = 38, + VK_GPA_PERF_BLOCK_CHA_AMD = 39, + VK_GPA_PERF_BLOCK_CHC_AMD = 40, + VK_GPA_PERF_BLOCK_CHCG_AMD = 41, + VK_GPA_PERF_BLOCK_GUS_AMD = 42, + VK_GPA_PERF_BLOCK_GCR_AMD = 43, + VK_GPA_PERF_BLOCK_PH_AMD = 44, + VK_GPA_PERF_BLOCK_UTCL1_AMD = 45, + VK_GPA_PERF_BLOCK_GE_DIST_AMD = 46, + VK_GPA_PERF_BLOCK_GE_SE_AMD = 47, + VK_GPA_PERF_BLOCK_DF_MALL_AMD = 48, + VK_GPA_PERF_BLOCK_SQ_WGP_AMD = 49, + VK_GPA_PERF_BLOCK_PC_AMD = 50, + VK_GPA_PERF_BLOCK_GL1XA_AMD = 51, + VK_GPA_PERF_BLOCK_GL1XC_AMD = 52, + VK_GPA_PERF_BLOCK_WGS_AMD = 53, + VK_GPA_PERF_BLOCK_EACPWD_AMD = 54, + VK_GPA_PERF_BLOCK_EASE_AMD = 55, + VK_GPA_PERF_BLOCK_RLCUSER_AMD = 56, + VK_GPA_PERF_BLOCK_GE1_AMD = VK_GPA_PERF_BLOCK_GE_AMD, + VK_GPA_PERF_BLOCK_RLCLOCAL_AMD = VK_GPA_PERF_BLOCK_RLCUSER_AMD, + VK_GPA_PERF_BLOCK_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaPerfBlockAMD; + +typedef enum VkGpaSampleTypeAMD { + VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD = 0, + VK_GPA_SAMPLE_TYPE_TRACE_AMD = 1, + VK_GPA_SAMPLE_TYPE_TIMING_AMD = 2, + VK_GPA_SAMPLE_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaSampleTypeAMD; + +typedef enum VkGpaDeviceClockModeAMD { + VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD = 0, + VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD = 1, + VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD = 2, + VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD = 3, + VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD = 4, + VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD = 5, + VK_GPA_DEVICE_CLOCK_MODE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaDeviceClockModeAMD; + +typedef enum VkGpaSqShaderStageFlagBitsAMD { + VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD = 0x00000001, + VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD = 0x00000002, + VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD = 0x00000004, + VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD = 0x00000008, + VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD = 0x00000010, + VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD = 0x00000020, + VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD = 0x00000040, + VK_GPA_SQ_SHADER_STAGE_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaSqShaderStageFlagBitsAMD; +typedef VkFlags VkGpaSqShaderStageFlagsAMD; +typedef VkFlags VkGpaPerfBlockPropertiesFlagsAMD; +typedef VkFlags VkPhysicalDeviceGpaPropertiesFlagsAMD; +typedef struct VkGpaPerfBlockPropertiesAMD { + VkGpaPerfBlockAMD blockType; + VkGpaPerfBlockPropertiesFlagsAMD flags; + uint32_t instanceCount; + uint32_t maxEventID; + uint32_t maxGlobalOnlyCounters; + uint32_t maxGlobalSharedCounters; + uint32_t maxStreamingCounters; +} VkGpaPerfBlockPropertiesAMD; + +typedef struct VkPhysicalDeviceGpaFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 perfCounters; + VkBool32 streamingPerfCounters; + VkBool32 sqThreadTracing; + VkBool32 clockModes; +} VkPhysicalDeviceGpaFeaturesAMD; + +typedef struct VkPhysicalDeviceGpaPropertiesAMD { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceGpaPropertiesFlagsAMD flags; + VkDeviceSize maxSqttSeBufferSize; + uint32_t shaderEngineCount; + uint32_t perfBlockCount; + VkGpaPerfBlockPropertiesAMD* pPerfBlocks; +} VkPhysicalDeviceGpaPropertiesAMD; + +typedef struct VkPhysicalDeviceGpaProperties2AMD { + VkStructureType sType; + void* pNext; + uint32_t revisionId; +} VkPhysicalDeviceGpaProperties2AMD; + +typedef struct VkGpaPerfCounterAMD { + VkGpaPerfBlockAMD blockType; + uint32_t blockInstance; + uint32_t eventID; +} VkGpaPerfCounterAMD; + +typedef struct VkGpaSampleBeginInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaSampleTypeAMD sampleType; + VkBool32 sampleInternalOperations; + VkBool32 cacheFlushOnCounterCollection; + VkBool32 sqShaderMaskEnable; + VkGpaSqShaderStageFlagsAMD sqShaderMask; + uint32_t perfCounterCount; + const VkGpaPerfCounterAMD* pPerfCounters; + uint32_t streamingPerfTraceSampleInterval; + VkDeviceSize perfCounterDeviceMemoryLimit; + VkBool32 sqThreadTraceEnable; + VkBool32 sqThreadTraceSuppressInstructionTokens; + VkDeviceSize sqThreadTraceDeviceMemoryLimit; + VkPipelineStageFlags timingPreSample; + VkPipelineStageFlags timingPostSample; +} VkGpaSampleBeginInfoAMD; + +typedef struct VkGpaDeviceClockModeInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaDeviceClockModeAMD clockMode; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; +} VkGpaDeviceClockModeInfoAMD; + +typedef struct VkGpaDeviceGetClockInfoAMD { + VkStructureType sType; + void* pNext; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + uint32_t memoryClockFrequency; + uint32_t engineClockFrequency; +} VkGpaDeviceGetClockInfoAMD; + +typedef struct VkGpaSessionCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaSessionAMD secondaryCopySource; +} VkGpaSessionCreateInfoAMD; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateGpaSessionAMD)(VkDevice device, const VkGpaSessionCreateInfoAMD* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkGpaSessionAMD* pGpaSession); +typedef void (VKAPI_PTR *PFN_vkDestroyGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetGpaDeviceClockModeAMD)(VkDevice device, VkGpaDeviceClockModeInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaDeviceClockInfoAMD)(VkDevice device, VkGpaDeviceGetClockInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkCmdEndGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, uint32_t* pSampleID); +typedef void (VKAPI_PTR *PFN_vkCmdEndGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionStatusAMD)(VkDevice device, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionResultsAMD)(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t* pSizeInBytes, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkResetGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession); +typedef void (VKAPI_PTR *PFN_vkCmdCopyGpaSessionResultsAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGpaSessionAMD( + VkDevice device, + const VkGpaSessionCreateInfoAMD* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkGpaSessionAMD* pGpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyGpaSessionAMD( + VkDevice device, + VkGpaSessionAMD gpaSession, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetGpaDeviceClockModeAMD( + VkDevice device, + VkGpaDeviceClockModeInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaDeviceClockInfoAMD( + VkDevice device, + VkGpaDeviceGetClockInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdBeginGpaSessionAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdEndGpaSessionAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdBeginGpaSampleAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession, + const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, + uint32_t* pSampleID); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndGpaSampleAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession, + uint32_t sampleID); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaSessionStatusAMD( + VkDevice device, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaSessionResultsAMD( + VkDevice device, + VkGpaSessionAMD gpaSession, + uint32_t sampleID, + size_t* pSizeInBytes, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkResetGpaSessionAMD( + VkDevice device, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyGpaSessionResultsAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif +#endif + + // VK_EXT_descriptor_heap is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_descriptor_heap 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM) @@ -15600,10 +16569,7 @@ typedef struct VkHostAddressRangeConstEXT { size_t size; } VkHostAddressRangeConstEXT; -typedef struct VkDeviceAddressRangeEXT { - VkDeviceAddress address; - VkDeviceSize size; -} VkDeviceAddressRangeEXT; +typedef VkDeviceAddressRangeKHR VkDeviceAddressRangeEXT; typedef struct VkTexelBufferDescriptorInfoEXT { VkStructureType sType; @@ -16450,21 +17416,13 @@ typedef enum VkGeometryTypeKHR { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, #endif + VK_GEOMETRY_TYPE_MICROMAP_KHR = 1000623000, VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF } VkGeometryTypeKHR; typedef VkGeometryTypeKHR VkGeometryTypeNV; - -typedef enum VkAccelerationStructureTypeKHR { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, - VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureTypeKHR; typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; @@ -16505,15 +17463,17 @@ typedef enum VkGeometryInstanceFlagBitsKHR { VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000020, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR, // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a legacy alias VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR, // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF @@ -16531,21 +17491,24 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR { VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, #endif VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR = 0x00000400, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a legacy alias @@ -16559,10 +17522,10 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR { VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkBuildAccelerationStructureFlagBitsKHR; typedef VkFlags VkBuildAccelerationStructureFlagsKHR; -typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; - typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; +typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; + typedef struct VkRayTracingShaderGroupCreateInfoNV { VkStructureType sType; const void* pNext; @@ -16626,13 +17589,13 @@ typedef struct VkGeometryNV { } VkGeometryNV; typedef struct VkAccelerationStructureInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeNV type; - VkBuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const VkGeometryNV* pGeometries; + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsKHR flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; } VkAccelerationStructureInfoNV; typedef struct VkAccelerationStructureCreateInfoNV { @@ -16709,7 +17672,7 @@ typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); @@ -16741,7 +17704,7 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements); + VkMemoryRequirements2* pMemoryRequirements); #endif #ifndef VK_ONLY_EXPORTED_PROTOTYPES @@ -16903,6 +17866,18 @@ typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM { +// VK_QCOM_elapsed_timer_query is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_elapsed_timer_query 1 +#define VK_QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION 1 +#define VK_QCOM_ELAPSED_TIMER_QUERY_EXTENSION_NAME "VK_QCOM_elapsed_timer_query" +typedef struct VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 elapsedTimerQuery; +} VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM; + + + // VK_EXT_global_priority is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_global_priority 1 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 @@ -18999,6 +19974,98 @@ typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" +// VK_QCOM_queue_perf_hint is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_queue_perf_hint 1 +#define VK_QCOM_QUEUE_PERF_HINT_SPEC_VERSION 1 +#define VK_QCOM_QUEUE_PERF_HINT_EXTENSION_NAME "VK_QCOM_queue_perf_hint" + +typedef enum VkPerfHintTypeQCOM { + VK_PERF_HINT_TYPE_DEFAULT_QCOM = 0, + VK_PERF_HINT_TYPE_FREQUENCY_MIN_QCOM = 1, + VK_PERF_HINT_TYPE_FREQUENCY_MAX_QCOM = 2, + VK_PERF_HINT_TYPE_FREQUENCY_SCALED_QCOM = 3, + VK_PERF_HINT_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkPerfHintTypeQCOM; +typedef struct VkPerfHintInfoQCOM { + VkStructureType sType; + void* pNext; + VkPerfHintTypeQCOM type; + uint32_t scale; +} VkPerfHintInfoQCOM; + +typedef struct VkPhysicalDeviceQueuePerfHintFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 queuePerfHint; +} VkPhysicalDeviceQueuePerfHintFeaturesQCOM; + +typedef struct VkPhysicalDeviceQueuePerfHintPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceQueuePerfHintPropertiesQCOM; + +typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerfHintQCOM)(VkQueue queue, const VkPerfHintInfoQCOM* pPerfHintInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerfHintQCOM( + VkQueue queue, + const VkPerfHintInfoQCOM* pPerfHintInfo); +#endif +#endif + + +// VK_QCOM_image_processing3 is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_image_processing3 1 +#define VK_QCOM_IMAGE_PROCESSING_3_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_3_EXTENSION_NAME "VK_QCOM_image_processing3" +typedef struct VkPhysicalDeviceImageProcessing3FeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 imageGatherLinear; + VkBool32 imageGatherExtendedModes; + VkBool32 blockMatchExtendedClampToEdge; +} VkPhysicalDeviceImageProcessing3FeaturesQCOM; + + + +// VK_QCOM_shader_multiple_wait_queues is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_shader_multiple_wait_queues 1 +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION 1 +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_EXTENSION_NAME "VK_QCOM_shader_multiple_wait_queues" +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 shaderMultipleWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxShaderWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + + + +// VK_EXT_shader_split_barrier is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_split_barrier 1 +#define VK_EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION 1 +#define VK_EXT_SHADER_SPLIT_BARRIER_EXTENSION_NAME "VK_EXT_shader_split_barrier" +typedef struct VkPhysicalDeviceShaderSplitBarrierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderSplitBarrier; +} VkPhysicalDeviceShaderSplitBarrierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderSplitBarrierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t splitBarrierReservedSharedMemory; +} VkPhysicalDeviceShaderSplitBarrierPropertiesEXT; + + + // VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_tile_shading 1 #define VK_QCOM_TILE_SHADING_SPEC_VERSION 2 @@ -19099,7 +20166,6 @@ typedef struct VkQueryLowLatencySupportNV { // VK_EXT_descriptor_buffer is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_descriptor_buffer 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) #define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 #define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { @@ -19140,12 +20206,6 @@ typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { VkDeviceSize descriptorBufferAddressSpaceSize; } VkPhysicalDeviceDescriptorBufferPropertiesEXT; -typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - size_t combinedImageSamplerDensityMapDescriptorSize; -} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { VkStructureType sType; void* pNext; @@ -19233,6 +20293,12 @@ typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { VkAccelerationStructureNV accelerationStructureNV; } VkAccelerationStructureCaptureDescriptorDataInfoEXT; +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); @@ -19677,22 +20743,10 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { #define VK_EXT_device_fault 1 #define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 #define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" +typedef VkDeviceFaultAddressTypeKHR VkDeviceFaultAddressTypeEXT; + +typedef VkDeviceFaultVendorBinaryHeaderVersionKHR VkDeviceFaultVendorBinaryHeaderVersionEXT; -typedef enum VkDeviceFaultAddressTypeEXT { - VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, - VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, - VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, - VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, - VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultAddressTypeEXT; - -typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultVendorBinaryHeaderVersionEXT; typedef struct VkPhysicalDeviceFaultFeaturesEXT { VkStructureType sType; void* pNext; @@ -19708,40 +20762,20 @@ typedef struct VkDeviceFaultCountsEXT { VkDeviceSize vendorBinarySize; } VkDeviceFaultCountsEXT; -typedef struct VkDeviceFaultAddressInfoEXT { - VkDeviceFaultAddressTypeEXT addressType; - VkDeviceAddress reportedAddress; - VkDeviceSize addressPrecision; -} VkDeviceFaultAddressInfoEXT; - -typedef struct VkDeviceFaultVendorInfoEXT { - char description[VK_MAX_DESCRIPTION_SIZE]; - uint64_t vendorFaultCode; - uint64_t vendorFaultData; -} VkDeviceFaultVendorInfoEXT; - typedef struct VkDeviceFaultInfoEXT { VkStructureType sType; void* pNext; char description[VK_MAX_DESCRIPTION_SIZE]; - VkDeviceFaultAddressInfoEXT* pAddressInfos; - VkDeviceFaultVendorInfoEXT* pVendorInfos; + VkDeviceFaultAddressInfoKHR* pAddressInfos; + VkDeviceFaultVendorInfoKHR* pVendorInfos; void* pVendorBinaryData; } VkDeviceFaultInfoEXT; -typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { - uint32_t headerSize; - VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint32_t driverVersion; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - uint32_t applicationNameOffset; - uint32_t applicationVersion; - uint32_t engineNameOffset; - uint32_t engineVersion; - uint32_t apiVersion; -} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; +typedef VkDeviceFaultAddressInfoKHR VkDeviceFaultAddressInfoEXT; + +typedef VkDeviceFaultVendorInfoKHR VkDeviceFaultVendorInfoEXT; + +typedef VkDeviceFaultVendorBinaryHeaderVersionOneKHR VkDeviceFaultVendorBinaryHeaderVersionOneEXT; typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); @@ -20055,13 +21089,13 @@ typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { VkBool32 pipelinePropertiesIdentifier; } VkPhysicalDevicePipelinePropertiesFeaturesEXT; -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); #ifndef VK_NO_PROTOTYPES #ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, + const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); #endif #endif @@ -20422,21 +21456,10 @@ typedef enum VkCopyMicromapModeEXT { VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF } VkCopyMicromapModeEXT; +typedef VkOpacityMicromapFormatKHR VkOpacityMicromapFormatEXT; + +typedef VkOpacityMicromapSpecialIndexKHR VkOpacityMicromapSpecialIndexEXT; -typedef enum VkOpacityMicromapFormatEXT { - VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, - VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, - VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapFormatEXT; - -typedef enum VkOpacityMicromapSpecialIndexEXT { - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapSpecialIndexEXT; typedef enum VkAccelerationStructureCompatibilityKHR { VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, @@ -20568,26 +21591,22 @@ typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { VkMicromapEXT micromap; } VkAccelerationStructureTrianglesOpacityMicromapEXT; -typedef struct VkMicromapTriangleEXT { - uint32_t dataOffset; - uint16_t subdivisionLevel; - uint16_t format; -} VkMicromapTriangleEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); -typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); +typedef VkMicromapTriangleKHR VkMicromapTriangleEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); #ifndef VK_NO_PROTOTYPES #ifndef VK_ONLY_EXPORTED_PROTOTYPES @@ -20808,13 +21827,14 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesARM { // VK_ARM_scheduling_controls is a preprocessor guard. Do not pass it to API calls. #define VK_ARM_scheduling_controls 1 -#define VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION 1 +#define VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION 2 #define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls" typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; // Flag bits for VkPhysicalDeviceSchedulingControlsFlagBitsARM typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM; static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ULL; +static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_ARM = 0x00000002ULL; typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { VkStructureType sType; @@ -20834,6 +21854,31 @@ typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM { VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; } VkPhysicalDeviceSchedulingControlsPropertiesARM; +typedef struct VkDispatchParametersARM { + VkStructureType sType; + void* pNext; + uint32_t workGroupBatchSize; + uint32_t maxQueuedWorkGroupBatches; + uint32_t maxWarpsPerShaderCore; +} VkDispatchParametersARM; + +typedef struct VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t schedulingControlsMaxWarpsCount; + uint32_t schedulingControlsMaxQueuedBatchesCount; + uint32_t schedulingControlsMaxWorkGroupBatchSize; +} VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDispatchParametersARM)(VkCommandBuffer commandBuffer, const VkDispatchParametersARM* pDispatchParameters); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDispatchParametersARM( + VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters); +#endif +#endif // VK_EXT_image_sliced_view_of_3d is a preprocessor guard. Do not pass it to API calls. @@ -21047,11 +22092,11 @@ typedef VkFlags64 VkMemoryDecompressionMethodFlagsEXT; typedef VkMemoryDecompressionMethodFlagsEXT VkMemoryDecompressionMethodFlagsNV; typedef struct VkDecompressMemoryRegionNV { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize compressedSize; - VkDeviceSize decompressedSize; - VkMemoryDecompressionMethodFlagsNV decompressionMethod; + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; + VkMemoryDecompressionMethodFlagsEXT decompressionMethod; } VkDecompressMemoryRegionNV; typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT { @@ -22315,6 +23360,7 @@ typedef enum VkDepthClampModeEXT { typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT = 0x00000400, + VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM = 0x00000800, VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, @@ -22322,7 +23368,9 @@ typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, + VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT = 0x00001000, VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, + VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR = 0x00040000, VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkShaderCreateFlagBitsEXT; typedef VkFlags VkShaderCreateFlagsEXT; @@ -22864,6 +23912,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) typedef enum VkDataGraphPipelineSessionBindPointARM { VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM = 1000631001, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_NEURAL_ACCELERATOR_STATISTICS_ARM = 1000676000, VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF } VkDataGraphPipelineSessionBindPointARM; @@ -22875,6 +23925,8 @@ typedef enum VkDataGraphPipelineSessionBindPointTypeARM { typedef enum VkDataGraphPipelinePropertyARM { VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM = 1000676000, + VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_STATISTICS_INFO_ARM = 1000676001, VK_DATA_GRAPH_PIPELINE_PROPERTY_MAX_ENUM_ARM = 0x7FFFFFFF } VkDataGraphPipelinePropertyARM; @@ -22889,6 +23941,7 @@ typedef enum VkPhysicalDeviceDataGraphOperationTypeARM { VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM = 1000631000, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF } VkPhysicalDeviceDataGraphOperationTypeARM; typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; @@ -22896,6 +23949,7 @@ typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; // Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL; +static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM = 0x00000002ULL; typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; @@ -22936,7 +23990,7 @@ typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM { typedef struct VkDataGraphPipelineCreateInfoARM { VkStructureType sType; const void* pNext; - VkPipelineCreateFlags2KHR flags; + VkPipelineCreateFlags2 flags; VkPipelineLayout layout; uint32_t resourceInfoCount; const VkDataGraphPipelineResourceInfoARM* pResourceInfos; @@ -23167,6 +24221,54 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEngi #endif +// VK_ARM_data_graph_instruction_set_tosa is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph_instruction_set_tosa 1 +#define VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM 128U +#define VK_ARM_DATA_GRAPH_INSTRUCTION_SET_TOSA_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_INSTRUCTION_SET_TOSA_EXTENSION_NAME "VK_ARM_data_graph_instruction_set_tosa" + +typedef enum VkDataGraphTOSALevelARM { + VK_DATA_GRAPH_TOSA_LEVEL_NONE_ARM = 0, + VK_DATA_GRAPH_TOSA_LEVEL_8K_ARM = 1, + VK_DATA_GRAPH_TOSALEVEL_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphTOSALevelARM; + +typedef enum VkDataGraphTOSAQualityFlagBitsARM { + VK_DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM = 0x00000001, + VK_DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM = 0x00000002, + VK_DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM = 0x00000004, + VK_DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM = 0x00000008, + VK_DATA_GRAPH_TOSAQUALITY_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphTOSAQualityFlagBitsARM; +typedef VkFlags VkDataGraphTOSAQualityFlagsARM; +typedef struct VkDataGraphTOSANameQualityARM { + char name[VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM]; + VkDataGraphTOSAQualityFlagsARM qualityFlags; +} VkDataGraphTOSANameQualityARM; + +typedef struct VkQueueFamilyDataGraphTOSAPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t profileCount; + const VkDataGraphTOSANameQualityARM* pProfiles; + uint32_t extensionCount; + const VkDataGraphTOSANameQualityARM* pExtensions; + VkDataGraphTOSALevelARM level; +} VkQueueFamilyDataGraphTOSAPropertiesARM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, VkBaseOutStructure* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + VkBaseOutStructure* pProperties); +#endif +#endif + + // VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_multiview_per_view_render_areas 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 @@ -24310,7 +25412,7 @@ typedef struct VkPhysicalDevicePushConstantBankPropertiesNV { // VK_EXT_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_ray_tracing_invocation_reorder 1 -#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 +#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 2 #define VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_EXT_ray_tracing_invocation_reorder" typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT { VkStructureType sType; @@ -24486,6 +25588,103 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCo #endif +// VK_ARM_shader_instrumentation is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_shader_instrumentation 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderInstrumentationARM) +#define VK_ARM_SHADER_INSTRUMENTATION_SPEC_VERSION 1 +#define VK_ARM_SHADER_INSTRUMENTATION_EXTENSION_NAME "VK_ARM_shader_instrumentation" +typedef VkFlags VkShaderInstrumentationValuesFlagsARM; +typedef struct VkPhysicalDeviceShaderInstrumentationFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 shaderInstrumentation; +} VkPhysicalDeviceShaderInstrumentationFeaturesARM; + +typedef struct VkPhysicalDeviceShaderInstrumentationPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t numMetrics; + VkBool32 perBasicBlockGranularity; +} VkPhysicalDeviceShaderInstrumentationPropertiesARM; + +typedef struct VkShaderInstrumentationCreateInfoARM { + VkStructureType sType; + void* pNext; +} VkShaderInstrumentationCreateInfoARM; + +typedef struct VkShaderInstrumentationMetricDescriptionARM { + VkStructureType sType; + void* pNext; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkShaderInstrumentationMetricDescriptionARM; + +typedef struct VkShaderInstrumentationMetricDataHeaderARM { + uint32_t resultIndex; + uint32_t resultSubIndex; + VkShaderStageFlags stages; + uint32_t basicBlockIndex; +} VkShaderInstrumentationMetricDataHeaderARM; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM)(VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderInstrumentationARM)(VkDevice device, const VkShaderInstrumentationCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderInstrumentationARM* pInstrumentation); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderInstrumentationARM)(VkDevice device, VkShaderInstrumentationARM instrumentation, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBeginShaderInstrumentationARM)(VkCommandBuffer commandBuffer, VkShaderInstrumentationARM instrumentation); +typedef void (VKAPI_PTR *PFN_vkCmdEndShaderInstrumentationARM)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInstrumentationValuesARM)(VkDevice device, VkShaderInstrumentationARM instrumentation, uint32_t* pMetricBlockCount, void* pMetricValues, VkShaderInstrumentationValuesFlagsARM flags); +typedef void (VKAPI_PTR *PFN_vkClearShaderInstrumentationMetricsARM)(VkDevice device, VkShaderInstrumentationARM instrumentation); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM( + VkPhysicalDevice physicalDevice, + uint32_t* pDescriptionCount, + VkShaderInstrumentationMetricDescriptionARM* pDescriptions); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderInstrumentationARM( + VkDevice device, + const VkShaderInstrumentationCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderInstrumentationARM* pInstrumentation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderInstrumentationARM( + VkDevice device, + VkShaderInstrumentationARM instrumentation, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginShaderInstrumentationARM( + VkCommandBuffer commandBuffer, + VkShaderInstrumentationARM instrumentation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndShaderInstrumentationARM( + VkCommandBuffer commandBuffer); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInstrumentationValuesARM( + VkDevice device, + VkShaderInstrumentationARM instrumentation, + uint32_t* pMetricBlockCount, + void* pMetricValues, + VkShaderInstrumentationValuesFlagsARM flags); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkClearShaderInstrumentationMetricsARM( + VkDevice device, + VkShaderInstrumentationARM instrumentation); +#endif +#endif + + // VK_EXT_vertex_attribute_robustness is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_vertex_attribute_robustness 1 #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 @@ -24662,6 +25861,159 @@ typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM { +// VK_ARM_data_graph_optical_flow is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph_optical_flow 1 +#define VK_ARM_DATA_GRAPH_OPTICAL_FLOW_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_OPTICAL_FLOW_EXTENSION_NAME "VK_ARM_data_graph_optical_flow" + +typedef enum VkDataGraphOpticalFlowPerformanceLevelARM { + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM = 1, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM = 2, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM = 3, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowPerformanceLevelARM; + +typedef enum VkDataGraphPipelineNodeTypeARM { + VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM = 1000631000, + VK_DATA_GRAPH_PIPELINE_NODE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineNodeTypeARM; + +typedef enum VkDataGraphPipelineNodeConnectionTypeARM { + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM = 1000631000, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM = 1000631001, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM = 1000631002, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM = 1000631003, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM = 1000631004, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineNodeConnectionTypeARM; + +typedef enum VkDataGraphOpticalFlowGridSizeFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowGridSizeFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowGridSizeFlagsARM; + +typedef enum VkDataGraphOpticalFlowCreateFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM = 0x40000000, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowCreateFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowCreateFlagsARM; + +typedef enum VkDataGraphOpticalFlowImageUsageFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowImageUsageFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowImageUsageFlagsARM; + +typedef enum VkDataGraphOpticalFlowExecuteFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM = 0x00000010, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowExecuteFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowExecuteFlagsARM; +typedef struct VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraphOpticalFlow; +} VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM; + +typedef struct VkQueueFamilyDataGraphOpticalFlowPropertiesARM { + VkStructureType sType; + void* pNext; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedOutputGridSizes; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; +} VkQueueFamilyDataGraphOpticalFlowPropertiesARM; + +typedef struct VkDataGraphPipelineOpticalFlowCreateInfoARM { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkDataGraphOpticalFlowGridSizeFlagsARM outputGridSize; + VkDataGraphOpticalFlowGridSizeFlagsARM hintGridSize; + VkDataGraphOpticalFlowPerformanceLevelARM performanceLevel; + VkDataGraphOpticalFlowCreateFlagsARM flags; +} VkDataGraphPipelineOpticalFlowCreateInfoARM; + +typedef struct VkDataGraphOpticalFlowImageFormatPropertiesARM { + VkStructureType sType; + void* pNext; + VkFormat format; +} VkDataGraphOpticalFlowImageFormatPropertiesARM; + +typedef struct VkDataGraphOpticalFlowImageFormatInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphOpticalFlowImageUsageFlagsARM usage; +} VkDataGraphOpticalFlowImageFormatInfoARM; + +typedef struct VkDataGraphPipelineOpticalFlowDispatchInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphOpticalFlowExecuteFlagsARM flags; + uint32_t meanFlowL1NormHint; +} VkDataGraphPipelineOpticalFlowDispatchInfoARM; + +typedef struct VkDataGraphPipelineResourceInfoImageLayoutARM { + VkStructureType sType; + const void* pNext; + VkImageLayout layout; +} VkDataGraphPipelineResourceInfoImageLayoutARM; + +typedef struct VkDataGraphPipelineSingleNodeConnectionARM { + VkStructureType sType; + void* pNext; + uint32_t set; + uint32_t binding; + VkDataGraphPipelineNodeConnectionTypeARM connection; +} VkDataGraphPipelineSingleNodeConnectionARM; + +typedef struct VkDataGraphPipelineSingleNodeCreateInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelineNodeTypeARM nodeType; + uint32_t connectionCount; + const VkDataGraphPipelineSingleNodeConnectionARM* pConnections; +} VkDataGraphPipelineSingleNodeCreateInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); +#endif +#endif + + // VK_EXT_shader_long_vector is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_shader_long_vector 1 #define VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION 1 @@ -24762,6 +26114,83 @@ typedef struct VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE { +// VK_SEC_throttle_hint is a preprocessor guard. Do not pass it to API calls. +#define VK_SEC_throttle_hint 1 +#define VK_SEC_THROTTLE_HINT_SPEC_VERSION 1 +#define VK_SEC_THROTTLE_HINT_EXTENSION_NAME "VK_SEC_throttle_hint" + +typedef enum VkThrottleHintTypeSEC { + VK_THROTTLE_HINT_TYPE_DEFAULT_SEC = 0, + VK_THROTTLE_HINT_TYPE_LOW_SEC = 1, + VK_THROTTLE_HINT_TYPE_HIGH_SEC = 2, + VK_THROTTLE_HINT_TYPE_MAX_ENUM_SEC = 0x7FFFFFFF +} VkThrottleHintTypeSEC; +typedef struct VkThrottleHintSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + VkThrottleHintTypeSEC throttleHint; +} VkThrottleHintSubmitInfoSEC; + +typedef struct VkPhysicalDeviceThrottleHintFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 throttleHint; +} VkPhysicalDeviceThrottleHintFeaturesSEC; + + + +// VK_ARM_data_graph_neural_accelerator_statistics is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph_neural_accelerator_statistics 1 +#define VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_EXTENSION_NAME "VK_ARM_data_graph_neural_accelerator_statistics" + +typedef enum VkNeuralAcceleratorStatisticsModeARM { + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_DISABLED_ARM = 0, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS0_ARM = 1, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS1_ARM = 2, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkNeuralAcceleratorStatisticsModeARM; +typedef struct VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraphNeuralAcceleratorStatistics; +} VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + +typedef struct VkDataGraphPipelineNeuralStatisticsCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkBool32 allowNeuralStatistics; +} VkDataGraphPipelineNeuralStatisticsCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkNeuralAcceleratorStatisticsModeARM mode; +} VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + + + +// VK_EXT_primitive_restart_index is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_primitive_restart_index 1 +#define VK_EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION 1 +#define VK_EXT_PRIMITIVE_RESTART_INDEX_EXTENSION_NAME "VK_EXT_primitive_restart_index" +typedef struct VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitiveRestartIndex; +} VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartIndexEXT)(VkCommandBuffer commandBuffer, uint32_t primitiveRestartIndex); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartIndexEXT( + VkCommandBuffer commandBuffer, + uint32_t primitiveRestartIndex); +#endif +#endif + + // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_acceleration_structure 1 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 @@ -24772,14 +26201,6 @@ typedef enum VkBuildAccelerationStructureModeKHR { VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF } VkBuildAccelerationStructureModeKHR; - -typedef enum VkAccelerationStructureCreateFlagBitsKHR { - VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, - VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, - VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCreateFlagBitsKHR; -typedef VkFlags VkAccelerationStructureCreateFlagsKHR; typedef struct VkAccelerationStructureBuildRangeInfoKHR { uint32_t primitiveCount; uint32_t primitiveOffset; From f3896727177c47abad54304976a6a6599cea88f3 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 13:38:57 +0200 Subject: [PATCH 09/17] Update extension ban table. Should be parsed from XML at some point ... --- cli/device.cpp | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/cli/device.cpp b/cli/device.cpp index f878fa72..e6921876 100644 --- a/cli/device.cpp +++ b/cli/device.cpp @@ -65,13 +65,33 @@ static bool filter_instance_extension(const char *ext, uint32_t api_version) static bool filter_extension(const char *ext, bool want_amd_shader_info, const vector &all_exts, uint32_t api_version) { + // TODO: Possible to autogen this table? :| static const char *vulkan_11_only_extensions[] = { VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, VK_KHR_SPIRV_1_4_EXTENSION_NAME, VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, + VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME, + VK_KHR_OPACITY_MICROMAP_EXTENSION_NAME, + VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME, VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME, + VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME, + VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME, + VK_KHR_PIPELINE_BINARY_EXTENSION_NAME, + VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, + VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME, + VK_KHR_VIDEO_QUEUE_EXTENSION_NAME, + VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME, + VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME, + VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME, + VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, + VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME, + VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME, + VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME, + VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME, + VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME, VK_KHR_RAY_QUERY_EXTENSION_NAME, VK_KHR_MAINTENANCE_4_EXTENSION_NAME, VK_KHR_MAINTENANCE_5_EXTENSION_NAME, @@ -86,6 +106,20 @@ static bool filter_extension(const char *ext, bool want_amd_shader_info, VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME, VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME, + VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME, + VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME, + VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME, + VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME, + VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME, + VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME, + VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME, + VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME, + VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME, }; static const char *vulkan_12_only_extensions[] = { From 9da5a2c6c32582f90e9d7add2521216c0e9a66dc Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 14:44:29 +0200 Subject: [PATCH 10/17] Report global pipeline binary key in replayer too. --- cli/device.cpp | 30 ++++++++++++++++++++++ cli/device.hpp | 1 + cli/fossilize_validate_cache_roundtrip.cpp | 21 ++++++++++----- 3 files changed, 46 insertions(+), 6 deletions(-) diff --git a/cli/device.cpp b/cli/device.cpp index e6921876..d0a9a4b8 100644 --- a/cli/device.cpp +++ b/cli/device.cpp @@ -228,6 +228,13 @@ static bool application_info_promote_fragment_shading_rate(const VkApplicationIn return false; } +static void pipeline_binary_key_to_str(char (&str)[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1], const VkPipelineBinaryKeyKHR &key) +{ + str[0] = '\0'; + for (uint32_t i = 0; i < key.keySize; i++) + sprintf(str + 2 * i, "%02x", key.key[i]); +} + bool VulkanDevice::init_device(const Options &opts) { if (opts.null_device) @@ -523,6 +530,16 @@ bool VulkanDevice::init_device(const Options &opts) supports_module_identifiers = features.shader_module_identifier.shaderModuleIdentifier == VK_TRUE; + VkPhysicalDevicePipelineBinaryFeaturesKHR pipeline_binary_features = + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, gpu_features2.pNext, VK_TRUE }; + + supports_pipeline_binary = find_if(begin(active_device_extensions), end(active_device_extensions), [](const char *ext) { + return strcmp(ext, VK_KHR_PIPELINE_BINARY_EXTENSION_NAME) == 0; + }) != end(active_device_extensions); + + if (supports_pipeline_binary) + gpu_features2.pNext = &pipeline_binary_features; + VkDeviceCreateInfo device_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; device_info.pNext = has_device_features2 ? &gpu_features2 : nullptr; device_info.pEnabledFeatures = has_device_features2 ? nullptr : &gpu_features2.features; @@ -545,6 +562,19 @@ bool VulkanDevice::init_device(const Options &opts) return false; } + volkLoadDevice(device); + + if (supports_pipeline_binary) + { + VkPipelineBinaryKeyKHR key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + if (vkGetPipelineKeyKHR(device, nullptr, &key) == VK_SUCCESS) + { + char str[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1]; + pipeline_binary_key_to_str(str, key); + LOGI("Replayer global pipeline binary key: %s\n", str); + } + } + if (!feature_filter.init(api_version, active_device_extensions.data(), active_device_extensions.size(), &gpu_features2, &gpu_props2)) { diff --git a/cli/device.hpp b/cli/device.hpp index 193fce21..c99e45d5 100644 --- a/cli/device.hpp +++ b/cli/device.hpp @@ -131,6 +131,7 @@ class VulkanDevice : public DeviceQueryInterface bool supports_pipeline_feedback = false; bool supports_pipeline_cache_control = false; bool supports_module_identifiers = false; + bool supports_pipeline_binary = false; void init_null_device(); bool is_null_device = false; diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index 5d8040a2..d4a5bcf5 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -74,6 +74,13 @@ static VkInstance create_instance() return instance; } +static void pipeline_binary_key_to_str(char (&str)[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1], const VkPipelineBinaryKeyKHR &key) +{ + str[0] = '\0'; + for (uint32_t i = 0; i < key.keySize; i++) + sprintf(str + 2 * i, "%02x", key.key[i]); +} + static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures &features, bool pipeline_binary_key) { // Just pick the first GPU. Could be improved if needed. @@ -145,11 +152,10 @@ static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeature LOGE("Failed to get the global pipeline binary key.\n"); return VK_NULL_HANDLE; } - uint32_t key_values[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR / sizeof(uint32_t)] = {}; - memcpy(key_values, key.key, key.keySize); - LOGI("Global pipeline binary key: %08x%08x%08x%08x%08x%08x%08x%08x\n", - key_values[0], key_values[1], key_values[2], key_values[3], - key_values[4], key_values[5], key_values[6], key_values[7]); + + char str[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1]; + pipeline_binary_key_to_str(str, key); + LOGI("Global pipeline binary key: %s\n", str); } return device; @@ -561,8 +567,11 @@ static bool check_replayer_roundtrip(const std::string &replayer, const char *fo hits = parse_number_end_of_line(line); else if (strstr(line, "Pipeline cache misses reported")) misses = parse_number_end_of_line(line); - else if (strncmp(line, "Fossilize ERROR:", strlen("Fossilize ERROR:")) == 0) + else if (strncmp(line, "Fossilize ERROR:", strlen("Fossilize ERROR:")) == 0 || + strstr(line, "Replayer global pipeline binary key:")) + { fprintf(stderr, "%s", line); + } } fclose(file); From 96ae9b6a30dd8aa7be0c747e340aba85c5b797c6 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 14:59:07 +0200 Subject: [PATCH 11/17] Remove VK_KHR_robustness2 if features are not used. --- cli/fossilize_feature_filter.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/cli/fossilize_feature_filter.cpp b/cli/fossilize_feature_filter.cpp index 68254c9a..c3f9dc8a 100644 --- a/cli/fossilize_feature_filter.cpp +++ b/cli/fossilize_feature_filter.cpp @@ -387,6 +387,7 @@ static void filter_active_extensions(VkPhysicalDeviceFeatures2 &pdf, feature->robustImageAccess2 == VK_FALSE) { remove_extension(active_extensions, out_extension_count, VK_EXT_ROBUSTNESS_2_EXTENSION_NAME); + remove_extension(active_extensions, out_extension_count, VK_KHR_ROBUSTNESS_2_EXTENSION_NAME); accept = false; } break; From e5f68c5f69975c9589119ae857dd879e31669ba2 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 15:00:16 +0200 Subject: [PATCH 12/17] Tighten up the robustness feature additions. --- cli/fossilize_validate_cache_roundtrip.cpp | 30 ++++++++++------------ 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index d4a5bcf5..0489f4e3 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -81,7 +81,7 @@ static void pipeline_binary_key_to_str(char (&str)[VK_MAX_PIPELINE_BINARY_KEY_SI sprintf(str + 2 * i, "%02x", key.key[i]); } -static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures &features, bool pipeline_binary_key) +static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeatures2 &features2_base, bool pipeline_binary_key) { // Just pick the first GPU. Could be improved if needed. uint32_t count = 1; @@ -108,15 +108,7 @@ static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeature VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, nullptr, VK_TRUE }; - VkPhysicalDeviceRobustness2FeaturesEXT robustness2 = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, nullptr, - VK_TRUE, VK_TRUE, VK_TRUE - }; - - if (features.robustBufferAccess) - binary.pNext = &robustness2; - - VkPhysicalDeviceFeatures2 features2 = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, &binary, features }; + auto features2 = features2_base; device_info.pNext = &features2; static const char *extensions[] = { @@ -130,10 +122,13 @@ static VkDevice create_device(VkInstance instance, const VkPhysicalDeviceFeature if (pipeline_binary_key) { + binary.pNext = features2.pNext; + features2.pNext = &binary; + device_info.ppEnabledExtensionNames = extensions; - device_info.enabledExtensionCount = features.robustBufferAccess ? 6 : 5; + device_info.enabledExtensionCount = features2.features.robustBufferAccess ? 6 : 5; } - else + else if (features2.features.robustBufferAccess) { device_info.ppEnabledExtensionNames = extensions + 5; device_info.enabledExtensionCount = 1; @@ -651,10 +646,13 @@ int main(int argc, char **argv) VkInstance instance = create_instance(); - VkPhysicalDeviceFeatures features = {}; - features.robustBufferAccess = robustness; + VkPhysicalDeviceRobustness2FeaturesKHR robustness2 = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, nullptr, + VK_TRUE, VK_TRUE, VK_TRUE, + }; + VkPhysicalDeviceFeatures2 features2 = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, robustness ? &robustness2 : nullptr, { robustness } }; - VkDevice device = create_device(instance, features, pipeline_binary_key); + VkDevice device = create_device(instance, features2, pipeline_binary_key); VkPipelineCache cache = create_pipeline_cache(device); char tmp_foz[PATH_MAX]; @@ -671,7 +669,7 @@ int main(int argc, char **argv) if (!recorder.record_application_info(app_info)) return EXIT_FAILURE; - if (!recorder.record_physical_device_features(features)) + if (!recorder.record_physical_device_features(&features2)) return EXIT_FAILURE; ret = record_foz_and_cache(device, cache, recorder); From 7f134f5a59d8358afe56a197889bcc5ac08aee0a Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 15:02:18 +0200 Subject: [PATCH 13/17] Add --robustness help to roundtripper. --- cli/fossilize_validate_cache_roundtrip.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index 0489f4e3..ea6bd8cd 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -39,6 +39,7 @@ static void print_help() LOGI("fossilize-validate-cache-roundtrip\n" "\t[--help]\n" "\t[--fossilize-replay ]\n" + "\t[--robustness]\n" "\t[--pipeline-binary-key]\n"); } From 79cf458bbce59ae25951f98f23c54c3aa8a38e1e Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Tue, 4 Aug 2026 16:20:29 +0200 Subject: [PATCH 14/17] Add a script that autogenerates code for sifter. --- extract_vulkan_extensions_sifter.py | 217 ++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100755 extract_vulkan_extensions_sifter.py diff --git a/extract_vulkan_extensions_sifter.py b/extract_vulkan_extensions_sifter.py new file mode 100755 index 00000000..2c72b883 --- /dev/null +++ b/extract_vulkan_extensions_sifter.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python3 + +import argparse +from collections import namedtuple +import xml.etree.ElementTree as ET +import json +import sys + +StructType = namedtuple('StructType', ['extends', 'member_types']) +EnumType = namedtuple('EnumType', ['extensions']) + +def traverse_active_struct_type(active_types, t, mapping): + if t not in mapping: + return + if t in active_types: + return + active_types.add(t) + for m in mapping[t].member_types: + traverse_active_struct_type(active_types, m, mapping) + +def traverse_active_struct_types(base_types, mapping): + active_types = set() + for t in base_types: + traverse_active_struct_type(active_types, t, mapping) + return active_types + +def struct_extends_any(active_types, t, mappings): + if t not in mappings: + return False + for e in mappings[t].extends: + if e in active_types or struct_extends_any(active_types, e, mappings): + return True + return False + +def find_extending_structs(active_types, mappings): + extending_structs = set() + for m in mappings.keys(): + if struct_extends_any(active_types, m, mappings): + for memb in traverse_active_struct_types([m], mappings): + extending_structs.add(memb) + return extending_structs + +def find_active_enum_types(active_types, extending_types, mappings, enum_types, bitmask_reqs): + active_enum_types = set() + + for t in active_types: + for m in mappings[t].member_types: + if m in bitmask_reqs: + active_enum_types.add(bitmask_reqs[m]) + elif m in enum_types: + active_enum_types.add(m) + + for t in extending_types: + for m in mappings[t].member_types: + if m in bitmask_reqs: + active_enum_types.add(bitmask_reqs[m]) + elif m in enum_types: + active_enum_types.add(m) + + return active_enum_types + +def main(): + parser = argparse.ArgumentParser(description = 'Script for extracting what needs to be sifted through w.r.t. PDF2.') + parser.add_argument('--xml', help = 'Path to Vulkan registry XML.') + args = parser.parse_args() + if not args.xml: + sys.stderr.write('Need XML.\n') + sys.exit(1) + + tree = ET.parse(args.xml) + root = tree.getroot() + + struct_types = {} + enum_types = {} + bitmask_requirements = {} + type_aliases = {} + feature_structs = {} + + for t in root.find('types').iter('type'): + if 'alias' in t.attrib: + type_aliases[t.attrib['name']] = t.attrib['alias'] + + pNextLUT = [] + + for t in root.find('types').iter('type'): + if 'category' not in t.attrib: + continue + category = t.attrib['category'] + if category == 'struct': + name = t.attrib['name'] + member_types = [] + extended_types = set() + extends = set() + if 'structextends' in t.attrib: + extends = t.attrib['structextends'].split(',') + extends = set([type_aliases.get(x, x) for x in extends]) + if ('VkPhysicalDeviceFeatures2' in extends) or ('VkPhysicalDeviceFeatures2KHR' in extends): + stype = t.find('member').attrib['values'] + if name not in type_aliases: + pNextLUT.append((stype, name)) + feature_structs[name] = stype + + print('#pragma once') + print('// Autogenerated from extract_vulkan_extensions_sifter.py') + + print('static const struct {') + print('\tVkStructureType sType;') + print('\tsize_t size;') + print('} pNextLUT[] = {') + for entry in pNextLUT: + print('\t{', entry[0], ',', f'sizeof({name})', '},') + print('};\n') + + print('struct ExtensionRequirements {') + print('\tvoid *primary_feature;') + print('\tvoid *secondary_feature;') + print('\tconst char * const *extension_dependencies;') + print('\tuint32_t num_extension_dependencies;') + print('\tuint32_t minimum_api_version;') + print('};\n') + + member_names = [] + print('struct ExistingFeatureStructs {') + for feat in feature_structs: + print(f'\t{feat} {feat[16:]} =', '{', feature_structs[feat], '};') + member_names.append(feat[16:]) + + info_impl = [] + + for ext in root.find('extensions').iter('extension'): + if ('vulkan' in ext.attrib['supported'].split(',')) and (ext.attrib['type'] == 'device'): + ext_name = ext.attrib['name'] + deps = ext.attrib['depends'] if 'depends' in ext.attrib else None + + if 'ANDROID' in ext_name: + continue + if 'AMDX' in ext_name: + continue + + core_dep = 'VK_VERSION_1_0' + ext_deps = [] + + # Crude parsing. Don't want to implement basic grammar here, so just do + # the minimal hackery needed to parse the xml. + if deps: + or_deps = deps.split(',') + and_deps = deps.split('+') + + has_core_dep = False + if len(or_deps) > 1: + for dep in or_deps: + if ('VK_VERSION' in dep) and ('+' not in dep) and ('(' not in dep) and (')' not in dep): + if dep > core_dep: + core_dep = dep + has_core_dep = True + + if not has_core_dep: + for dep in and_deps: + while dep[0] == '(': + dep = dep[1:] + while dep[-1] == ')': + dep = dep[:-1] + or_deps = dep.split(',') + has_core_dep = False + for subdep in or_deps: + if 'VK_VERSION' in subdep: + if subdep > core_dep: + core_dep = subdep + has_core_dep = True + break + if not has_core_dep: + ext_deps.append(subdep) + + features = [] + for reqs in ext.iter('require'): + for t in reqs.iter('type'): + type_name = t.attrib['name'] + type_name = type_aliases.get(type_name, type_name) + if (type_name in feature_structs) and (type_name not in features): + features.append(type_name) + + info_impl.append(f'if (ext == "{ext_name}")' + ' {') + info_impl.append('\tdep = {};') + info_impl.append(f'\tdep.minimum_api_version = {core_dep};') + if len(ext_deps) != 0: + info_impl.append('\tstatic const char * const exts[] = { ' + ', '.join([f'"{e}"' for e in ext_deps]) + ' };') + info_impl.append('\tdep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0]));') + info_impl.append('\tdep.extension_dependencies = exts;') + if len(features) >= 1: + info_impl.append(f'\tdep.primary_feature = &{features[0][16:]};') + if len(features) >= 2: + info_impl.append(f'\tdep.secondary_feature = &{features[1][16:]};') + info_impl.append('\treturn true;') + info_impl.append('}') + info_impl.append('') + + assert len(features) <= 2, 'Number of feature structs per extension is expected to be max 2.' + + print('\tvoid reset_pnext() {') + for member_name in member_names: + print(f'\t\t{member_name}.pNext = nullptr;') + print('\t}\n') + + print('\tbool get_extension_requirements(ExtensionRequirements &dep) {') + for l in info_impl: + if len(l): + print('\t\t' + l) + else: + print('') + print('\t\treturn false;') + print('\t}') + + print('};\n') + +if __name__ == '__main__': + main() + From 2583ae3e1f77f1779a9c9d1dea6eccfb62a09f11 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Wed, 5 Aug 2026 14:56:01 +0200 Subject: [PATCH 15/17] Add the sifter CLI. --- cli/CMakeLists.txt | 1 + cli/fossilize_feature_sifter.cpp | 351 ++ cli/fossilize_feature_sifter.hpp | 4651 +++++++++++++++++++++++++++ extract_vulkan_extensions_sifter.py | 63 +- khronos/vulkan/vulkan_core.h | 348 +- 5 files changed, 5379 insertions(+), 35 deletions(-) create mode 100644 cli/fossilize_feature_sifter.cpp create mode 100644 cli/fossilize_feature_sifter.hpp diff --git a/cli/CMakeLists.txt b/cli/CMakeLists.txt index 37bcdf99..81b8ce2a 100644 --- a/cli/CMakeLists.txt +++ b/cli/CMakeLists.txt @@ -71,3 +71,4 @@ if ((NOT WIN32) AND (NOT ANDROID)) # Can be ported over as needed. add_fossilize_cli(fossilize-validate-cache-roundtrip fossilize_validate_cache_roundtrip.cpp) endif() +add_fossilize_cli(fossilize-feature-sifter fossilize_feature_sifter.cpp fossilize_feature_sifter.hpp) diff --git a/cli/fossilize_feature_sifter.cpp b/cli/fossilize_feature_sifter.cpp new file mode 100644 index 00000000..f33e4493 --- /dev/null +++ b/cli/fossilize_feature_sifter.cpp @@ -0,0 +1,351 @@ +/* Copyright (c) 2026 Hans-Kristian Arntzen for Valve Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "volk.h" +#include "fossilize_feature_sifter.hpp" + +#include +#include +#include "cli_parser.hpp" +#include "logging.hpp" +#include + +using namespace Fossilize; + +static void print_help() +{ + LOGI("fossilize-feature-sifter\n" + "\t[--help]\n" + "\t[--block-extension ]\n"); +} + +struct Instance +{ + VkInstance instance; + std::vector props; + std::vector extensions; +}; + +static bool create_instance(Instance &instance) +{ + if (volkInitialize() != VK_SUCCESS) + return false; + + uint32_t instance_version; + if (vkEnumerateInstanceVersion(&instance_version) != VK_SUCCESS || instance_version < VK_API_VERSION_1_1) + return false; + + VkInstanceCreateInfo instance_info = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }; + + const VkApplicationInfo app_info = { + VK_STRUCTURE_TYPE_APPLICATION_INFO, nullptr, + "fossilize-sifter", 1, + "fossilize-cli", 1, + instance_version, + }; + + instance_info.pApplicationInfo = &app_info; + + uint32_t count; + vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); + instance.props.resize(count); + vkEnumerateInstanceExtensionProperties(nullptr, &count, instance.props.data()); + instance.extensions.reserve(count); + for (auto &prop : instance.props) + instance.extensions.push_back(prop.extensionName); + + instance_info.enabledExtensionCount = count; + instance_info.ppEnabledExtensionNames = instance.extensions.data(); + + if (vkCreateInstance(&instance_info, nullptr, &instance.instance) != VK_SUCCESS) + { + LOGE("Failed to create instance.\n"); + return false; + } + + volkLoadInstance(instance.instance); + return true; +} + +static void pipeline_binary_key_to_str(char (&str)[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1], const VkPipelineBinaryKeyKHR &key) +{ + str[0] = '\0'; + for (uint32_t i = 0; i < key.keySize; i++) + sprintf(str + 2 * i, "%02x", key.key[i]); +} + +static void print_pipeline_binary_key(const char *tag, const VkPipelineBinaryKeyKHR &key) +{ + char str[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * 2 + 1]; + pipeline_binary_key_to_str(str, key); + LOGI("Pipeline key for \"%s\": %s\n", tag, str); +} + +static bool compare_pipeline_key(const VkPipelineBinaryKeyKHR &a, const VkPipelineBinaryKeyKHR &b) +{ + return a.keySize == b.keySize && memcmp(a.key, b.key, a.keySize) == 0; +} + +static bool get_pipeline_key(VkPhysicalDevice gpu, const std::vector &extensions, + const VkPhysicalDeviceFeatures2 &features2_base, + VkPipelineBinaryKeyKHR &key) +{ + VkDeviceCreateInfo device_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; + VkDeviceQueueCreateInfo queue_create_info = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }; + const float queue_prio = 1.0f; + queue_create_info.queueCount = 1; + // Don't care what this queue does. + queue_create_info.queueFamilyIndex = 0; + queue_create_info.pQueuePriorities = &queue_prio; + device_info.pQueueCreateInfos = &queue_create_info; + + VkPhysicalDevicePipelineBinaryFeaturesKHR binary = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, nullptr, VK_TRUE + }; + + auto features2 = features2_base; + device_info.pNext = &features2; + + auto tmp_extensions = extensions; + tmp_extensions.push_back(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME); + + binary.pNext = features2.pNext; + features2.pNext = &binary; + device_info.ppEnabledExtensionNames = tmp_extensions.data(); + device_info.enabledExtensionCount = uint32_t(tmp_extensions.size()); + + VkDevice device; + auto vr = vkCreateDevice(gpu, &device_info, nullptr, &device); + if (vr != VK_SUCCESS) + { + LOGE("Failed to create device, vr %d.\n", vr); + return false; + } + + if (vkGetPipelineKeyKHR(device, nullptr, &key) != VK_SUCCESS) + { + LOGE("Failed to get the global pipeline binary key.\n"); + vkDestroyDevice(device, nullptr); + return false; + } + + vkDestroyDevice(device, nullptr); + return true; +} + +int main(int argc, char **argv) +{ + std::vector ban_list; + CLICallbacks cbs; + + cbs.add("--help", [&](CLIParser &parser) { parser.end(); }); + cbs.add("--block-extension", [&](CLIParser &parser) { ban_list.emplace_back(parser.next_string()); }); + + CLIParser parser(std::move(cbs), argc - 1, argv + 1); + if (!parser.parse()) + { + print_help(); + return EXIT_FAILURE; + } + else if (parser.is_ended_state()) + { + print_help(); + return EXIT_SUCCESS; + } + + Instance instance; + if (!create_instance(instance)) + return EXIT_FAILURE; + + VkPhysicalDevice gpu; + uint32_t count = 1; + if (vkEnumeratePhysicalDevices(instance.instance, &count, &gpu) < 0) + { + LOGE("Failed to enumerate GPU.\n"); + return EXIT_FAILURE; + } + + VkPhysicalDeviceFeatures features = {}; + vkGetPhysicalDeviceFeatures(gpu, &features); + + VkPhysicalDeviceFeatures2 features2 = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 }; + VkPipelineBinaryKeyKHR baseline_key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + VkPipelineBinaryKeyKHR full_feature_key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + if (!get_pipeline_key(gpu, {}, features2, baseline_key)) + { + LOGE("Failed to get pipeline key.\n"); + return EXIT_FAILURE; + } + + print_pipeline_binary_key("Baseline", baseline_key); + + features2.features = features; + if (!get_pipeline_key(gpu, {}, features2, full_feature_key)) + { + LOGE("Failed to get pipeline key.\n"); + return EXIT_FAILURE; + } + print_pipeline_binary_key("Full 1.0 feature key", full_feature_key); + + // First, sift through all base features. + for (size_t i = 0; i < sizeof(features) / sizeof(VkBool32); i++) + { + if (reinterpret_cast(&features)[i]) + { + features2.features = {}; + reinterpret_cast(&features2.features)[i] = VK_TRUE; + + VkPipelineBinaryKeyKHR key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + if (!get_pipeline_key(gpu, {}, features2, key)) + { + LOGE("Failed to get pipeline key.\n"); + return EXIT_FAILURE; + } + + if (!compare_pipeline_key(baseline_key, key)) + { + LOGI("Found key delta for VkPhysicalDeviceFeature feature number %zu ...\n", i); + print_pipeline_binary_key("Delta", key); + } + } + } + + vkEnumerateDeviceExtensionProperties(gpu, nullptr, &count, nullptr); + std::vector extensions(count); + vkEnumerateDeviceExtensionProperties(gpu, nullptr, &count, extensions.data()); + + std::vector enabled_extensions; + ExistingFeatureStructs feature_structs; + + const auto supports_device_extension = [&](const char *e) + { + return std::find_if(extensions.begin(), extensions.end(), + [&](const VkExtensionProperties &prop) { return strcmp(prop.extensionName, e) == 0; }) != extensions.end(); + }; + + const auto has_banned_extension = [&](const std::vector &candidates) + { + for (auto *candidate: candidates) + { + if (std::find_if(ban_list.begin(), ban_list.end(), [&](const std::string &banned) { + return banned == candidate; }) != ban_list.end()) + { + return true; + } + } + return false; + }; + + for (auto &ext : extensions) + { + if (strcmp(ext.extensionName, VK_KHR_PIPELINE_BINARY_EXTENSION_NAME) == 0) + continue; + + feature_structs.reset_pnext(); + enabled_extensions.clear(); + + features2.pNext = nullptr; + enabled_extensions.push_back(ext.extensionName); + + ExtensionRequirements reqs = {}; + if (!feature_structs.get_extension_requirements(ext.extensionName, reqs)) + { + LOGE("Extension %s does not have extension requirements in LUT. Skipping.\n", ext.extensionName); + continue; + } + + features2.pNext = reqs.primary_feature; + if (reqs.secondary_feature) + { + static_cast(reqs.primary_feature)->pNext = + static_cast(reqs.secondary_feature); + } + + const auto add_unique_device_ext = [&](const char *candidate) -> bool + { + auto itr = std::find_if( + instance.extensions.begin(), instance.extensions.end(), + [&](const char *instance_ext) { return strcmp(instance_ext, candidate) == 0; }); + + if (itr != instance.extensions.end()) + return false; + + for (auto *enabled : enabled_extensions) + if (strcmp(enabled, candidate) == 0) + return false; + enabled_extensions.push_back(candidate); + return true; + }; + + std::vector current_exts; + bool new_extensions; + + do + { + new_extensions = false; + current_exts = enabled_extensions; + for (auto *current_ext : current_exts) + if (feature_structs.get_extension_requirements(current_ext, reqs)) + for (uint32_t i = 0; i < reqs.num_extension_dependencies; i++) + if (add_unique_device_ext(reqs.extension_dependencies[i])) + new_extensions = true; + } while(new_extensions); + + // The dependency list might contain extensions that aren't actually supported if they are promoted exts to core. + // Filter them out. + auto itr = std::remove_if(enabled_extensions.begin(), enabled_extensions.end(), + [&](const char *candidate) + { + return !supports_device_extension(candidate); + }); + enabled_extensions.erase(itr, enabled_extensions.end()); + + if (has_banned_extension(enabled_extensions)) + { + LOGI("Skipping extension %s due to banned extensions.\n", ext.extensionName); + continue; + } + + // Make sure dependent features also get enabled. + if (strcmp(ext.extensionName, VK_EXT_MESH_SHADER_EXTENSION_NAME) == 0) + { + feature_structs.mFragmentShadingRateFeaturesKHR.pNext = features2.pNext; + features2.pNext = &feature_structs.mFragmentShadingRateFeaturesKHR; + feature_structs.mMultiviewFeatures.pNext = features2.pNext; + features2.pNext = &feature_structs.mMultiviewFeatures; + } + + vkGetPhysicalDeviceFeatures2(gpu, &features2); + + VkPipelineBinaryKeyKHR key = { VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR }; + if (!get_pipeline_key(gpu, enabled_extensions, features2, key)) + { + LOGE("Failed to get pipeline key for extension %s.\n", ext.extensionName); + continue; + } + + if (!compare_pipeline_key(full_feature_key, key)) + print_pipeline_binary_key(ext.extensionName, key); + } + + vkDestroyInstance(instance.instance, nullptr); +} \ No newline at end of file diff --git a/cli/fossilize_feature_sifter.hpp b/cli/fossilize_feature_sifter.hpp new file mode 100644 index 00000000..08684a6f --- /dev/null +++ b/cli/fossilize_feature_sifter.hpp @@ -0,0 +1,4651 @@ +#pragma once +// Autogenerated from extract_vulkan_extensions_sifter.py +#include +static const struct { + VkStructureType sType; + size_t size; +} pNextLUT[] = { + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV, sizeof(VkPhysicalDevicePushConstantBankFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, sizeof(VkPhysicalDevicePrivateDataFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, sizeof(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, sizeof(VkPhysicalDeviceVariablePointersFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, sizeof(VkPhysicalDeviceMultiviewFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, sizeof(VkPhysicalDevicePresentIdFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, sizeof(VkPhysicalDevicePresentId2FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, sizeof(VkPhysicalDevicePresentWait2FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT, sizeof(VkPhysicalDevicePresentTimingFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, sizeof(VkPhysicalDevice16BitStorageFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, sizeof(VkPhysicalDeviceProtectedMemoryFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, sizeof(VkPhysicalDeviceMaintenance4Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, sizeof(VkPhysicalDeviceMaintenance5Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, sizeof(VkPhysicalDeviceMaintenance6Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, sizeof(VkPhysicalDeviceMaintenance7FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, sizeof(VkPhysicalDeviceMaintenance8FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, sizeof(VkPhysicalDeviceMaintenance9FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR, sizeof(VkPhysicalDeviceMaintenance11FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR, sizeof(VkPhysicalDeviceMaintenance10FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, sizeof(VkPhysicalDeviceShaderFloat16Int8Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, sizeof(VkPhysicalDeviceHostQueryResetFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM, sizeof(VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, sizeof(VkPhysicalDevice8BitStorageFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, sizeof(VkPhysicalDeviceShaderAtomicInt64Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR, sizeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, sizeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, sizeof(VkPhysicalDeviceMemoryDecompressionFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, sizeof(VkPhysicalDeviceMeshShaderFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, sizeof(VkPhysicalDeviceMeshShaderFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, sizeof(VkPhysicalDevicePresentBarrierFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, sizeof(VkPhysicalDeviceIndexTypeUint8Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, sizeof(VkPhysicalDeviceLineRasterizationFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, sizeof(VkPhysicalDeviceVulkan11Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, sizeof(VkPhysicalDeviceVulkan12Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, sizeof(VkPhysicalDeviceVulkan13Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, sizeof(VkPhysicalDeviceVulkan14Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD, sizeof(VkPhysicalDeviceGpaFeaturesAMD) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, sizeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR, sizeof(VkPhysicalDeviceExtendedFlagsFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, sizeof(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, sizeof(VkPhysicalDeviceRobustness2FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, sizeof(VkPhysicalDeviceImageRobustnessFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, sizeof(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, sizeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, sizeof(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, sizeof(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, sizeof(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT, sizeof(VkPhysicalDeviceCustomResolveFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceDepthClampControlFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, sizeof(VkPhysicalDeviceSynchronization2Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, sizeof(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, sizeof(VkPhysicalDeviceHostImageCopyFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, sizeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT, sizeof(VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, sizeof(VkPhysicalDevicePipelineProtectedAccessFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoMaintenance1FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoMaintenance2FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, sizeof(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, sizeof(VkPhysicalDeviceDescriptorBufferFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderFmaFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, sizeof(VkPhysicalDeviceRayTracingValidationFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, sizeof(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, sizeof(VkPhysicalDeviceDynamicRenderingFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, sizeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, sizeof(VkPhysicalDevicePipelineBinaryFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM, sizeof(VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, sizeof(VkPhysicalDeviceNestedCommandBufferFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR, sizeof(VkPhysicalDeviceOpacityMicromapFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, sizeof(VkPhysicalDeviceOpacityMicromapFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, sizeof(VkPhysicalDevicePipelineRobustnessFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM, sizeof(VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, sizeof(VkPhysicalDeviceImageProcessingFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, sizeof(VkPhysicalDeviceTilePropertiesFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, sizeof(VkPhysicalDeviceAmigoProfilingFeaturesSEC) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, sizeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, sizeof(VkPhysicalDeviceAddressBindingReportFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, sizeof(VkPhysicalDeviceOpticalFlowFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, sizeof(VkPhysicalDeviceFaultFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR, sizeof(VkPhysicalDeviceFaultFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, sizeof(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, sizeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, sizeof(VkPhysicalDeviceFrameBoundaryFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, sizeof(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR, sizeof(VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, sizeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceDepthBiasControlFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT, sizeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, sizeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, sizeof(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, sizeof(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, sizeof(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, sizeof(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderObjectFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderTileImageFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM, sizeof(VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, sizeof(VkPhysicalDeviceAntiLagFeaturesAMD) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, sizeof(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, sizeof(VkPhysicalDeviceCubicClampFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, sizeof(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, sizeof(VkPhysicalDeviceCubicWeightsFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, sizeof(VkPhysicalDeviceImageProcessing2FeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM, sizeof(VkPhysicalDeviceImageProcessing3FeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, sizeof(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, sizeof(VkPhysicalDevicePerStageDescriptorSetFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, sizeof(VkPhysicalDeviceSchedulingControlsFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, sizeof(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, sizeof(VkPhysicalDeviceRenderPassStripedFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, sizeof(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, sizeof(VkPhysicalDeviceShaderSubgroupRotateFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, sizeof(VkPhysicalDeviceShaderExpectAssumeFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, sizeof(VkPhysicalDeviceShaderFloatControls2Features) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, sizeof(VkPhysicalDeviceDynamicRenderingLocalReadFeatures) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderQuadControlFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, sizeof(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, sizeof(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderBfloat16FeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, sizeof(VkPhysicalDeviceRawAccessChainsFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, sizeof(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, sizeof(VkPhysicalDeviceImageAlignmentControlFeaturesMESA) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, sizeof(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, sizeof(VkPhysicalDeviceCooperativeMatrix2FeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV, sizeof(VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, sizeof(VkPhysicalDeviceHdrVividFeaturesHUAWEI) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, sizeof(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, sizeof(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, sizeof(VkPhysicalDeviceCooperativeVectorFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, sizeof(VkPhysicalDeviceTileShadingFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, sizeof(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, sizeof(VkPhysicalDevicePresentMeteringFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE, sizeof(VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT, sizeof(VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, sizeof(VkPhysicalDeviceFormatPackFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC, sizeof(VkPhysicalDeviceThrottleHintFeaturesSEC) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, sizeof(VkPhysicalDeviceTensorFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, sizeof(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderFloat8FeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, sizeof(VkPhysicalDeviceDataGraphFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, sizeof(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM, sizeof(VkPhysicalDeviceDataGraphModelFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE, sizeof(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT, sizeof(VkPhysicalDeviceShader64BitIndexingFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM, sizeof(VkPhysicalDeviceQueuePerfHintFeaturesQCOM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM, sizeof(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV, sizeof(VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderLongVectorFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT, sizeof(VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderSplitBarrierFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT, sizeof(VkPhysicalDeviceDescriptorHeapFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM, sizeof(VkPhysicalDeviceShaderInstrumentationFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR, sizeof(VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderConstantDataFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR, sizeof(VkPhysicalDeviceShaderAbortFeaturesKHR) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM, sizeof(VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT, sizeof(VkPhysicalDeviceImageTilingControlFeaturesEXT) }, + { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT, sizeof(VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT) }, +}; + +struct ExtensionRequirements { + void *primary_feature; + void *secondary_feature; + const char * const *extension_dependencies; + uint32_t num_extension_dependencies; + uint32_t minimum_api_version; +}; + +struct ExistingFeatureStructs { + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV mDeviceGeneratedCommandsFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV }; + VkPhysicalDevicePushConstantBankFeaturesNV mPushConstantBankFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV }; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV mDeviceGeneratedCommandsComputeFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV }; + VkPhysicalDevicePrivateDataFeatures mPrivateDataFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES }; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV mClusterAccelerationStructureFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV }; + VkPhysicalDeviceVariablePointersFeatures mVariablePointersFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES }; + VkPhysicalDeviceMultiviewFeatures mMultiviewFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES }; + VkPhysicalDevicePresentIdFeaturesKHR mPresentIdFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR }; + VkPhysicalDevicePresentId2FeaturesKHR mPresentId2FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR }; + VkPhysicalDevicePresentWaitFeaturesKHR mPresentWaitFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR }; + VkPhysicalDevicePresentWait2FeaturesKHR mPresentWait2FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR }; + VkPhysicalDevicePresentTimingFeaturesEXT mPresentTimingFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT }; + VkPhysicalDevice16BitStorageFeatures m16BitStorageFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES }; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures mShaderSubgroupExtendedTypesFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES }; + VkPhysicalDeviceSamplerYcbcrConversionFeatures mSamplerYcbcrConversionFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES }; + VkPhysicalDeviceProtectedMemoryFeatures mProtectedMemoryFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES }; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT mBlendOperationAdvancedFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT }; + VkPhysicalDeviceMultiDrawFeaturesEXT mMultiDrawFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT }; + VkPhysicalDeviceInlineUniformBlockFeatures mInlineUniformBlockFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES }; + VkPhysicalDeviceMaintenance4Features mMaintenance4Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES }; + VkPhysicalDeviceMaintenance5Features mMaintenance5Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES }; + VkPhysicalDeviceMaintenance6Features mMaintenance6Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES }; + VkPhysicalDeviceMaintenance7FeaturesKHR mMaintenance7FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR }; + VkPhysicalDeviceMaintenance8FeaturesKHR mMaintenance8FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR }; + VkPhysicalDeviceMaintenance9FeaturesKHR mMaintenance9FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR }; + VkPhysicalDeviceMaintenance11FeaturesKHR mMaintenance11FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR }; + VkPhysicalDeviceMaintenance10FeaturesKHR mMaintenance10FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR }; + VkPhysicalDeviceShaderDrawParametersFeatures mShaderDrawParametersFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES }; + VkPhysicalDeviceShaderFloat16Int8Features mShaderFloat16Int8Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES }; + VkPhysicalDeviceHostQueryResetFeatures mHostQueryResetFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES }; + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM mElapsedTimerQueryFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM }; + VkPhysicalDeviceGlobalPriorityQueryFeatures mGlobalPriorityQueryFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES }; + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT mDeviceMemoryReportFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT }; + VkPhysicalDeviceDescriptorIndexingFeatures mDescriptorIndexingFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES }; + VkPhysicalDeviceTimelineSemaphoreFeatures mTimelineSemaphoreFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES }; + VkPhysicalDevice8BitStorageFeatures m8BitStorageFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES }; + VkPhysicalDeviceConditionalRenderingFeaturesEXT mConditionalRenderingFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT }; + VkPhysicalDeviceVulkanMemoryModelFeatures mVulkanMemoryModelFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES }; + VkPhysicalDeviceShaderAtomicInt64Features mShaderAtomicInt64Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES }; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT mShaderAtomicFloatFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT }; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT mShaderAtomicFloat2FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT }; + VkPhysicalDeviceVertexAttributeDivisorFeatures mVertexAttributeDivisorFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES }; + VkPhysicalDeviceASTCDecodeFeaturesEXT mASTCDecodeFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT }; + VkPhysicalDeviceTransformFeedbackFeaturesEXT mTransformFeedbackFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT }; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV mRepresentativeFragmentTestFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV }; + VkPhysicalDeviceExclusiveScissorFeaturesNV mExclusiveScissorFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV }; + VkPhysicalDeviceCornerSampledImageFeaturesNV mCornerSampledImageFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV }; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR mComputeShaderDerivativesFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR }; + VkPhysicalDeviceShaderImageFootprintFeaturesNV mShaderImageFootprintFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV }; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV mDedicatedAllocationImageAliasingFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV }; + VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR mCopyMemoryIndirectFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR }; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV mCopyMemoryIndirectFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV }; + VkPhysicalDeviceMemoryDecompressionFeaturesEXT mMemoryDecompressionFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT }; + VkPhysicalDeviceShadingRateImageFeaturesNV mShadingRateImageFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV }; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI mInvocationMaskFeaturesHUAWEI = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI }; + VkPhysicalDeviceMeshShaderFeaturesNV mMeshShaderFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV }; + VkPhysicalDeviceMeshShaderFeaturesEXT mMeshShaderFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT }; + VkPhysicalDeviceAccelerationStructureFeaturesKHR mAccelerationStructureFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR }; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR mRayTracingPipelineFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR }; + VkPhysicalDeviceRayQueryFeaturesKHR mRayQueryFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR }; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR mRayTracingMaintenance1FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR }; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT mFragmentDensityMapFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT }; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT mFragmentDensityMap2FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT }; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT mFragmentDensityMapOffsetFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT }; + VkPhysicalDeviceScalarBlockLayoutFeatures mScalarBlockLayoutFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES }; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures mUniformBufferStandardLayoutFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES }; + VkPhysicalDeviceDepthClipEnableFeaturesEXT mDepthClipEnableFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT }; + VkPhysicalDeviceMemoryPriorityFeaturesEXT mMemoryPriorityFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT }; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT mPageableDeviceLocalMemoryFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT }; + VkPhysicalDeviceBufferDeviceAddressFeatures mBufferDeviceAddressFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES }; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT mBufferDeviceAddressFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT }; + VkPhysicalDeviceImagelessFramebufferFeatures mImagelessFramebufferFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES }; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures mTextureCompressionASTCHDRFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES }; + VkPhysicalDeviceCooperativeMatrixFeaturesNV mCooperativeMatrixFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV }; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT mYcbcrImageArraysFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT }; + VkPhysicalDevicePresentBarrierFeaturesNV mPresentBarrierFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV }; + VkPhysicalDevicePerformanceQueryFeaturesKHR mPerformanceQueryFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR }; + VkPhysicalDeviceCoverageReductionModeFeaturesNV mCoverageReductionModeFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV }; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL mShaderIntegerFunctions2FeaturesINTEL = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL }; + VkPhysicalDeviceShaderClockFeaturesKHR mShaderClockFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR }; + VkPhysicalDeviceIndexTypeUint8Features mIndexTypeUint8Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES }; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV mShaderSMBuiltinsFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV }; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT mFragmentShaderInterlockFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT }; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures mSeparateDepthStencilLayoutsFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES }; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT mPrimitiveTopologyListRestartFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT }; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR mPipelineExecutablePropertiesFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR }; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures mShaderDemoteToHelperInvocationFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES }; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT mTexelBufferAlignmentFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT }; + VkPhysicalDeviceSubgroupSizeControlFeatures mSubgroupSizeControlFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES }; + VkPhysicalDeviceLineRasterizationFeatures mLineRasterizationFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES }; + VkPhysicalDevicePipelineCreationCacheControlFeatures mPipelineCreationCacheControlFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES }; + VkPhysicalDeviceVulkan11Features mVulkan11Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES }; + VkPhysicalDeviceVulkan12Features mVulkan12Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES }; + VkPhysicalDeviceVulkan13Features mVulkan13Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES }; + VkPhysicalDeviceVulkan14Features mVulkan14Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES }; + VkPhysicalDeviceCoherentMemoryFeaturesAMD mCoherentMemoryFeaturesAMD = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD }; + VkPhysicalDeviceGpaFeaturesAMD mGpaFeaturesAMD = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD }; + VkPhysicalDeviceCustomBorderColorFeaturesEXT mCustomBorderColorFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT }; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT mBorderColorSwizzleFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT }; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT mExtendedDynamicStateFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT }; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT mExtendedDynamicState2FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT }; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT mExtendedDynamicState3FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT }; + VkPhysicalDeviceExtendedFlagsFeaturesKHR mExtendedFlagsFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR }; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV mPartitionedAccelerationStructureFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV }; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV mDiagnosticsConfigFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV }; + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures mZeroInitializeWorkgroupMemoryFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES }; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR mShaderSubgroupUniformControlFlowFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR }; + VkPhysicalDeviceRobustness2FeaturesKHR mRobustness2FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR }; + VkPhysicalDeviceImageRobustnessFeatures mImageRobustnessFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES }; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR mWorkgroupMemoryExplicitLayoutFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR }; + VkPhysicalDevice4444FormatsFeaturesEXT m4444FormatsFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT }; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI mSubpassShadingFeaturesHUAWEI = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI }; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI mClusterCullingShaderFeaturesHUAWEI = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI }; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT mShaderImageAtomicInt64FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT }; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR mFragmentShadingRateFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR }; + VkPhysicalDeviceShaderTerminateInvocationFeatures mShaderTerminateInvocationFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES }; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV mFragmentShadingRateEnumsFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV }; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT mImage2DViewOf3DFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT }; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT mImageSlicedViewOf3DFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT }; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT mAttachmentFeedbackLoopDynamicStateFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT }; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT mLegacyVertexAttributesFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT }; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT mMutableDescriptorTypeFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT }; + VkPhysicalDeviceDepthClipControlFeaturesEXT mDepthClipControlFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT }; + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT mZeroInitializeDeviceMemoryFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT }; + VkPhysicalDeviceCustomResolveFeaturesEXT mCustomResolveFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT }; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT mDeviceGeneratedCommandsFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT }; + VkPhysicalDeviceDepthClampControlFeaturesEXT mDepthClampControlFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT }; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT mVertexInputDynamicStateFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT }; + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV mExternalMemoryRDMAFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV }; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR mShaderRelaxedExtendedInstructionFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR }; + VkPhysicalDeviceColorWriteEnableFeaturesEXT mColorWriteEnableFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT }; + VkPhysicalDeviceSynchronization2Features mSynchronization2Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES }; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR mUnifiedImageLayoutsFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR }; + VkPhysicalDeviceHostImageCopyFeatures mHostImageCopyFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES }; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT mPrimitivesGeneratedQueryFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT }; + VkPhysicalDeviceLegacyDitheringFeaturesEXT mLegacyDitheringFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT }; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT mMultisampledRenderToSingleSampledFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT }; + VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT mMultisampledRenderToSwapchainFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT }; + VkPhysicalDevicePipelineProtectedAccessFeatures mPipelineProtectedAccessFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES }; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR mVideoMaintenance1FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR }; + VkPhysicalDeviceVideoMaintenance2FeaturesKHR mVideoMaintenance2FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR }; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR mVideoDecodeVP9FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR }; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR mVideoEncodeQuantizationMapFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR }; + VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR mVideoEncodeFeedback2FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR }; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR mVideoEncodeAV1FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR }; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV mInheritedViewportScissorFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV }; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT mYcbcr2Plane444FormatsFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT }; + VkPhysicalDeviceProvokingVertexFeaturesEXT mProvokingVertexFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT }; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR mVideoEncodeIntraRefreshFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR }; + VkPhysicalDeviceDescriptorBufferFeaturesEXT mDescriptorBufferFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT }; + VkPhysicalDeviceShaderIntegerDotProductFeatures mShaderIntegerDotProductFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES }; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR mFragmentShaderBarycentricFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR }; + VkPhysicalDeviceShaderFmaFeaturesKHR mShaderFmaFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR }; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV mRayTracingMotionBlurFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV }; + VkPhysicalDeviceRayTracingValidationFeaturesNV mRayTracingValidationFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV }; + VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV mRayTracingLinearSweptSpheresFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV }; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT mRGBA10X6FormatsFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT }; + VkPhysicalDeviceDynamicRenderingFeatures mDynamicRenderingFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES }; + VkPhysicalDeviceImageViewMinLodFeaturesEXT mImageViewMinLodFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT }; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT mRasterizationOrderAttachmentAccessFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT }; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV mLinearColorAttachmentFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV }; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT mGraphicsPipelineLibraryFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT }; + VkPhysicalDevicePipelineBinaryFeaturesKHR mPipelineBinaryFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR }; + VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM mDataGraphNeuralAcceleratorStatisticsFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM }; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE mDescriptorSetHostMappingFeaturesVALVE = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE }; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT mNestedCommandBufferFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT }; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT mShaderModuleIdentifierFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT }; + VkPhysicalDeviceImageCompressionControlFeaturesEXT mImageCompressionControlFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT }; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT mImageCompressionControlSwapchainFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT }; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT mSubpassMergeFeedbackFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT }; + VkPhysicalDeviceOpacityMicromapFeaturesKHR mOpacityMicromapFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR }; + VkPhysicalDeviceOpacityMicromapFeaturesEXT mOpacityMicromapFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT }; + VkPhysicalDevicePipelinePropertiesFeaturesEXT mPipelinePropertiesFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT }; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD mShaderEarlyAndLateFragmentTestsFeaturesAMD = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD }; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT mNonSeamlessCubeMapFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT }; + VkPhysicalDevicePipelineRobustnessFeatures mPipelineRobustnessFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES }; + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM mShaderMultipleWaitQueuesFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM }; + VkPhysicalDeviceImageProcessingFeaturesQCOM mImageProcessingFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM }; + VkPhysicalDeviceTilePropertiesFeaturesQCOM mTilePropertiesFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM }; + VkPhysicalDeviceAmigoProfilingFeaturesSEC mAmigoProfilingFeaturesSEC = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC }; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT mAttachmentFeedbackLoopLayoutFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT }; + VkPhysicalDeviceAddressBindingReportFeaturesEXT mAddressBindingReportFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT }; + VkPhysicalDeviceOpticalFlowFeaturesNV mOpticalFlowFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV }; + VkPhysicalDeviceFaultFeaturesEXT mFaultFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT }; + VkPhysicalDeviceFaultFeaturesKHR mFaultFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR }; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT mPipelineLibraryGroupHandlesFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT }; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM mShaderCoreBuiltinsFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM }; + VkPhysicalDeviceFrameBoundaryFeaturesEXT mFrameBoundaryFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT }; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT mDynamicRenderingUnusedAttachmentsFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT }; + VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR mInternallySynchronizedQueuesFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR }; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR mSwapchainMaintenance1FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR }; + VkPhysicalDeviceDepthBiasControlFeaturesEXT mDepthBiasControlFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT }; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT mRayTracingInvocationReorderFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT }; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV mRayTracingInvocationReorderFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV }; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV mExtendedSparseAddressSpaceFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV }; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM mMultiviewPerViewViewportsFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM }; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR mRayTracingPositionFetchFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR }; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM mMultiviewPerViewRenderAreasFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM }; + VkPhysicalDeviceShaderObjectFeaturesEXT mShaderObjectFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT }; + VkPhysicalDeviceShaderTileImageFeaturesEXT mShaderTileImageFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT }; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR mCooperativeMatrixFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR }; + VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM mCooperativeMatrixConversionFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM }; + VkPhysicalDeviceAntiLagFeaturesAMD mAntiLagFeaturesAMD = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD }; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM mTileMemoryHeapFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM }; + VkPhysicalDeviceCubicClampFeaturesQCOM mCubicClampFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM }; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM mYcbcrDegammaFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM }; + VkPhysicalDeviceCubicWeightsFeaturesQCOM mCubicWeightsFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM }; + VkPhysicalDeviceImageProcessing2FeaturesQCOM mImageProcessing2FeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM }; + VkPhysicalDeviceImageProcessing3FeaturesQCOM mImageProcessing3FeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM }; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV mDescriptorPoolOverallocationFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV }; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV mPerStageDescriptorSetFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV }; + VkPhysicalDeviceSchedulingControlsFeaturesARM mSchedulingControlsFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM }; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG mRelaxedLineRasterizationFeaturesIMG = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG }; + VkPhysicalDeviceRenderPassStripedFeaturesARM mRenderPassStripedFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM }; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM mPipelineOpacityMicromapFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM }; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR mShaderMaximalReconvergenceFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR }; + VkPhysicalDeviceShaderSubgroupRotateFeatures mShaderSubgroupRotateFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES }; + VkPhysicalDeviceShaderExpectAssumeFeatures mShaderExpectAssumeFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES }; + VkPhysicalDeviceShaderFloatControls2Features mShaderFloatControls2Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES }; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures mDynamicRenderingLocalReadFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES }; + VkPhysicalDeviceShaderQuadControlFeaturesKHR mShaderQuadControlFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR }; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV mShaderAtomicFloat16VectorFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV }; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT mMapMemoryPlacedFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT }; + VkPhysicalDeviceShaderBfloat16FeaturesKHR mShaderBfloat16FeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR }; + VkPhysicalDeviceRawAccessChainsFeaturesNV mRawAccessChainsFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV }; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV mCommandBufferInheritanceFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV }; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA mImageAlignmentControlFeaturesMESA = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA }; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT mShaderReplicatedCompositesFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT }; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR mPresentModeFifoLatestReadyFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR }; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV mCooperativeMatrix2FeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV }; + VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV mCooperativeMatrixDecodeVectorFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV }; + VkPhysicalDeviceHdrVividFeaturesHUAWEI mHdrVividFeaturesHUAWEI = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI }; + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT mVertexAttributeRobustnessFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT }; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR mDepthClampZeroOneFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR }; + VkPhysicalDeviceCooperativeVectorFeaturesNV mCooperativeVectorFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV }; + VkPhysicalDeviceTileShadingFeaturesQCOM mTileShadingFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM }; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE mFragmentDensityMapLayeredFeaturesVALVE = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE }; + VkPhysicalDevicePresentMeteringFeaturesNV mPresentMeteringFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV }; + VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT mShaderUniformBufferUnsizedArrayFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT }; + VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE mShaderMixedFloatDotProductFeaturesVALVE = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE }; + VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT mPrimitiveRestartIndexFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT }; + VkPhysicalDeviceFormatPackFeaturesARM mFormatPackFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM }; + VkPhysicalDeviceThrottleHintFeaturesSEC mThrottleHintFeaturesSEC = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC }; + VkPhysicalDeviceTensorFeaturesARM mTensorFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM }; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM mDescriptorBufferTensorFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM }; + VkPhysicalDeviceShaderFloat8FeaturesEXT mShaderFloat8FeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT }; + VkPhysicalDeviceDataGraphFeaturesARM mDataGraphFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM }; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC mPipelineCacheIncrementalModeFeaturesSEC = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC }; + VkPhysicalDeviceDataGraphModelFeaturesQCOM mDataGraphModelFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM }; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR mShaderUntypedPointersFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR }; + VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE mVideoEncodeRgbConversionFeaturesVALVE = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE }; + VkPhysicalDeviceShader64BitIndexingFeaturesEXT mShader64BitIndexingFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT }; + VkPhysicalDeviceQueuePerfHintFeaturesQCOM mQueuePerfHintFeaturesQCOM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM }; + VkPhysicalDevicePerformanceCountersByRegionFeaturesARM mPerformanceCountersByRegionFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM }; + VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV mComputeOccupancyPriorityFeaturesNV = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV }; + VkPhysicalDeviceShaderLongVectorFeaturesEXT mShaderLongVectorFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT }; + VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT mTextureCompressionASTC3DFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT }; + VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT mShaderSubgroupPartitionedFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT }; + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT mShaderSplitBarrierFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT }; + VkPhysicalDeviceDescriptorHeapFeaturesEXT mDescriptorHeapFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT }; + VkPhysicalDeviceShaderInstrumentationFeaturesARM mShaderInstrumentationFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM }; + VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR mDeviceAddressCommandsFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR }; + VkPhysicalDeviceShaderConstantDataFeaturesKHR mShaderConstantDataFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR }; + VkPhysicalDeviceShaderAbortFeaturesKHR mShaderAbortFeaturesKHR = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR }; + VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM mDataGraphOpticalFlowFeaturesARM = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM }; + VkPhysicalDeviceImageTilingControlFeaturesEXT mImageTilingControlFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT }; + VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT mShaderOCPMicroscalingTypesFeaturesEXT = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT }; + void reset_pnext() { + mDeviceGeneratedCommandsFeaturesNV.pNext = nullptr; + mPushConstantBankFeaturesNV.pNext = nullptr; + mDeviceGeneratedCommandsComputeFeaturesNV.pNext = nullptr; + mPrivateDataFeatures.pNext = nullptr; + mClusterAccelerationStructureFeaturesNV.pNext = nullptr; + mVariablePointersFeatures.pNext = nullptr; + mMultiviewFeatures.pNext = nullptr; + mPresentIdFeaturesKHR.pNext = nullptr; + mPresentId2FeaturesKHR.pNext = nullptr; + mPresentWaitFeaturesKHR.pNext = nullptr; + mPresentWait2FeaturesKHR.pNext = nullptr; + mPresentTimingFeaturesEXT.pNext = nullptr; + m16BitStorageFeatures.pNext = nullptr; + mShaderSubgroupExtendedTypesFeatures.pNext = nullptr; + mSamplerYcbcrConversionFeatures.pNext = nullptr; + mProtectedMemoryFeatures.pNext = nullptr; + mBlendOperationAdvancedFeaturesEXT.pNext = nullptr; + mMultiDrawFeaturesEXT.pNext = nullptr; + mInlineUniformBlockFeatures.pNext = nullptr; + mMaintenance4Features.pNext = nullptr; + mMaintenance5Features.pNext = nullptr; + mMaintenance6Features.pNext = nullptr; + mMaintenance7FeaturesKHR.pNext = nullptr; + mMaintenance8FeaturesKHR.pNext = nullptr; + mMaintenance9FeaturesKHR.pNext = nullptr; + mMaintenance11FeaturesKHR.pNext = nullptr; + mMaintenance10FeaturesKHR.pNext = nullptr; + mShaderDrawParametersFeatures.pNext = nullptr; + mShaderFloat16Int8Features.pNext = nullptr; + mHostQueryResetFeatures.pNext = nullptr; + mElapsedTimerQueryFeaturesQCOM.pNext = nullptr; + mGlobalPriorityQueryFeatures.pNext = nullptr; + mDeviceMemoryReportFeaturesEXT.pNext = nullptr; + mDescriptorIndexingFeatures.pNext = nullptr; + mTimelineSemaphoreFeatures.pNext = nullptr; + m8BitStorageFeatures.pNext = nullptr; + mConditionalRenderingFeaturesEXT.pNext = nullptr; + mVulkanMemoryModelFeatures.pNext = nullptr; + mShaderAtomicInt64Features.pNext = nullptr; + mShaderAtomicFloatFeaturesEXT.pNext = nullptr; + mShaderAtomicFloat2FeaturesEXT.pNext = nullptr; + mVertexAttributeDivisorFeatures.pNext = nullptr; + mASTCDecodeFeaturesEXT.pNext = nullptr; + mTransformFeedbackFeaturesEXT.pNext = nullptr; + mRepresentativeFragmentTestFeaturesNV.pNext = nullptr; + mExclusiveScissorFeaturesNV.pNext = nullptr; + mCornerSampledImageFeaturesNV.pNext = nullptr; + mComputeShaderDerivativesFeaturesKHR.pNext = nullptr; + mShaderImageFootprintFeaturesNV.pNext = nullptr; + mDedicatedAllocationImageAliasingFeaturesNV.pNext = nullptr; + mCopyMemoryIndirectFeaturesKHR.pNext = nullptr; + mCopyMemoryIndirectFeaturesNV.pNext = nullptr; + mMemoryDecompressionFeaturesEXT.pNext = nullptr; + mShadingRateImageFeaturesNV.pNext = nullptr; + mInvocationMaskFeaturesHUAWEI.pNext = nullptr; + mMeshShaderFeaturesNV.pNext = nullptr; + mMeshShaderFeaturesEXT.pNext = nullptr; + mAccelerationStructureFeaturesKHR.pNext = nullptr; + mRayTracingPipelineFeaturesKHR.pNext = nullptr; + mRayQueryFeaturesKHR.pNext = nullptr; + mRayTracingMaintenance1FeaturesKHR.pNext = nullptr; + mFragmentDensityMapFeaturesEXT.pNext = nullptr; + mFragmentDensityMap2FeaturesEXT.pNext = nullptr; + mFragmentDensityMapOffsetFeaturesEXT.pNext = nullptr; + mScalarBlockLayoutFeatures.pNext = nullptr; + mUniformBufferStandardLayoutFeatures.pNext = nullptr; + mDepthClipEnableFeaturesEXT.pNext = nullptr; + mMemoryPriorityFeaturesEXT.pNext = nullptr; + mPageableDeviceLocalMemoryFeaturesEXT.pNext = nullptr; + mBufferDeviceAddressFeatures.pNext = nullptr; + mBufferDeviceAddressFeaturesEXT.pNext = nullptr; + mImagelessFramebufferFeatures.pNext = nullptr; + mTextureCompressionASTCHDRFeatures.pNext = nullptr; + mCooperativeMatrixFeaturesNV.pNext = nullptr; + mYcbcrImageArraysFeaturesEXT.pNext = nullptr; + mPresentBarrierFeaturesNV.pNext = nullptr; + mPerformanceQueryFeaturesKHR.pNext = nullptr; + mCoverageReductionModeFeaturesNV.pNext = nullptr; + mShaderIntegerFunctions2FeaturesINTEL.pNext = nullptr; + mShaderClockFeaturesKHR.pNext = nullptr; + mIndexTypeUint8Features.pNext = nullptr; + mShaderSMBuiltinsFeaturesNV.pNext = nullptr; + mFragmentShaderInterlockFeaturesEXT.pNext = nullptr; + mSeparateDepthStencilLayoutsFeatures.pNext = nullptr; + mPrimitiveTopologyListRestartFeaturesEXT.pNext = nullptr; + mPipelineExecutablePropertiesFeaturesKHR.pNext = nullptr; + mShaderDemoteToHelperInvocationFeatures.pNext = nullptr; + mTexelBufferAlignmentFeaturesEXT.pNext = nullptr; + mSubgroupSizeControlFeatures.pNext = nullptr; + mLineRasterizationFeatures.pNext = nullptr; + mPipelineCreationCacheControlFeatures.pNext = nullptr; + mVulkan11Features.pNext = nullptr; + mVulkan12Features.pNext = nullptr; + mVulkan13Features.pNext = nullptr; + mVulkan14Features.pNext = nullptr; + mCoherentMemoryFeaturesAMD.pNext = nullptr; + mGpaFeaturesAMD.pNext = nullptr; + mCustomBorderColorFeaturesEXT.pNext = nullptr; + mBorderColorSwizzleFeaturesEXT.pNext = nullptr; + mExtendedDynamicStateFeaturesEXT.pNext = nullptr; + mExtendedDynamicState2FeaturesEXT.pNext = nullptr; + mExtendedDynamicState3FeaturesEXT.pNext = nullptr; + mExtendedFlagsFeaturesKHR.pNext = nullptr; + mPartitionedAccelerationStructureFeaturesNV.pNext = nullptr; + mDiagnosticsConfigFeaturesNV.pNext = nullptr; + mZeroInitializeWorkgroupMemoryFeatures.pNext = nullptr; + mShaderSubgroupUniformControlFlowFeaturesKHR.pNext = nullptr; + mRobustness2FeaturesKHR.pNext = nullptr; + mImageRobustnessFeatures.pNext = nullptr; + mWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext = nullptr; + m4444FormatsFeaturesEXT.pNext = nullptr; + mSubpassShadingFeaturesHUAWEI.pNext = nullptr; + mClusterCullingShaderFeaturesHUAWEI.pNext = nullptr; + mShaderImageAtomicInt64FeaturesEXT.pNext = nullptr; + mFragmentShadingRateFeaturesKHR.pNext = nullptr; + mShaderTerminateInvocationFeatures.pNext = nullptr; + mFragmentShadingRateEnumsFeaturesNV.pNext = nullptr; + mImage2DViewOf3DFeaturesEXT.pNext = nullptr; + mImageSlicedViewOf3DFeaturesEXT.pNext = nullptr; + mAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext = nullptr; + mLegacyVertexAttributesFeaturesEXT.pNext = nullptr; + mMutableDescriptorTypeFeaturesEXT.pNext = nullptr; + mDepthClipControlFeaturesEXT.pNext = nullptr; + mZeroInitializeDeviceMemoryFeaturesEXT.pNext = nullptr; + mCustomResolveFeaturesEXT.pNext = nullptr; + mDeviceGeneratedCommandsFeaturesEXT.pNext = nullptr; + mDepthClampControlFeaturesEXT.pNext = nullptr; + mVertexInputDynamicStateFeaturesEXT.pNext = nullptr; + mExternalMemoryRDMAFeaturesNV.pNext = nullptr; + mShaderRelaxedExtendedInstructionFeaturesKHR.pNext = nullptr; + mColorWriteEnableFeaturesEXT.pNext = nullptr; + mSynchronization2Features.pNext = nullptr; + mUnifiedImageLayoutsFeaturesKHR.pNext = nullptr; + mHostImageCopyFeatures.pNext = nullptr; + mPrimitivesGeneratedQueryFeaturesEXT.pNext = nullptr; + mLegacyDitheringFeaturesEXT.pNext = nullptr; + mMultisampledRenderToSingleSampledFeaturesEXT.pNext = nullptr; + mMultisampledRenderToSwapchainFeaturesEXT.pNext = nullptr; + mPipelineProtectedAccessFeatures.pNext = nullptr; + mVideoMaintenance1FeaturesKHR.pNext = nullptr; + mVideoMaintenance2FeaturesKHR.pNext = nullptr; + mVideoDecodeVP9FeaturesKHR.pNext = nullptr; + mVideoEncodeQuantizationMapFeaturesKHR.pNext = nullptr; + mVideoEncodeFeedback2FeaturesKHR.pNext = nullptr; + mVideoEncodeAV1FeaturesKHR.pNext = nullptr; + mInheritedViewportScissorFeaturesNV.pNext = nullptr; + mYcbcr2Plane444FormatsFeaturesEXT.pNext = nullptr; + mProvokingVertexFeaturesEXT.pNext = nullptr; + mVideoEncodeIntraRefreshFeaturesKHR.pNext = nullptr; + mDescriptorBufferFeaturesEXT.pNext = nullptr; + mShaderIntegerDotProductFeatures.pNext = nullptr; + mFragmentShaderBarycentricFeaturesKHR.pNext = nullptr; + mShaderFmaFeaturesKHR.pNext = nullptr; + mRayTracingMotionBlurFeaturesNV.pNext = nullptr; + mRayTracingValidationFeaturesNV.pNext = nullptr; + mRayTracingLinearSweptSpheresFeaturesNV.pNext = nullptr; + mRGBA10X6FormatsFeaturesEXT.pNext = nullptr; + mDynamicRenderingFeatures.pNext = nullptr; + mImageViewMinLodFeaturesEXT.pNext = nullptr; + mRasterizationOrderAttachmentAccessFeaturesEXT.pNext = nullptr; + mLinearColorAttachmentFeaturesNV.pNext = nullptr; + mGraphicsPipelineLibraryFeaturesEXT.pNext = nullptr; + mPipelineBinaryFeaturesKHR.pNext = nullptr; + mDataGraphNeuralAcceleratorStatisticsFeaturesARM.pNext = nullptr; + mDescriptorSetHostMappingFeaturesVALVE.pNext = nullptr; + mNestedCommandBufferFeaturesEXT.pNext = nullptr; + mShaderModuleIdentifierFeaturesEXT.pNext = nullptr; + mImageCompressionControlFeaturesEXT.pNext = nullptr; + mImageCompressionControlSwapchainFeaturesEXT.pNext = nullptr; + mSubpassMergeFeedbackFeaturesEXT.pNext = nullptr; + mOpacityMicromapFeaturesKHR.pNext = nullptr; + mOpacityMicromapFeaturesEXT.pNext = nullptr; + mPipelinePropertiesFeaturesEXT.pNext = nullptr; + mShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext = nullptr; + mNonSeamlessCubeMapFeaturesEXT.pNext = nullptr; + mPipelineRobustnessFeatures.pNext = nullptr; + mShaderMultipleWaitQueuesFeaturesQCOM.pNext = nullptr; + mImageProcessingFeaturesQCOM.pNext = nullptr; + mTilePropertiesFeaturesQCOM.pNext = nullptr; + mAmigoProfilingFeaturesSEC.pNext = nullptr; + mAttachmentFeedbackLoopLayoutFeaturesEXT.pNext = nullptr; + mAddressBindingReportFeaturesEXT.pNext = nullptr; + mOpticalFlowFeaturesNV.pNext = nullptr; + mFaultFeaturesEXT.pNext = nullptr; + mFaultFeaturesKHR.pNext = nullptr; + mPipelineLibraryGroupHandlesFeaturesEXT.pNext = nullptr; + mShaderCoreBuiltinsFeaturesARM.pNext = nullptr; + mFrameBoundaryFeaturesEXT.pNext = nullptr; + mDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext = nullptr; + mInternallySynchronizedQueuesFeaturesKHR.pNext = nullptr; + mSwapchainMaintenance1FeaturesKHR.pNext = nullptr; + mDepthBiasControlFeaturesEXT.pNext = nullptr; + mRayTracingInvocationReorderFeaturesEXT.pNext = nullptr; + mRayTracingInvocationReorderFeaturesNV.pNext = nullptr; + mExtendedSparseAddressSpaceFeaturesNV.pNext = nullptr; + mMultiviewPerViewViewportsFeaturesQCOM.pNext = nullptr; + mRayTracingPositionFetchFeaturesKHR.pNext = nullptr; + mMultiviewPerViewRenderAreasFeaturesQCOM.pNext = nullptr; + mShaderObjectFeaturesEXT.pNext = nullptr; + mShaderTileImageFeaturesEXT.pNext = nullptr; + mCooperativeMatrixFeaturesKHR.pNext = nullptr; + mCooperativeMatrixConversionFeaturesQCOM.pNext = nullptr; + mAntiLagFeaturesAMD.pNext = nullptr; + mTileMemoryHeapFeaturesQCOM.pNext = nullptr; + mCubicClampFeaturesQCOM.pNext = nullptr; + mYcbcrDegammaFeaturesQCOM.pNext = nullptr; + mCubicWeightsFeaturesQCOM.pNext = nullptr; + mImageProcessing2FeaturesQCOM.pNext = nullptr; + mImageProcessing3FeaturesQCOM.pNext = nullptr; + mDescriptorPoolOverallocationFeaturesNV.pNext = nullptr; + mPerStageDescriptorSetFeaturesNV.pNext = nullptr; + mSchedulingControlsFeaturesARM.pNext = nullptr; + mRelaxedLineRasterizationFeaturesIMG.pNext = nullptr; + mRenderPassStripedFeaturesARM.pNext = nullptr; + mPipelineOpacityMicromapFeaturesARM.pNext = nullptr; + mShaderMaximalReconvergenceFeaturesKHR.pNext = nullptr; + mShaderSubgroupRotateFeatures.pNext = nullptr; + mShaderExpectAssumeFeatures.pNext = nullptr; + mShaderFloatControls2Features.pNext = nullptr; + mDynamicRenderingLocalReadFeatures.pNext = nullptr; + mShaderQuadControlFeaturesKHR.pNext = nullptr; + mShaderAtomicFloat16VectorFeaturesNV.pNext = nullptr; + mMapMemoryPlacedFeaturesEXT.pNext = nullptr; + mShaderBfloat16FeaturesKHR.pNext = nullptr; + mRawAccessChainsFeaturesNV.pNext = nullptr; + mCommandBufferInheritanceFeaturesNV.pNext = nullptr; + mImageAlignmentControlFeaturesMESA.pNext = nullptr; + mShaderReplicatedCompositesFeaturesEXT.pNext = nullptr; + mPresentModeFifoLatestReadyFeaturesKHR.pNext = nullptr; + mCooperativeMatrix2FeaturesNV.pNext = nullptr; + mCooperativeMatrixDecodeVectorFeaturesNV.pNext = nullptr; + mHdrVividFeaturesHUAWEI.pNext = nullptr; + mVertexAttributeRobustnessFeaturesEXT.pNext = nullptr; + mDepthClampZeroOneFeaturesKHR.pNext = nullptr; + mCooperativeVectorFeaturesNV.pNext = nullptr; + mTileShadingFeaturesQCOM.pNext = nullptr; + mFragmentDensityMapLayeredFeaturesVALVE.pNext = nullptr; + mPresentMeteringFeaturesNV.pNext = nullptr; + mShaderUniformBufferUnsizedArrayFeaturesEXT.pNext = nullptr; + mShaderMixedFloatDotProductFeaturesVALVE.pNext = nullptr; + mPrimitiveRestartIndexFeaturesEXT.pNext = nullptr; + mFormatPackFeaturesARM.pNext = nullptr; + mThrottleHintFeaturesSEC.pNext = nullptr; + mTensorFeaturesARM.pNext = nullptr; + mDescriptorBufferTensorFeaturesARM.pNext = nullptr; + mShaderFloat8FeaturesEXT.pNext = nullptr; + mDataGraphFeaturesARM.pNext = nullptr; + mPipelineCacheIncrementalModeFeaturesSEC.pNext = nullptr; + mDataGraphModelFeaturesQCOM.pNext = nullptr; + mShaderUntypedPointersFeaturesKHR.pNext = nullptr; + mVideoEncodeRgbConversionFeaturesVALVE.pNext = nullptr; + mShader64BitIndexingFeaturesEXT.pNext = nullptr; + mQueuePerfHintFeaturesQCOM.pNext = nullptr; + mPerformanceCountersByRegionFeaturesARM.pNext = nullptr; + mComputeOccupancyPriorityFeaturesNV.pNext = nullptr; + mShaderLongVectorFeaturesEXT.pNext = nullptr; + mTextureCompressionASTC3DFeaturesEXT.pNext = nullptr; + mShaderSubgroupPartitionedFeaturesEXT.pNext = nullptr; + mShaderSplitBarrierFeaturesEXT.pNext = nullptr; + mDescriptorHeapFeaturesEXT.pNext = nullptr; + mShaderInstrumentationFeaturesARM.pNext = nullptr; + mDeviceAddressCommandsFeaturesKHR.pNext = nullptr; + mShaderConstantDataFeaturesKHR.pNext = nullptr; + mShaderAbortFeaturesKHR.pNext = nullptr; + mDataGraphOpticalFlowFeaturesARM.pNext = nullptr; + mImageTilingControlFeaturesEXT.pNext = nullptr; + mShaderOCPMicroscalingTypesFeaturesEXT.pNext = nullptr; + } + + bool get_extension_requirements(const std::string &ext, ExtensionRequirements &dep) { + if (ext == "VK_KHR_swapchain") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_surface" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_display_swapchain") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_display" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_glsl_shader") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_depth_range_unrestricted") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_sampler_mirror_clamp_to_edge") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_IMG_filter_cubic") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_rasterization_order") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_shader_trinary_minmax") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_shader_explicit_vertex_parameter") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_debug_marker") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_debug_report" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_queue") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_decode_queue") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_video_queue", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_gcn_shader") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_dedicated_allocation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_transform_feedback") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTransformFeedbackFeaturesEXT; + return true; + } + + if (ext == "VK_NVX_binary_import") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NVX_image_view_handle") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_draw_indirect_count") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_negative_viewport_height") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_gpu_shader_half_float") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_shader_ballot") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_video_encode_h264") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_encode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_encode_h265") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_encode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_decode_h264") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_decode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_texture_gather_bias_lod") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_shader_info") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_dynamic_rendering") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_depth_stencil_resolve" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDynamicRenderingFeatures; + return true; + } + + if (ext == "VK_AMD_shader_image_load_store_lod") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_corner_sampled_image") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCornerSampledImageFeaturesNV; + return true; + } + + if (ext == "VK_KHR_multiview") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultiviewFeatures; + return true; + } + + if (ext == "VK_IMG_format_pvrtc") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_external_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_NV_external_memory_capabilities" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_external_memory_win32") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_NV_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_win32_keyed_mutex") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_NV_external_memory_win32" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_device_group") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_device_group_creation" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_shader_draw_parameters") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_shader_subgroup_ballot") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_shader_subgroup_vote") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_texture_compression_astc_hdr") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTextureCompressionASTCHDRFeatures; + return true; + } + + if (ext == "VK_EXT_astc_decode_mode") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mASTCDecodeFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_pipeline_robustness") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineRobustnessFeatures; + return true; + } + + if (ext == "VK_KHR_maintenance1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_external_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory_capabilities" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_memory_win32") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_memory_fd") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_win32_keyed_mutex") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_memory_win32" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_semaphore") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_semaphore_capabilities" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_semaphore_win32") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_semaphore" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_semaphore_fd") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_semaphore" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_push_descriptor") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_conditional_rendering") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mConditionalRenderingFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_shader_float16_int8") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderFloat16Int8Features; + return true; + } + + if (ext == "VK_KHR_16bit_storage") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_storage_buffer_storage_class" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &m16BitStorageFeatures; + return true; + } + + if (ext == "VK_KHR_incremental_present") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_descriptor_update_template") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_clip_space_w_scaling") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_display_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_display_surface_counter", "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_GOOGLE_display_timing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_sample_mask_override_coverage") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_geometry_shader_passthrough") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_viewport_array2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NVX_multiview_per_view_attributes") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_multiview" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_viewport_swizzle") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_discard_rectangles") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_conservative_rasterization") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_depth_clip_enable") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthClipEnableFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_hdr_metadata") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_imageless_framebuffer") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_maintenance2", "VK_KHR_image_format_list" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImagelessFramebufferFeatures; + return true; + } + + if (ext == "VK_KHR_create_renderpass2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_multiview", "VK_KHR_maintenance2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_IMG_relaxed_line_rasterization") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRelaxedLineRasterizationFeaturesIMG; + return true; + } + + if (ext == "VK_KHR_shared_presentable_image") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_get_surface_capabilities2", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_fence") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_fence_capabilities" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_fence_win32") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_fence" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_external_fence_fd") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_fence" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_performance_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPerformanceQueryFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_maintenance2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_variable_pointers") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_storage_buffer_storage_class" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVariablePointersFeatures; + return true; + } + + if (ext == "VK_EXT_external_memory_dma_buf") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_memory_fd" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_queue_family_foreign") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_dedicated_allocation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_memory_requirements2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_sampler_filter_minmax") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_storage_buffer_storage_class") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_gpu_shader_int16") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_gpa_interface") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mGpaFeaturesAMD; + return true; + } + + if (ext == "VK_EXT_descriptor_heap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_4; + static const char * const exts[] = { "VK_KHR_extended_flags", "VK_KHR_maintenance5", "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDescriptorHeapFeaturesEXT; + return true; + } + + if (ext == "VK_AMD_mixed_attachment_samples") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_AMD_shader_fragment_mask") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_inline_uniform_block") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_maintenance1" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mInlineUniformBlockFeatures; + return true; + } + + if (ext == "VK_EXT_shader_stencil_export") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_shader_bfloat16") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderBfloat16FeaturesKHR; + return true; + } + + if (ext == "VK_EXT_sample_locations") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_relaxed_block_layout") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_get_memory_requirements2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_image_format_list") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_blend_operation_advanced") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mBlendOperationAdvancedFeaturesEXT; + return true; + } + + if (ext == "VK_NV_fragment_coverage_to_color") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_acceleration_structure") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_EXT_descriptor_indexing", "VK_KHR_buffer_device_address", "VK_KHR_deferred_host_operations" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAccelerationStructureFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_ray_tracing_pipeline") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_spirv_1_4", "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingPipelineFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_ray_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_spirv_1_4", "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayQueryFeaturesKHR; + return true; + } + + if (ext == "VK_NV_framebuffer_mixed_samples") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_fill_rectangle") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_shader_sm_builtins") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mShaderSMBuiltinsFeaturesNV; + return true; + } + + if (ext == "VK_EXT_post_depth_coverage") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_sampler_ycbcr_conversion") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_maintenance1", "VK_KHR_bind_memory2", "VK_KHR_get_memory_requirements2", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSamplerYcbcrConversionFeatures; + return true; + } + + if (ext == "VK_KHR_bind_memory2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_image_drm_format_modifier") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_bind_memory2", "VK_KHR_get_physical_device_properties2", "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_image_format_list" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_validation_cache") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_descriptor_indexing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_maintenance3" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDescriptorIndexingFeatures; + return true; + } + + if (ext == "VK_EXT_shader_viewport_index_layer") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_portability_subset") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_shading_rate_image") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShadingRateImageFeaturesNV; + return true; + } + + if (ext == "VK_NV_ray_tracing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_get_memory_requirements2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_representative_fragment_test") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRepresentativeFragmentTestFeaturesNV; + return true; + } + + if (ext == "VK_KHR_maintenance3") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_draw_indirect_count") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_filter_cubic") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_QCOM_render_pass_shader_resolve") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_QCOM_cooperative_matrix_conversion") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_cooperative_matrix" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeMatrixConversionFeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_elapsed_timer_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mElapsedTimerQueryFeaturesQCOM; + return true; + } + + if (ext == "VK_EXT_global_priority") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_shader_subgroup_extended_types") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mShaderSubgroupExtendedTypesFeatures; + return true; + } + + if (ext == "VK_KHR_8bit_storage") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_storage_buffer_storage_class" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &m8BitStorageFeatures; + return true; + } + + if (ext == "VK_EXT_external_memory_host") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_buffer_marker") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_shader_atomic_int64") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderAtomicInt64Features; + return true; + } + + if (ext == "VK_KHR_shader_clock") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderClockFeaturesKHR; + return true; + } + + if (ext == "VK_AMD_pipeline_compiler_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_calibrated_timestamps") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_shader_core_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_decode_h265") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_decode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_global_priority") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mGlobalPriorityQueryFeatures; + return true; + } + + if (ext == "VK_AMD_memory_overallocation_behavior") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_vertex_attribute_divisor") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVertexAttributeDivisorFeatures; + return true; + } + + if (ext == "VK_GGP_frame_token") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_GGP_stream_descriptor_surface" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_pipeline_creation_feedback") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_driver_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_shader_float_controls") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_shader_subgroup_partitioned") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + return true; + } + + if (ext == "VK_KHR_depth_stencil_resolve") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_create_renderpass2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_swapchain_mutable_format") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_maintenance2", "VK_KHR_image_format_list" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_compute_shader_derivatives") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mComputeShaderDerivativesFeaturesKHR; + return true; + } + + if (ext == "VK_NV_mesh_shader") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMeshShaderFeaturesNV; + return true; + } + + if (ext == "VK_NV_fragment_shader_barycentric") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentShaderBarycentricFeaturesKHR; + return true; + } + + if (ext == "VK_NV_shader_image_footprint") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderImageFootprintFeaturesNV; + return true; + } + + if (ext == "VK_NV_scissor_exclusive") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExclusiveScissorFeaturesNV; + return true; + } + + if (ext == "VK_NV_device_diagnostic_checkpoints") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_timeline_semaphore") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTimelineSemaphoreFeatures; + return true; + } + + if (ext == "VK_EXT_present_timing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_present_id2", "VK_KHR_get_surface_capabilities2", "VK_KHR_calibrated_timestamps" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentTimingFeaturesEXT; + return true; + } + + if (ext == "VK_INTEL_shader_integer_functions2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderIntegerFunctions2FeaturesINTEL; + return true; + } + + if (ext == "VK_INTEL_performance_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_vulkan_memory_model") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVulkanMemoryModelFeatures; + return true; + } + + if (ext == "VK_EXT_pci_bus_info") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_display_native_hdr") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_get_surface_capabilities2", "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_shader_terminate_invocation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderTerminateInvocationFeatures; + return true; + } + + if (ext == "VK_EXT_fragment_density_map") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentDensityMapFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_scalar_block_layout") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mScalarBlockLayoutFeatures; + return true; + } + + if (ext == "VK_GOOGLE_hlsl_functionality1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_GOOGLE_decorate_string") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_subgroup_size_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mSubgroupSizeControlFeatures; + return true; + } + + if (ext == "VK_KHR_fragment_shading_rate") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_create_renderpass2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentShadingRateFeaturesKHR; + return true; + } + + if (ext == "VK_AMD_shader_core_properties2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_AMD_shader_core_properties" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_AMD_device_coherent_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCoherentMemoryFeaturesAMD; + return true; + } + + if (ext == "VK_KHR_shader_constant_data") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderConstantDataFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_dynamic_rendering_local_read") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_dynamic_rendering" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDynamicRenderingLocalReadFeatures; + return true; + } + + if (ext == "VK_KHR_shader_abort") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_device_fault", "VK_KHR_shader_constant_data" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderAbortFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_image_atomic_int64") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderImageAtomicInt64FeaturesEXT; + return true; + } + + if (ext == "VK_KHR_shader_quad_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_vulkan_memory_model", "VK_KHR_shader_maximal_reconvergence" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderQuadControlFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_spirv_1_4") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_shader_float_controls" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_memory_budget") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_memory_priority") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMemoryPriorityFeaturesEXT; + return true; + } + + if (ext == "VK_NV_dedicated_allocation_image_aliasing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_dedicated_allocation", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDedicatedAllocationImageAliasingFeaturesNV; + return true; + } + + if (ext == "VK_KHR_separate_depth_stencil_layouts") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_create_renderpass2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSeparateDepthStencilLayoutsFeatures; + return true; + } + + if (ext == "VK_EXT_buffer_device_address") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mBufferDeviceAddressFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_tooling_info") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_separate_stencil_usage") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_present_wait") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_present_id" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentWaitFeaturesKHR; + return true; + } + + if (ext == "VK_NV_cooperative_matrix") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeMatrixFeaturesNV; + return true; + } + + if (ext == "VK_NV_coverage_reduction_mode") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_NV_framebuffer_mixed_samples", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCoverageReductionModeFeaturesNV; + return true; + } + + if (ext == "VK_EXT_fragment_shader_interlock") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentShaderInterlockFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_ycbcr_image_arrays") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_sampler_ycbcr_conversion" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mYcbcrImageArraysFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_uniform_buffer_standard_layout") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mUniformBufferStandardLayoutFeatures; + return true; + } + + if (ext == "VK_EXT_provoking_vertex") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mProvokingVertexFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_full_screen_exclusive") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_surface", "VK_KHR_get_surface_capabilities2", "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_buffer_device_address") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_device_group" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mBufferDeviceAddressFeatures; + return true; + } + + if (ext == "VK_EXT_line_rasterization") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mLineRasterizationFeatures; + return true; + } + + if (ext == "VK_EXT_shader_atomic_float") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderAtomicFloatFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_host_query_reset") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mHostQueryResetFeatures; + return true; + } + + if (ext == "VK_EXT_index_type_uint8") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mIndexTypeUint8Features; + return true; + } + + if (ext == "VK_EXT_extended_dynamic_state") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExtendedDynamicStateFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_deferred_host_operations") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_pipeline_executable_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineExecutablePropertiesFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_host_image_copy") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_copy_commands2", "VK_KHR_format_feature_flags2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mHostImageCopyFeatures; + return true; + } + + if (ext == "VK_KHR_map_memory2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_map_memory_placed") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_4; + static const char * const exts[] = { "VK_KHR_map_memory2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMapMemoryPlacedFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_shader_atomic_float2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_shader_atomic_float" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderAtomicFloat2FeaturesEXT; + return true; + } + + if (ext == "VK_EXT_swapchain_maintenance1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_EXT_surface_maintenance1", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSwapchainMaintenance1FeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_demote_to_helper_invocation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderDemoteToHelperInvocationFeatures; + return true; + } + + if (ext == "VK_NV_device_generated_commands") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDeviceGeneratedCommandsFeaturesNV; + return true; + } + + if (ext == "VK_NV_inherited_viewport_scissor") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mInheritedViewportScissorFeaturesNV; + return true; + } + + if (ext == "VK_KHR_shader_integer_dot_product") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderIntegerDotProductFeatures; + return true; + } + + if (ext == "VK_EXT_texel_buffer_alignment") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTexelBufferAlignmentFeaturesEXT; + return true; + } + + if (ext == "VK_QCOM_render_pass_transform") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_depth_bias_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthBiasControlFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_device_memory_report") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDeviceMemoryReportFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_robustness2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRobustness2FeaturesKHR; + return true; + } + + if (ext == "VK_EXT_custom_border_color") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCustomBorderColorFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_texture_compression_astc_3d") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTextureCompressionASTC3DFeaturesEXT; + return true; + } + + if (ext == "VK_GOOGLE_user_type") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_pipeline_library") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_NV_present_barrier") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_surface", "VK_KHR_get_surface_capabilities2", "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentBarrierFeaturesNV; + return true; + } + + if (ext == "VK_KHR_shader_non_semantic_info") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_present_id") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentIdFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_private_data") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPrivateDataFeatures; + return true; + } + + if (ext == "VK_EXT_pipeline_creation_cache_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineCreationCacheControlFeatures; + return true; + } + + if (ext == "VK_KHR_video_encode_queue") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_video_queue", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_NV_device_diagnostics_config") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDiagnosticsConfigFeaturesNV; + return true; + } + + if (ext == "VK_QCOM_render_pass_store_ops") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_QCOM_queue_perf_hint") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mQueuePerfHintFeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_image_processing3") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageProcessing3FeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_shader_multiple_wait_queues") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderMultipleWaitQueuesFeaturesQCOM; + return true; + } + + if (ext == "VK_EXT_shader_split_barrier") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderSplitBarrierFeaturesEXT; + return true; + } + + if (ext == "VK_NV_cuda_kernel_launch") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_QCOM_tile_shading") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_QCOM_tile_properties" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTileShadingFeaturesQCOM; + return true; + } + + if (ext == "VK_NV_low_latency") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_EXT_metal_objects") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_synchronization2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSynchronization2Features; + return true; + } + + if (ext == "VK_EXT_descriptor_buffer") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address", "VK_EXT_descriptor_indexing", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDescriptorBufferFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_device_address_commands") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address", "VK_KHR_synchronization2", "VK_EXT_extended_dynamic_state" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDeviceAddressCommandsFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_graphics_pipeline_library") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_pipeline_library" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mGraphicsPipelineLibraryFeaturesEXT; + return true; + } + + if (ext == "VK_AMD_shader_early_and_late_fragment_tests") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderEarlyAndLateFragmentTestsFeaturesAMD; + return true; + } + + if (ext == "VK_KHR_fragment_shader_barycentric") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentShaderBarycentricFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_shader_subgroup_uniform_control_flow") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mShaderSubgroupUniformControlFlowFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_zero_initialize_workgroup_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mZeroInitializeWorkgroupMemoryFeatures; + return true; + } + + if (ext == "VK_NV_fragment_shading_rate_enums") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_fragment_shading_rate" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentShadingRateEnumsFeaturesNV; + return true; + } + + if (ext == "VK_NV_ray_tracing_motion_blur") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingMotionBlurFeaturesNV; + return true; + } + + if (ext == "VK_EXT_mesh_shader") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_spirv_1_4" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMeshShaderFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_ycbcr_2plane_444_formats") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_sampler_ycbcr_conversion" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mYcbcr2Plane444FormatsFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_fragment_density_map2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_fragment_density_map" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentDensityMap2FeaturesEXT; + return true; + } + + if (ext == "VK_QCOM_rotated_copy_commands") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_copy_commands2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_image_robustness") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageRobustnessFeatures; + return true; + } + + if (ext == "VK_KHR_workgroup_memory_explicit_layout") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mWorkgroupMemoryExplicitLayoutFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_copy_commands2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_image_compression_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageCompressionControlFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_attachment_feedback_loop_layout") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAttachmentFeedbackLoopLayoutFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_4444_formats") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &m4444FormatsFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_device_fault") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFaultFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_rasterization_order_attachment_access") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRasterizationOrderAttachmentAccessFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_rgba10x6_formats") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_sampler_ycbcr_conversion" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRGBA10X6FormatsFeaturesEXT; + return true; + } + + if (ext == "VK_NV_acquire_winrt_display") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_direct_mode_display" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_VALVE_mutable_descriptor_type") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_maintenance3" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMutableDescriptorTypeFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_vertex_input_dynamic_state") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVertexInputDynamicStateFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_physical_device_drm") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_device_address_binding_report") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_EXT_debug_utils" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAddressBindingReportFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_depth_clip_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthClipControlFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_primitive_topology_list_restart") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPrimitiveTopologyListRestartFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_format_feature_flags2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_present_mode_fifo_latest_ready") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentModeFifoLatestReadyFeaturesKHR; + return true; + } + + if (ext == "VK_FUCHSIA_external_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory_capabilities", "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_FUCHSIA_external_semaphore") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_external_semaphore_capabilities", "VK_KHR_external_semaphore" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_FUCHSIA_buffer_collection") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_FUCHSIA_external_memory", "VK_KHR_sampler_ycbcr_conversion" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_HUAWEI_subpass_shading") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_create_renderpass2", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSubpassShadingFeaturesHUAWEI; + return true; + } + + if (ext == "VK_HUAWEI_invocation_mask") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mInvocationMaskFeaturesHUAWEI; + return true; + } + + if (ext == "VK_NV_external_memory_rdma") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExternalMemoryRDMAFeaturesNV; + return true; + } + + if (ext == "VK_EXT_pipeline_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelinePropertiesFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_frame_boundary") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFrameBoundaryFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_multisampled_render_to_single_sampled") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_create_renderpass2", "VK_KHR_depth_stencil_resolve" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultisampledRenderToSingleSampledFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_extended_dynamic_state2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExtendedDynamicState2FeaturesEXT; + return true; + } + + if (ext == "VK_EXT_color_write_enable") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mColorWriteEnableFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_primitives_generated_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_transform_feedback" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPrimitivesGeneratedQueryFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_ray_tracing_maintenance1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingMaintenance1FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_shader_untyped_pointers") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderUntypedPointersFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_global_priority_query") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_EXT_global_priority", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mGlobalPriorityQueryFeatures; + return true; + } + + if (ext == "VK_VALVE_video_encode_rgb_conversion") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_video_encode_queue", "VK_KHR_sampler_ycbcr_conversion" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoEncodeRgbConversionFeaturesVALVE; + return true; + } + + if (ext == "VK_EXT_image_view_min_lod") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageViewMinLodFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_multi_draw") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultiDrawFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_image_2d_view_of_3d") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_maintenance1", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImage2DViewOf3DFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_shader_tile_image") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + dep.primary_feature = &mShaderTileImageFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_opacity_micromap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_acceleration_structure", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mOpacityMicromapFeaturesEXT; + return true; + } + + if (ext == "VK_NV_displacement_micromap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_opacity_micromap" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_load_store_op_none") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_HUAWEI_cluster_culling_shader") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mClusterCullingShaderFeaturesHUAWEI; + return true; + } + + if (ext == "VK_EXT_border_color_swizzle") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_custom_border_color" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mBorderColorSwizzleFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_pageable_device_local_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_memory_priority" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPageableDeviceLocalMemoryFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_maintenance4") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mMaintenance4Features; + return true; + } + + if (ext == "VK_ARM_shader_core_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + return true; + } + + if (ext == "VK_KHR_shader_subgroup_rotate") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderSubgroupRotateFeatures; + return true; + } + + if (ext == "VK_ARM_scheduling_controls") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_ARM_shader_core_builtins" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSchedulingControlsFeaturesARM; + return true; + } + + if (ext == "VK_EXT_image_sliced_view_of_3d") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_maintenance1", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageSlicedViewOf3DFeaturesEXT; + return true; + } + + if (ext == "VK_VALVE_descriptor_set_host_mapping") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDescriptorSetHostMappingFeaturesVALVE; + return true; + } + + if (ext == "VK_EXT_depth_clamp_zero_one") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthClampZeroOneFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_non_seamless_cube_map") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mNonSeamlessCubeMapFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_render_pass_striped") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRenderPassStripedFeaturesARM; + return true; + } + + if (ext == "VK_QCOM_fragment_density_map_offset") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_EXT_fragment_density_map" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentDensityMapOffsetFeaturesEXT; + return true; + } + + if (ext == "VK_NV_copy_memory_indirect") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCopyMemoryIndirectFeaturesNV; + return true; + } + + if (ext == "VK_NV_memory_decompression") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMemoryDecompressionFeaturesEXT; + return true; + } + + if (ext == "VK_NV_device_generated_commands_compute") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_NV_device_generated_commands" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDeviceGeneratedCommandsComputeFeaturesNV; + return true; + } + + if (ext == "VK_NV_ray_tracing_linear_swept_spheres") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingLinearSweptSpheresFeaturesNV; + return true; + } + + if (ext == "VK_NV_linear_color_attachment") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mLinearColorAttachmentFeaturesNV; + return true; + } + + if (ext == "VK_KHR_shader_maximal_reconvergence") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mShaderMaximalReconvergenceFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_image_compression_control_swapchain") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_image_compression_control" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageCompressionControlSwapchainFeaturesEXT; + return true; + } + + if (ext == "VK_QCOM_image_processing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_format_feature_flags2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageProcessingFeaturesQCOM; + return true; + } + + if (ext == "VK_EXT_nested_command_buffer") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mNestedCommandBufferFeaturesEXT; + return true; + } + + if (ext == "VK_OHOS_external_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_external_memory", "VK_KHR_dedicated_allocation", "VK_EXT_queue_family_foreign" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_external_memory_acquire_unmodified") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_extended_dynamic_state3") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExtendedDynamicState3FeaturesEXT; + return true; + } + + if (ext == "VK_EXT_subpass_merge_feedback") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSubpassMergeFeedbackFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_tensors") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + dep.primary_feature = &mTensorFeaturesARM; + dep.secondary_feature = &mDescriptorBufferTensorFeaturesARM; + return true; + } + + if (ext == "VK_EXT_shader_module_identifier") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_EXT_pipeline_creation_cache_control" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderModuleIdentifierFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_rasterization_order_attachment_access") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRasterizationOrderAttachmentAccessFeaturesEXT; + return true; + } + + if (ext == "VK_NV_optical_flow") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_format_feature_flags2", "VK_KHR_synchronization2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mOpticalFlowFeaturesNV; + return true; + } + + if (ext == "VK_EXT_legacy_dithering") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mLegacyDitheringFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_pipeline_protected_access") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineProtectedAccessFeatures; + return true; + } + + if (ext == "VK_KHR_maintenance5") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_dynamic_rendering" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMaintenance5Features; + return true; + } + + if (ext == "VK_AMD_anti_lag") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAntiLagFeaturesAMD; + return true; + } + + if (ext == "VK_KHR_present_id2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_get_surface_capabilities2", "VK_KHR_surface", "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentId2FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_present_wait2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_get_surface_capabilities2", "VK_KHR_surface", "VK_KHR_swapchain", "VK_KHR_present_id2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentWait2FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_ray_tracing_position_fetch") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingPositionFetchFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_object") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_dynamic_rendering" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderObjectFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_pipeline_binary") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_4; + static const char * const exts[] = { "VK_KHR_extended_flags", "VK_KHR_maintenance5" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineBinaryFeaturesKHR; + return true; + } + + if (ext == "VK_QCOM_tile_properties") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTilePropertiesFeaturesQCOM; + return true; + } + + if (ext == "VK_SEC_amigo_profiling") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAmigoProfilingFeaturesSEC; + return true; + } + + if (ext == "VK_KHR_swapchain_maintenance1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_KHR_surface_maintenance1", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mSwapchainMaintenance1FeaturesKHR; + return true; + } + + if (ext == "VK_QCOM_multiview_per_view_viewports") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultiviewPerViewViewportsFeaturesQCOM; + return true; + } + + if (ext == "VK_NV_ray_tracing_invocation_reorder") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingInvocationReorderFeaturesNV; + return true; + } + + if (ext == "VK_NV_cooperative_vector") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeVectorFeaturesNV; + return true; + } + + if (ext == "VK_NV_extended_sparse_address_space") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExtendedSparseAddressSpaceFeaturesNV; + return true; + } + + if (ext == "VK_EXT_mutable_descriptor_type") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_maintenance3" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMutableDescriptorTypeFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_legacy_vertex_attributes") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_vertex_input_dynamic_state" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mLegacyVertexAttributesFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_shader_core_builtins") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderCoreBuiltinsFeaturesARM; + return true; + } + + if (ext == "VK_EXT_pipeline_library_group_handles") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline", "VK_KHR_pipeline_library" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineLibraryGroupHandlesFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_dynamic_rendering_unused_attachments") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_dynamic_rendering" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDynamicRenderingUnusedAttachmentsFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_internally_synchronized_queues") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mInternallySynchronizedQueuesFeaturesKHR; + return true; + } + + if (ext == "VK_NV_low_latency2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_timeline_semaphore", "VK_KHR_present_id", "VK_KHR_present_id2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_cooperative_matrix") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeMatrixFeaturesKHR; + return true; + } + + if (ext == "VK_ARM_data_graph") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_extended_flags", "VK_KHR_maintenance5", "VK_KHR_deferred_host_operations" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDataGraphFeaturesARM; + return true; + } + + if (ext == "VK_ARM_data_graph_instruction_set_tosa") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_ARM_data_graph" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_QCOM_multiview_per_view_render_areas") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultiviewPerViewRenderAreasFeaturesQCOM; + return true; + } + + if (ext == "VK_KHR_compute_shader_derivatives") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mComputeShaderDerivativesFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_video_decode_av1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_decode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_video_encode_av1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_encode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoEncodeAV1FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_video_decode_vp9") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_decode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoDecodeVP9FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_video_maintenance1") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoMaintenance1FeaturesKHR; + return true; + } + + if (ext == "VK_NV_per_stage_descriptor_set") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_4; + static const char * const exts[] = { "VK_KHR_maintenance6" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPerStageDescriptorSetFeaturesNV; + return true; + } + + if (ext == "VK_QCOM_image_processing2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_QCOM_image_processing" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageProcessing2FeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_filter_cubic_weights") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_filter_cubic" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCubicWeightsFeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_ycbcr_degamma") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mYcbcrDegammaFeaturesQCOM; + return true; + } + + if (ext == "VK_QCOM_filter_cubic_clamp") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_EXT_filter_cubic", "VK_EXT_sampler_filter_minmax" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCubicClampFeaturesQCOM; + return true; + } + + if (ext == "VK_EXT_attachment_feedback_loop_dynamic_state") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_EXT_attachment_feedback_loop_layout" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mAttachmentFeedbackLoopDynamicStateFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_vertex_attribute_divisor") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVertexAttributeDivisorFeatures; + return true; + } + + if (ext == "VK_KHR_load_store_op_none") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_unified_image_layouts") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mUnifiedImageLayoutsFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_shader_float_controls2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_shader_float_controls" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderFloatControls2Features; + return true; + } + + if (ext == "VK_MSFT_layered_driver") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_index_type_uint8") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mIndexTypeUint8Features; + return true; + } + + if (ext == "VK_KHR_line_rasterization") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mLineRasterizationFeatures; + return true; + } + + if (ext == "VK_KHR_calibrated_timestamps") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_shader_expect_assume") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderExpectAssumeFeatures; + return true; + } + + if (ext == "VK_KHR_maintenance6") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mMaintenance6Features; + return true; + } + + if (ext == "VK_NV_descriptor_pool_overallocation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mDescriptorPoolOverallocationFeaturesNV; + return true; + } + + if (ext == "VK_QCOM_tile_memory_heap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_memory_requirements2", "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mTileMemoryHeapFeaturesQCOM; + return true; + } + + if (ext == "VK_KHR_copy_memory_indirect") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCopyMemoryIndirectFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_memory_decompression") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_buffer_device_address" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMemoryDecompressionFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_video_encode_intra_refresh") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_encode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoEncodeIntraRefreshFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_video_encode_quantization_map") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_video_encode_queue", "VK_KHR_format_feature_flags2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoEncodeQuantizationMapFeaturesKHR; + return true; + } + + if (ext == "VK_NV_raw_access_chains") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRawAccessChainsFeaturesNV; + return true; + } + + if (ext == "VK_NV_external_compute_queue") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + return true; + } + + if (ext == "VK_KHR_shader_relaxed_extended_instruction") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderRelaxedExtendedInstructionFeaturesKHR; + return true; + } + + if (ext == "VK_NV_command_buffer_inheritance") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCommandBufferInheritanceFeaturesNV; + return true; + } + + if (ext == "VK_KHR_maintenance7") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mMaintenance7FeaturesKHR; + return true; + } + + if (ext == "VK_NV_shader_atomic_float16_vector") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderAtomicFloat16VectorFeaturesNV; + return true; + } + + if (ext == "VK_EXT_shader_replicated_composites") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderReplicatedCompositesFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_tensor_controls") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_ARM_tensors" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_shader_float8") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderFloat8FeaturesEXT; + return true; + } + + if (ext == "VK_NV_ray_tracing_validation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingValidationFeaturesNV; + return true; + } + + if (ext == "VK_NV_cluster_acceleration_structure") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mClusterAccelerationStructureFeaturesNV; + return true; + } + + if (ext == "VK_NV_partitioned_acceleration_structure") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_acceleration_structure" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPartitionedAccelerationStructureFeaturesNV; + return true; + } + + if (ext == "VK_EXT_device_generated_commands") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_buffer_device_address", "VK_KHR_extended_flags", "VK_KHR_maintenance5" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDeviceGeneratedCommandsFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_device_fault") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFaultFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_maintenance8") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + dep.primary_feature = &mMaintenance8FeaturesKHR; + return true; + } + + if (ext == "VK_MESA_image_alignment_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mImageAlignmentControlFeaturesMESA; + return true; + } + + if (ext == "VK_KHR_shader_fma") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderFmaFeaturesKHR; + return true; + } + + if (ext == "VK_NV_push_constant_bank") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + dep.primary_feature = &mPushConstantBankFeaturesNV; + return true; + } + + if (ext == "VK_EXT_ray_tracing_invocation_reorder") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_ray_tracing_pipeline" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRayTracingInvocationReorderFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_depth_clamp_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthClampControlFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_maintenance9") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMaintenance9FeaturesKHR; + return true; + } + + if (ext == "VK_KHR_video_maintenance2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoMaintenance2FeaturesKHR; + return true; + } + + if (ext == "VK_HUAWEI_hdr_vivid") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_swapchain", "VK_EXT_hdr_metadata" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mHdrVividFeaturesHUAWEI; + return true; + } + + if (ext == "VK_NV_cooperative_matrix2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_cooperative_matrix" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeMatrix2FeaturesNV; + return true; + } + + if (ext == "VK_ARM_pipeline_opacity_micromap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_EXT_opacity_micromap" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineOpacityMicromapFeaturesARM; + return true; + } + + if (ext == "VK_KHR_video_encode_feedback2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_video_encode_queue" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVideoEncodeFeedback2FeaturesKHR; + return true; + } + + if (ext == "VK_IMG_filter_linear_2d") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_format_feature_flags2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_EXT_external_memory_metal") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_external_memory" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + return true; + } + + if (ext == "VK_KHR_depth_clamp_zero_one") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDepthClampZeroOneFeaturesKHR; + return true; + } + + if (ext == "VK_ARM_performance_counters_by_region") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPerformanceCountersByRegionFeaturesARM; + return true; + } + + if (ext == "VK_ARM_shader_instrumentation") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderInstrumentationFeaturesARM; + return true; + } + + if (ext == "VK_EXT_vertex_attribute_robustness") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mVertexAttributeRobustnessFeaturesEXT; + return true; + } + + if (ext == "VK_ARM_format_pack") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFormatPackFeaturesARM; + return true; + } + + if (ext == "VK_VALVE_fragment_density_map_layered") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_4; + static const char * const exts[] = { "VK_KHR_extended_flags", "VK_KHR_maintenance5", "VK_EXT_fragment_density_map" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentDensityMapLayeredFeaturesVALVE; + return true; + } + + if (ext == "VK_KHR_robustness2") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mRobustness2FeaturesKHR; + return true; + } + + if (ext == "VK_NV_present_metering") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentMeteringFeaturesNV; + return true; + } + + if (ext == "VK_EXT_multisampled_render_to_swapchain") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain", "VK_EXT_multisampled_render_to_single_sampled" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMultisampledRenderToSwapchainFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_fragment_density_map_offset") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_3; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_EXT_fragment_density_map", "VK_KHR_create_renderpass2", "VK_KHR_dynamic_rendering" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mFragmentDensityMapOffsetFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_zero_initialize_device_memory") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mZeroInitializeDeviceMemoryFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_present_mode_fifo_latest_ready") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_swapchain" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPresentModeFifoLatestReadyFeaturesKHR; + return true; + } + + if (ext == "VK_KHR_opacity_micromap") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_KHR_acceleration_structure", "VK_KHR_device_address_commands" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mOpacityMicromapFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_64bit_indexing") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShader64BitIndexingFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_custom_resolve") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCustomResolveFeaturesEXT; + return true; + } + + if (ext == "VK_QCOM_data_graph_model") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_ARM_data_graph" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDataGraphModelFeaturesQCOM; + return true; + } + + if (ext == "VK_KHR_maintenance10") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMaintenance10FeaturesKHR; + return true; + } + + if (ext == "VK_ARM_data_graph_optical_flow") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_ARM_data_graph" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mDataGraphOpticalFlowFeaturesARM; + return true; + } + + if (ext == "VK_EXT_shader_long_vector") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + dep.primary_feature = &mShaderLongVectorFeaturesEXT; + return true; + } + + if (ext == "VK_SEC_pipeline_cache_incremental_mode") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPipelineCacheIncrementalModeFeaturesSEC; + return true; + } + + if (ext == "VK_EXT_shader_uniform_buffer_unsized_array") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderUniformBufferUnsizedArrayFeaturesEXT; + return true; + } + + if (ext == "VK_NV_compute_occupancy_priority") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mComputeOccupancyPriorityFeaturesNV; + return true; + } + + if (ext == "VK_KHR_maintenance11") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mMaintenance11FeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_subgroup_partitioned") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderSubgroupPartitionedFeaturesEXT; + return true; + } + + if (ext == "VK_KHR_extended_flags") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mExtendedFlagsFeaturesKHR; + return true; + } + + if (ext == "VK_EXT_shader_ocp_microscaling_types") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderOCPMicroscalingTypesFeaturesEXT; + return true; + } + + if (ext == "VK_VALVE_shader_mixed_float_dot_product") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_2; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2", "VK_KHR_shader_float16_int8" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mShaderMixedFloatDotProductFeaturesVALVE; + return true; + } + + if (ext == "VK_SEC_throttle_hint") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + dep.primary_feature = &mThrottleHintFeaturesSEC; + return true; + } + + if (ext == "VK_ARM_data_graph_neural_accelerator_statistics") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + dep.primary_feature = &mDataGraphNeuralAcceleratorStatisticsFeaturesARM; + return true; + } + + if (ext == "VK_EXT_primitive_restart_index") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_1; + static const char * const exts[] = { "VK_KHR_get_physical_device_properties2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mPrimitiveRestartIndexFeaturesEXT; + return true; + } + + if (ext == "VK_EXT_image_tiling_control") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + dep.primary_feature = &mImageTilingControlFeaturesEXT; + return true; + } + + if (ext == "VK_NV_cooperative_matrix_decode_vector") { + dep = {}; + dep.minimum_api_version = VK_VERSION_1_0; + static const char * const exts[] = { "VK_NV_cooperative_matrix2" }; + dep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0])); + dep.extension_dependencies = exts; + dep.primary_feature = &mCooperativeMatrixDecodeVectorFeaturesNV; + return true; + } + + return false; + } +}; + diff --git a/extract_vulkan_extensions_sifter.py b/extract_vulkan_extensions_sifter.py index 2c72b883..2c7b9f5a 100755 --- a/extract_vulkan_extensions_sifter.py +++ b/extract_vulkan_extensions_sifter.py @@ -59,6 +59,19 @@ def find_active_enum_types(active_types, extending_types, mappings, enum_types, return active_enum_types +def is_banned_ext(ext): + if 'Scissor' in ext: + return False + if 'DisplacementMicromap' in ext: + return True + if 'CudaKernelLaunch' in ext: + return True + banned_vendors = [ 'ANDROID', 'AMDX', 'Sci', 'Portability', 'VulkanSC', 'QNX' ] + for vendor in banned_vendors: + if vendor in ext: + return True + return False + def main(): parser = argparse.ArgumentParser(description = 'Script for extracting what needs to be sifted through w.r.t. PDF2.') parser.add_argument('--xml', help = 'Path to Vulkan registry XML.') @@ -88,6 +101,8 @@ def main(): category = t.attrib['category'] if category == 'struct': name = t.attrib['name'] + if is_banned_ext(name): + continue member_types = [] extended_types = set() extends = set() @@ -102,13 +117,14 @@ def main(): print('#pragma once') print('// Autogenerated from extract_vulkan_extensions_sifter.py') + print('#include ') print('static const struct {') print('\tVkStructureType sType;') print('\tsize_t size;') print('} pNextLUT[] = {') for entry in pNextLUT: - print('\t{', entry[0], ',', f'sizeof({name})', '},') + print('\t{', entry[0] + ',', f'sizeof({entry[1]})', '},') print('};\n') print('struct ExtensionRequirements {') @@ -122,7 +138,7 @@ def main(): member_names = [] print('struct ExistingFeatureStructs {') for feat in feature_structs: - print(f'\t{feat} {feat[16:]} =', '{', feature_structs[feat], '};') + print(f'\t{feat} m{feat[16:]} =', '{', feature_structs[feat], '};') member_names.append(feat[16:]) info_impl = [] @@ -132,9 +148,7 @@ def main(): ext_name = ext.attrib['name'] deps = ext.attrib['depends'] if 'depends' in ext.attrib else None - if 'ANDROID' in ext_name: - continue - if 'AMDX' in ext_name: + if is_banned_ext(ext_name): continue core_dep = 'VK_VERSION_1_0' @@ -142,34 +156,21 @@ def main(): # Crude parsing. Don't want to implement basic grammar here, so just do # the minimal hackery needed to parse the xml. + # Just consider everything "and". if deps: or_deps = deps.split(',') - and_deps = deps.split('+') - - has_core_dep = False - if len(or_deps) > 1: - for dep in or_deps: - if ('VK_VERSION' in dep) and ('+' not in dep) and ('(' not in dep) and (')' not in dep): - if dep > core_dep: - core_dep = dep - has_core_dep = True - - if not has_core_dep: - for dep in and_deps: + for or_dep in or_deps: + deps = or_dep.split('+') + for dep in deps: while dep[0] == '(': dep = dep[1:] while dep[-1] == ')': dep = dep[:-1] - or_deps = dep.split(',') - has_core_dep = False - for subdep in or_deps: - if 'VK_VERSION' in subdep: - if subdep > core_dep: - core_dep = subdep - has_core_dep = True - break - if not has_core_dep: - ext_deps.append(subdep) + if 'VK_VERSION' in dep: + if dep > core_dep: + core_dep = dep + else: + ext_deps.append(dep) features = [] for reqs in ext.iter('require'): @@ -187,9 +188,9 @@ def main(): info_impl.append('\tdep.num_extension_dependencies = uint32_t(sizeof(exts) / sizeof(exts[0]));') info_impl.append('\tdep.extension_dependencies = exts;') if len(features) >= 1: - info_impl.append(f'\tdep.primary_feature = &{features[0][16:]};') + info_impl.append(f'\tdep.primary_feature = &m{features[0][16:]};') if len(features) >= 2: - info_impl.append(f'\tdep.secondary_feature = &{features[1][16:]};') + info_impl.append(f'\tdep.secondary_feature = &m{features[1][16:]};') info_impl.append('\treturn true;') info_impl.append('}') info_impl.append('') @@ -198,10 +199,10 @@ def main(): print('\tvoid reset_pnext() {') for member_name in member_names: - print(f'\t\t{member_name}.pNext = nullptr;') + print(f'\t\tm{member_name}.pNext = nullptr;') print('\t}\n') - print('\tbool get_extension_requirements(ExtensionRequirements &dep) {') + print('\tbool get_extension_requirements(const std::string &ext, ExtensionRequirements &dep) {') for l in info_impl: if len(l): print('\t\t' + l) diff --git a/khronos/vulkan/vulkan_core.h b/khronos/vulkan/vulkan_core.h index 042cf481..a26833ad 100644 --- a/khronos/vulkan/vulkan_core.h +++ b/khronos/vulkan/vulkan_core.h @@ -4,7 +4,7 @@ /* ** Copyright 2015-2026 The Khronos Group Inc. ** -** SPDX-License-Identifier: Apache-2.0 +** SPDX-License-Identifier: Apache-2.0 OR MIT */ /* @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 351 +#define VK_HEADER_VERSION 358 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -1343,6 +1343,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, + VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM = 1000565000, + VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM = 1000565001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT = 1000567000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000, @@ -1404,6 +1406,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR = 1000598000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR = 1000598001, + VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR = 1000598002, VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, @@ -1426,6 +1431,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT = 1000616000, + VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT = 1000616001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, @@ -1465,6 +1472,14 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR = 1000657001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC = 1000664000, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR = 1000668000, + VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000668001, + VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000668002, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR = 1000668003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR = 1000668004, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR = 1000668005, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR = 1000668006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT = 1000672000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE = 1000673000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC = 1000674000, VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC = 1000674001, @@ -1472,6 +1487,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM = 1000676002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT = 1000678000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT = 1000687000, + VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT = 1000687001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV = 1000689000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias @@ -1810,6 +1828,7 @@ typedef enum VkVendorId { VK_VENDOR_ID_MESA = 0x10005, VK_VENDOR_ID_POCL = 0x10006, VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_APE = 0x10008, VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF } VkVendorId; @@ -6352,6 +6371,8 @@ typedef enum VkDriverId { VK_DRIVER_ID_MESA_HONEYKRISP = 26, VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, VK_DRIVER_ID_MESA_KOSMICKRISP = 28, + VK_DRIVER_ID_MESA_GFXSTREAM = 29, + VK_DRIVER_ID_APE_SOFT = 30, VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, @@ -7361,6 +7382,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_2D_BIT_IMG = 0x200000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x10000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; @@ -9041,6 +9063,7 @@ typedef enum VkSwapchainCreateFlagBitsKHR { VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, + VK_SWAPCHAIN_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00000100, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkSwapchainCreateFlagBitsKHR; @@ -12212,6 +12235,13 @@ typedef enum VkVideoEncodeFeedbackFlagBitsKHR { VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_FEEDBACK_AVERAGE_QUANTIZATION_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_FEEDBACK_MIN_QUANTIZATION_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_FEEDBACK_MAX_QUANTIZATION_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_FEEDBACK_INTRA_PIXELS_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_FEEDBACK_INTER_PIXELS_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_FEEDBACK_SKIPPED_PIXELS_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_FEEDBACK_PICTURE_PARTITION_COUNT_BIT_KHR = 0x00000200, VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeFeedbackFlagBitsKHR; typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; @@ -13481,6 +13511,11 @@ typedef enum VkComponentTypeKHR { VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, + VK_COMPONENT_TYPE_FLOAT6_E2M3_EXT = 1000672000, + VK_COMPONENT_TYPE_FLOAT6_E3M2_EXT = 1000672001, + VK_COMPONENT_TYPE_FLOAT4_E2M1_EXT = 1000672002, + VK_COMPONENT_TYPE_FLOAT8_UNSIGNED_E8M0_EXT = 1000672003, + VK_COMPONENT_TYPE_MXINT8_EXT = 1000672004, VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, @@ -14567,6 +14602,40 @@ typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR { +// VK_KHR_video_encode_feedback2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_feedback2 1 +#define VK_KHR_VIDEO_ENCODE_FEEDBACK_2_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_FEEDBACK_2_EXTENSION_NAME "VK_KHR_video_encode_feedback2" + +typedef enum VkVideoEncodePerPartitionFeedbackFlagBitsKHR { + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_STATUS_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodePerPartitionFeedbackFlagBitsKHR; +typedef VkFlags VkVideoEncodePerPartitionFeedbackFlagsKHR; +typedef struct VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeFeedback2; +} VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR; + +typedef struct VkVideoEncodeFeedback2CapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR supportedPerPartitionEncodeFeedbackFlags; +} VkVideoEncodeFeedback2CapabilitiesKHR; + +typedef struct VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR perPartitionEncodeFeedbackFlags; +} VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR; + + + // VK_KHR_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_depth_clamp_zero_one 1 #define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 @@ -14773,6 +14842,117 @@ typedef struct VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR { +// VK_KHR_extended_flags is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_extended_flags 1 +#define VK_KHR_EXTENDED_FLAGS_SPEC_VERSION 1 +#define VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME "VK_KHR_extended_flags" +typedef VkFlags64 VkFormatFeatureFlags4KHR; + +// Flag bits for VkFormatFeatureFlagBits4KHR +typedef VkFlags64 VkFormatFeatureFlagBits4KHR; + +typedef VkFlags64 VkImageUsageFlags2KHR; + +// Flag bits for VkImageUsageFlagBits2KHR +typedef VkFlags64 VkImageUsageFlagBits2KHR; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLED_BIT_KHR = 0x00000004ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_STORAGE_BIT_KHR = 0x00000008ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000010ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000020ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSIENT_ATTACHMENT_BIT_KHR = 0x00000040ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_INPUT_ATTACHMENT_BIT_KHR = 0x00000080ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00000400ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x00040000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_HOST_TRANSFER_BIT_KHR = 0x00400000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TENSOR_ALIASING_BIT_ARM = 0x00800000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000ULL; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL; + +typedef VkFlags64 VkImageCreateFlags2KHR; + +// Flag bits for VkImageCreateFlagBits2KHR +typedef VkFlags64 VkImageCreateFlagBits2KHR; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_BINDING_BIT_KHR = 0x00000001ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_RESIDENCY_BIT_KHR = 0x00000002ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_ALIASED_BIT_KHR = 0x00000004ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_MUTABLE_FORMAT_BIT_KHR = 0x00000008ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_CUBE_COMPATIBLE_BIT_KHR = 0x00000010ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR = 0x00400000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000040ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_EXTENDED_USAGE_BIT_KHR = 0x00000100ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_DISJOINT_BIT_KHR = 0x00000200ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_ALIAS_BIT_KHR = 0x00000400ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_PROTECTED_BIT_KHR = 0x00000800ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_CORNER_SAMPLED_BIT_NV = 0x00002000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SUBSAMPLED_BIT_EXT = 0x00004000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000ULL; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000ULL; + +typedef struct VkFormatProperties4KHR { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags4KHR linearTilingFeatures; + VkFormatFeatureFlags4KHR optimalTilingFeatures; + VkFormatFeatureFlags4KHR bufferFeatures; +} VkFormatProperties4KHR; + +typedef struct VkImageUsageFlags2CreateInfoKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags2KHR usage; +} VkImageUsageFlags2CreateInfoKHR; + +typedef struct VkImageCreateFlags2CreateInfoKHR { + VkStructureType sType; + void* pNext; + VkImageCreateFlags2KHR flags; +} VkImageCreateFlags2CreateInfoKHR; + +typedef struct VkImageViewUsage2CreateInfoKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags2KHR usage; +} VkImageViewUsage2CreateInfoKHR; + +typedef struct VkPhysicalDeviceExtendedFlagsFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 extendedFlags; +} VkPhysicalDeviceExtendedFlagsFeaturesKHR; + +typedef struct VkImageStencilUsage2CreateInfoKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags2KHR stencilUsage; +} VkImageStencilUsage2CreateInfoKHR; + +typedef struct VkSharedPresentSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags2KHR sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilities2KHR; + + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -16429,7 +16609,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCmdEndGpaSessionAMD)(VkCommandBuffer commandB typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, uint32_t* pSampleID); typedef void (VKAPI_PTR *PFN_vkCmdEndGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID); typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionStatusAMD)(VkDevice device, VkGpaSessionAMD gpaSession); -typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionResultsAMD)(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t* pSizeInBytes, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionResultsAMD)(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t* pSizeInBytes, void* pData); typedef VkResult (VKAPI_PTR *PFN_vkResetGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession); typedef void (VKAPI_PTR *PFN_vkCmdCopyGpaSessionResultsAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); @@ -20154,7 +20334,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM( // VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls. #define VK_NV_low_latency 1 -#define VK_NV_LOW_LATENCY_SPEC_VERSION 1 +#define VK_NV_LOW_LATENCY_SPEC_VERSION 2 #define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" typedef struct VkQueryLowLatencySupportNV { VkStructureType sType; @@ -20162,6 +20342,60 @@ typedef struct VkQueryLowLatencySupportNV { void* pQueriedLowLatencyData; } VkQueryLowLatencySupportNV; +typedef void (VKAPI_PTR *PFN_vkSetLatencySleepModeLegacyNV)(VkDevice device, VkBool32 lowLatencyMode, VkBool32 lowLatencyBoost, uint32_t minimumIntervalUs); +typedef void (VKAPI_PTR *PFN_vkLatencySleepLegacyNV)(VkDevice device, VkSemaphore signalSemaphore, uint64_t value); +typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerLegacyNV)(VkDevice device, uint64_t frameID, uint32_t marker); +typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsLegacyNV)(VkDevice device, void* pTimings); +typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandLegacyNV)(VkQueue queue, uint32_t queueType); +typedef void (VKAPI_PTR *PFN_vkGetSleepStatusLegacyNV)(VkDevice device, VkBool32* pLowLatencyMode); +typedef void (VKAPI_PTR *PFN_vkShutdownLatencyDeviceLegacyNV)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetLatencySleepModeLegacyNV( + VkDevice device, + VkBool32 lowLatencyMode, + VkBool32 lowLatencyBoost, + uint32_t minimumIntervalUs); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkLatencySleepLegacyNV( + VkDevice device, + VkSemaphore signalSemaphore, + uint64_t value); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerLegacyNV( + VkDevice device, + uint64_t frameID, + uint32_t marker); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsLegacyNV( + VkDevice device, + void* pTimings); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandLegacyNV( + VkQueue queue, + uint32_t queueType); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetSleepStatusLegacyNV( + VkDevice device, + VkBool32* pLowLatencyMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkShutdownLatencyDeviceLegacyNV( + VkDevice device); +#endif +#endif // VK_EXT_descriptor_buffer is a preprocessor guard. Do not pass it to API calls. @@ -21530,6 +21764,7 @@ typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { void* pNext; VkBool32 micromap; VkBool32 micromapCaptureReplay; + // micromapHostCommands is legacy, but no reason was given in the API XML VkBool32 micromapHostCommands; } VkPhysicalDeviceOpacityMicromapFeaturesEXT; @@ -22738,6 +22973,11 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorViewARM) typedef enum VkTensorTilingARM { VK_TENSOR_TILING_OPTIMAL_ARM = 0, VK_TENSOR_TILING_LINEAR_ARM = 1, + VK_TENSOR_TILING_BRICK_16_WIDE_ARM = 1000565000, + VK_TENSOR_TILING_BRICK_8_WIDE_ARM = 1000565001, + VK_TENSOR_TILING_BRICK_4_WIDE_ARM = 1000565002, + VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_ARM = 1000565003, + VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_64K_ARM = 1000565004, VK_TENSOR_TILING_MAX_ENUM_ARM = 0x7FFFFFFF } VkTensorTilingARM; typedef VkFlags64 VkTensorCreateFlagsARM; @@ -24667,6 +24907,29 @@ typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT { +// VK_ARM_tensor_controls is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_tensor_controls 1 +#define VK_MAX_TENSOR_CREATE_INFO_ROLLING_BACKING_WRAP_COUNT_ARM 4U +#define VK_ARM_TENSOR_CONTROLS_SPEC_VERSION 1 +#define VK_ARM_TENSOR_CONTROLS_EXTENSION_NAME "VK_ARM_tensor_controls" +typedef struct VkTensorRollingBackingCreateInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t wraps[VK_MAX_TENSOR_CREATE_INFO_ROLLING_BACKING_WRAP_COUNT_ARM]; +} VkTensorRollingBackingCreateInfoARM; + +typedef struct VkTensorExplicitTilingFormatPropertiesARM { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 brick16TilingTensorFeatures; + VkFormatFeatureFlags2 brick8TilingTensorFeatures; + VkFormatFeatureFlags2 brick4TilingTensorFeatures; + VkFormatFeatureFlags2 blockUTilingTensorFeatures; + VkFormatFeatureFlags2 blockU64kTilingTensorFeatures; +} VkTensorExplicitTilingFormatPropertiesARM; + + + // VK_EXT_shader_float8 is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_shader_float8 1 #define VK_EXT_SHADER_FLOAT8_SPEC_VERSION 1 @@ -25530,6 +25793,12 @@ typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM { +// VK_IMG_filter_linear_2d is a preprocessor guard. Do not pass it to API calls. +#define VK_IMG_filter_linear_2d 1 +#define VK_IMG_FILTER_LINEAR_2D_SPEC_VERSION 1 +#define VK_IMG_FILTER_LINEAR_2D_EXTENSION_NAME "VK_IMG_filter_linear_2d" + + // VK_ARM_performance_counters_by_region is a preprocessor guard. Do not pass it to API calls. #define VK_ARM_performance_counters_by_region 1 #define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION 1 @@ -25752,6 +26021,24 @@ typedef struct VkPhysicalDevicePresentMeteringFeaturesNV { +// VK_EXT_multisampled_render_to_swapchain is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_multisampled_render_to_swapchain 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SWAPCHAIN_SPEC_VERSION 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SWAPCHAIN_EXTENSION_NAME "VK_EXT_multisampled_render_to_swapchain" +typedef struct VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multisampledRenderToSwapchain; +} VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT; + +typedef struct VkSwapchainFlagsSurfaceCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkSwapchainCreateFlagsKHR swapchainSupportedFlags; +} VkSwapchainFlagsSurfaceCapabilitiesEXT; + + + // VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_fragment_density_map_offset 1 #define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 @@ -26099,6 +26386,21 @@ typedef struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT { +// VK_EXT_shader_ocp_microscaling_types is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_ocp_microscaling_types 1 +#define VK_EXT_SHADER_OCP_MICROSCALING_TYPES_SPEC_VERSION 1 +#define VK_EXT_SHADER_OCP_MICROSCALING_TYPES_EXTENSION_NAME "VK_EXT_shader_ocp_microscaling_types" +typedef struct VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat4; + VkBool32 shaderFloat6; + VkBool32 shaderFloat8UnsignedE8M0; + VkBool32 shaderMXInt8; +} VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT; + + + // VK_VALVE_shader_mixed_float_dot_product is a preprocessor guard. Do not pass it to API calls. #define VK_VALVE_shader_mixed_float_dot_product 1 #define VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_SPEC_VERSION 1 @@ -26191,6 +26493,43 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartIndexEXT( #endif +// VK_EXT_image_tiling_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_tiling_control 1 +#define VK_EXT_IMAGE_TILING_CONTROL_SPEC_VERSION 1 +#define VK_EXT_IMAGE_TILING_CONTROL_EXTENSION_NAME "VK_EXT_image_tiling_control" + +typedef enum VkImageTilingControlEXT { + VK_IMAGE_TILING_CONTROL_DEFAULT_EXT = 0, + VK_IMAGE_TILING_CONTROL_MIN_SIZE_EXT = 1, + VK_IMAGE_TILING_CONTROL_MAX_PERFORMANCE_EXT = 2, + VK_IMAGE_TILING_CONTROL_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageTilingControlEXT; +typedef struct VkPhysicalDeviceImageTilingControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageTilingControl; +} VkPhysicalDeviceImageTilingControlFeaturesEXT; + +typedef struct VkImageTilingControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageTilingControlEXT tilingControl; +} VkImageTilingControlCreateInfoEXT; + + + +// VK_NV_cooperative_matrix_decode_vector is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cooperative_matrix_decode_vector 1 +#define VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_matrix_decode_vector" +typedef struct VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrixDecodeVector; +} VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV; + + + // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_acceleration_structure 1 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 @@ -26286,6 +26625,7 @@ typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { VkBool32 accelerationStructure; VkBool32 accelerationStructureCaptureReplay; VkBool32 accelerationStructureIndirectBuild; + // accelerationStructureHostCommands is legacy, but no reason was given in the API XML VkBool32 accelerationStructureHostCommands; VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; } VkPhysicalDeviceAccelerationStructureFeaturesKHR; From 5cdac68b7fd142ac3e0c71c44237bbdd495fa2ae Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Wed, 5 Aug 2026 15:30:47 +0200 Subject: [PATCH 16/17] Use execlp instead of execl. --- cli/fossilize_validate_cache_roundtrip.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cli/fossilize_validate_cache_roundtrip.cpp b/cli/fossilize_validate_cache_roundtrip.cpp index ea6bd8cd..18338d42 100644 --- a/cli/fossilize_validate_cache_roundtrip.cpp +++ b/cli/fossilize_validate_cache_roundtrip.cpp @@ -609,9 +609,9 @@ static bool check_replayer_roundtrip(const std::string &replayer, const char *fo _exit(EXIT_FAILURE); close(pipe_fd[1]); - if (execl(replayer.c_str(), replayer.c_str(), - foz_path, "--num-threads", "1", "--on-disk-pipeline-cache", - cache_bin, static_cast(nullptr)) < 0) + if (execlp(replayer.c_str(), replayer.c_str(), + foz_path, "--num-threads", "1", "--on-disk-pipeline-cache", + cache_bin, static_cast(nullptr)) < 0) { LOGE("Failed to spawn child process \"%s\".\n", replayer.c_str()); _exit(EXIT_FAILURE); @@ -691,4 +691,4 @@ int main(int argc, char **argv) if (!ret) return EXIT_FAILURE; -} \ No newline at end of file +} From 093ebb16d992bda6773c0bf056baf3390873b4b5 Mon Sep 17 00:00:00 2001 From: Hans-Kristian Arntzen Date: Wed, 5 Aug 2026 15:34:03 +0200 Subject: [PATCH 17/17] Remove some dead code from sifter script. --- extract_vulkan_extensions_sifter.py | 53 ----------------------------- 1 file changed, 53 deletions(-) diff --git a/extract_vulkan_extensions_sifter.py b/extract_vulkan_extensions_sifter.py index 2c7b9f5a..b18af85a 100755 --- a/extract_vulkan_extensions_sifter.py +++ b/extract_vulkan_extensions_sifter.py @@ -6,59 +6,6 @@ import json import sys -StructType = namedtuple('StructType', ['extends', 'member_types']) -EnumType = namedtuple('EnumType', ['extensions']) - -def traverse_active_struct_type(active_types, t, mapping): - if t not in mapping: - return - if t in active_types: - return - active_types.add(t) - for m in mapping[t].member_types: - traverse_active_struct_type(active_types, m, mapping) - -def traverse_active_struct_types(base_types, mapping): - active_types = set() - for t in base_types: - traverse_active_struct_type(active_types, t, mapping) - return active_types - -def struct_extends_any(active_types, t, mappings): - if t not in mappings: - return False - for e in mappings[t].extends: - if e in active_types or struct_extends_any(active_types, e, mappings): - return True - return False - -def find_extending_structs(active_types, mappings): - extending_structs = set() - for m in mappings.keys(): - if struct_extends_any(active_types, m, mappings): - for memb in traverse_active_struct_types([m], mappings): - extending_structs.add(memb) - return extending_structs - -def find_active_enum_types(active_types, extending_types, mappings, enum_types, bitmask_reqs): - active_enum_types = set() - - for t in active_types: - for m in mappings[t].member_types: - if m in bitmask_reqs: - active_enum_types.add(bitmask_reqs[m]) - elif m in enum_types: - active_enum_types.add(m) - - for t in extending_types: - for m in mappings[t].member_types: - if m in bitmask_reqs: - active_enum_types.add(bitmask_reqs[m]) - elif m in enum_types: - active_enum_types.add(m) - - return active_enum_types - def is_banned_ext(ext): if 'Scissor' in ext: return False