From 2310ab969f26730c5c41a99f837f4aa64b929e7e Mon Sep 17 00:00:00 2001 From: Rune Date: Tue, 14 Apr 2026 14:01:37 +0200 Subject: [PATCH] finalized --- Setup/src/Program.bf | 225 +- src/Library.bf | 35 +- src/Loader.bf | 1 + src/Metadata.bf | 8508 ++++++++++++++++++++++++++++++++++++++---- 4 files changed, 7932 insertions(+), 837 deletions(-) diff --git a/Setup/src/Program.bf b/Setup/src/Program.bf index b83ac5b..49d1568 100644 --- a/Setup/src/Program.bf +++ b/Setup/src/Program.bf @@ -59,7 +59,7 @@ static class Metadata } } - public void WriteToStream(String strBuffer, StreamWriter writer, StringView decl, params Span<(StringView sig, enum { Method, Property, Cases } mode)> methodSigs) + public void WriteToStream(String strBuffer, StreamWriter writer, StringView decl, params Span<(StringView sig, enum { Method, Property, UniqueProperty, Cases } mode)> methodSigs) { strBuffer.Clear(); strBuffer.Append(decl, "\n{\n"); @@ -67,7 +67,8 @@ static class Metadata { if (@sig.Index != 0) strBuffer.Append('\n'); StringView indent; - strBuffer.Append("\t", sig.sig); + if (!sig.sig.IsNull) + strBuffer.Append("\tpublic ", sig.sig); switch (sig.mode) { case .Method: @@ -79,7 +80,7 @@ static class Metadata { """); - case .Property: + case .Property, .UniqueProperty: indent = "\t\t\t"; strBuffer.Append(""" @@ -92,7 +93,6 @@ static class Metadata """); case .Cases: indent = "\t"; - strBuffer.Length--; } for (let kv in this) { @@ -105,22 +105,25 @@ static class Metadata { case .Cases: if (val != null) - strBuffer.Append(" = "); - case .Method, .Property: - strBuffer.Append(": return "); + strBuffer.Append(" = ", val); + strBuffer.Append(";\n"); + case .Method: + strBuffer.Append(":", val); + case .Property, .UniqueProperty: + strBuffer.Append(": return ", val, ";\n"); } - strBuffer.Append(val, ";\n"); } switch (sig.mode) { case .Method: strBuffer.Append(""" - default: return default; + default: + Runtime.FatalError("Index out of range"); } } """); - case .Property: + case .Property, .UniqueProperty: strBuffer.Append(""" default: return default; } @@ -128,8 +131,47 @@ static class Metadata } """); + + if (_ == .UniqueProperty) + { + writer.Write(strBuffer); + strBuffer.Clear(); + var iter = sig.sig.Split(' '); + StringView type = iter.GetNext(); + bool string = false; + if (type == "String") { type = "StringView"; string = true; } + StringView name = iter.GetNext(); + strBuffer.Append(""" + + [Optimize] public static Self For + """, name, "(", type, """ + val) + { + Self output = 0; + + """); + if (string) strBuffer.Append("\t\tint hash = val.GetHashCode();\n"); + for (let kv in this) + { + if (kv.value.predicate != null && *kv.value.predicate != .AlreadyWritten) + continue; + let val = kv.value.underlying.[Friend]mVal[@sig.Index]; + if (val == null) continue; + strBuffer.Append("\t\tif ("); + if (string) + strBuffer.AppendF($"hash == {val.GetHashCode()} && "); + strBuffer.Append("val == ", val, ") output = ", kv.key, ";\n"); + } + strBuffer.Append(""" + return output; + } + + """); + } case .Cases: } + writer.Write(strBuffer); + strBuffer.Clear(); } strBuffer.Append("}\n\n"); writer.Write(strBuffer); @@ -138,13 +180,17 @@ static class Metadata public enum ApiVersion { Cases, FeatureStruct } public static append EnumMetadata apiVersion; - public enum Extensions { Cases, Name, Tag, Kind, MinVersion, PromotedTo, Dependencies } + public enum Extensions { Cases, Name, Tag, Kind, MinVersion, PromotedTo, FeatureStruct, DependencyCount, GetDependency } public static append EnumMetadata extensions; - public enum Features { Cases, ApiVersion, ExtensionStruct } + public enum Features { Cases, ApiVersion, Extension } public static append EnumMetadata features; public enum TypeEnum { Type } public static append EnumMetadata vkStructureType; public static append EnumMetadata vkObjectType; + public enum Formats { Size, ComponentCount, GetComponent } + public static append EnumMetadata vkFormat; + public enum CasesOnlyEnum { Cases } + public static append EnumMetadata vkFormatComponentNumericFormat; } class VulkanFeature @@ -352,6 +398,9 @@ class RegistryParser : XmlParser Extensions, Extension, Require, + + Formats, + Format, } append List eStack = .(16); @@ -436,7 +485,10 @@ class RegistryParser : XmlParser append String handle_parent = .(64); EnumFeature curEnum; + int ext_number = -1; + append String ext_tag = .(16); + append String ext_name = .(64); class Param { @@ -468,6 +520,9 @@ class RegistryParser : XmlParser return param; } + String format_name = command_rettype; + append List format_components = .(4); + public override void StartElementHandler(char8* nameC, char8** attsC) { HandleCData(); @@ -589,8 +644,20 @@ class RegistryParser : XmlParser eStack.Add(.Ignore); } case .Require: - if (vkTypes.TryGetValue(atts["name"], let value)) + let name = atts["name"]; + if (vkTypes.TryGetValue(name, let value)) + { + if (eStack[^2] == .Extension && + name.StartsWith("VkPhysicalDevice") && + name.EndsWith(ext_tag) && + name[..<^ext_tag.Length].EndsWith("Features")) + { + strBuf.Clear(); + strBuf.Append(name, ".SType"); + Metadata.extensions.For(ext_name).At(.FeatureStruct) = new:alloc .(strBuf); + } vkOutput.Add(value); + } eStack.Add(.Ignore); default: eStack.Add(.Type); @@ -749,12 +816,13 @@ class RegistryParser : XmlParser FeatureComment(); ext_number = int.Parse(atts["number"]); - let name = atts["name"]; - if (!name.StartsWith("VK")) break; - var value = Metadata.extensions.For(name); + ext_name.Set(atts["name"]); + ext_tag.Set(atts.GetValueOrDefault("author")); + if (!ext_name.StartsWith("VK")) break; + var value = Metadata.extensions.For(ext_name); value.At(.Cases) = new:alloc .(atts["number"]); - value.At(.Tag) = new:alloc $"\"{atts.GetValueOrDefault("author")}\""; - value.At(.Name) = new:alloc $"nameof({name})"; + value.At(.Tag) = new:alloc $"\"{ext_tag}\""; + value.At(.Name) = new:alloc $"nameof({ext_name})"; if (atts.TryGetValue("promotedto", let promotedto) && promotedto.StartsWith("VK_VERSION_")) value.At(.PromotedTo) = new:alloc $".{promotedto}"; switch (atts["type"]) @@ -766,13 +834,23 @@ class RegistryParser : XmlParser command_rettype.Clear(); if (atts.TryGetValue("depends", let depends)) { - strBuf.Set("Self[?]("); + List dependencies = scope .(8); + strBuf.Clear(); cdata.Clear(); char8 lastOp = '\0'; void Handle(char8 c) { - mixin Version() { Runtime.Assert(command_rettype.IsEmpty); command_rettype.Set(cdata); } - mixin Extension() { strBuf.Append(cdata, ", "); } + mixin Version() + { + Runtime.Assert(command_rettype.IsEmpty); + command_rettype.Set(cdata); + } + mixin Extension() + { + int index = strBuf.Length; + strBuf.Append(cdata); + dependencies.Add(strBuf[index...]); + } if (!cdata.IsEmpty) { @@ -808,17 +886,51 @@ class RegistryParser : XmlParser Handle(c); } Handle(lastOp); - if (!strBuf.EndsWith('(')) + value.At(.DependencyCount) = new:alloc .(dependencies.Count.ToString(..scope .(8))); + if (!dependencies.IsEmpty) { - strBuf.Length -= 2; - strBuf.Append(')'); - value.At(.Dependencies) = new:alloc .(strBuf); + cdata.Set(""" + + switch (idx) + { + + """); + for (let dep in dependencies) + { + cdata.Append("\t\t\tcase "); + @dep.Index.ToString(cdata); + cdata.Append(": return ", dep, ";\n"); + } + cdata.Append(""" + default: Runtime.FatalError("Index out of range"); + } + + """); + value.At(.GetDependency) = new:alloc .(cdata); } + cdata.Clear(); } if (command_rettype.IsEmpty) command_rettype.Set("VK_VERSION_1_0"); value.At(.MinVersion) = new:alloc $".{command_rettype}"; case "require": eStack.Add(.Require); FeatureComment(); + + case "formats": eStack.Add(.Formats); + case "format" when eStack.Back == .Formats: + format_name.Set(atts["name"]); + format_components.Clear(); + let clazz = atts["class"]; + if (clazz.EndsWith("-bit")) + Metadata.vkFormat.For(format_name).At(.Size) = new:alloc .(clazz[...^5]); + eStack.Add(.Format); + case "component" when eStack.Back == .Format: + let name = atts["name"]; + let bits = atts["bits"]; + let numericFormat = atts["numericFormat"]; + format_components.Add(new $".(.{name}, {(bits == "compressed") ? "null" : bits}, .{numericFormat})"); + Metadata.vkFormatComponentNumericFormat.For(numericFormat).At(.Cases) = null; + eStack.Add(.Ignore); + default: eStack.Add(.Ignore); } } @@ -989,9 +1101,8 @@ class RegistryParser : XmlParser } else { - mode = .ExtensionStruct; - strBuf.Append(type_name); - strBuf.Append(".SType"); + mode = .Extension; + strBuf.Append(".ForFeatureStruct(", type_name, ".SType)"); } String outputStr = new:alloc .(strBuf); for (let field in fields) @@ -1491,6 +1602,29 @@ class RegistryParser : XmlParser } vkCommands.Add(feature.name, feature); + case .Format: + let value = Metadata.vkFormat.For(format_name); + value.At(.ComponentCount) = new:alloc .(format_components.Count.ToString(..scope .(1))); + strBuf.Clear(); + strBuf.Append(""" + + switch (idx) + { + + """); + for (let componet in format_components) + { + strBuf.Append("\t\t\tcase "); + @componet.Index.ToString(strBuf); + strBuf.Append(": return ", componet, ";\n"); + delete componet; + } + strBuf.Append(""" + default: Runtime.FatalError("Index out of range"); + } + + """); + value.At(.GetComponent) = new:alloc .(strBuf); default: } } @@ -1666,6 +1800,7 @@ class Program public void LoadInstance(VkInstance instance) mut { + this.vkGetDeviceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceProcAddr)); """); LoadFunc("vkGetInstanceProcAddr", "instance", .Instance); @@ -1674,7 +1809,7 @@ class Program public void LoadDevice(VkDevice device) mut { - + """); LoadFunc("vkGetDeviceProcAddr", "device", .Device); writer.Write(""" @@ -1748,28 +1883,38 @@ class Program String strBuffer = scope .(1024); Metadata.apiVersion.WriteToStream(strBuffer, writer, "enum VulkanApiVersion", (null, .Cases), - ("public VkStructureType FeatureStruct", .Property)); + ("VkStructureType FeatureStruct", .UniqueProperty)); Metadata.extensions.WriteToStream(strBuffer, writer, "enum VulkanExtension", (null, .Cases), - ("public String Name", .Property), - ("public String Tag", .Property), - ("public Kind Kind", .Property), - ("public VulkanApiVersion MinVersion", .Property), - ("public VulkanApiVersion PromotedTo", .Property), - ("public Span Dependencies", .Property)); + ("String Name", .UniqueProperty), + ("String Tag", .Property), + ("Kind Kind", .Property), + ("VulkanApiVersion MinVersion", .Property), + ("VulkanApiVersion PromotedTo", .Property), + ("VkStructureType FeatureStruct", .UniqueProperty), + ("int DependencyCount", .Property), + ("VulkanExtension GetDependency(int idx)", .Method)); + Metadata.features.Values.GetNextRef()->At(.Cases) = "1"; Metadata.features.WriteToStream(strBuffer, writer, "enum VulkanFeature", (null, .Cases), - ("public VulkanApiVersion ApiVersion", .Property), - ("public VkStructureType ExtensionStruct", .Property)); + ("VulkanApiVersion ApiVersion", .Property), + ("VulkanExtension Extension", .Property)); writer.Write(""" namespace Vulkan; """); Metadata.vkStructureType.WriteToStream(strBuffer, writer, "extension VkStructureType", - ("public Type Type", .Property)); + ("Type Type", .UniqueProperty)); Metadata.vkObjectType.WriteToStream(strBuffer, writer, "extension VkObjectType", - ("public Type Type", .Property)); + ("Type Type", .UniqueProperty)); + Metadata.vkFormatComponentNumericFormat.WriteToStream(strBuffer, writer, "extension VkFormat { extension Component { public enum NumericFormat", + (null, .Cases)); + writer.Write("}}"); + Metadata.vkFormat.WriteToStream(strBuffer, writer, "extension VkFormat", + ("int? Size", .Property), + ("int ComponentCount", .Property), + ("Component GetComponent(int idx)", .Method)); } return 0; diff --git a/src/Library.bf b/src/Library.bf index 39c6d20..053de9c 100644 --- a/src/Library.bf +++ b/src/Library.bf @@ -2,6 +2,7 @@ using System; using System.Interop; +using System.Collections; namespace Vulkan; @@ -17,7 +18,7 @@ static #if BF_PLATFORM_WINDOWS .Stdcall; #else - .Cdecl; + .Unspecified; #endif public const let VK_NULL_HANDLE = 0; @@ -29,11 +30,43 @@ extension VkResult public void ReturnValueDiscarded(); } +extension VkFormat +{ + public struct Component : this(Channel channel, int? bits, NumericFormat numericFormat) + { + public enum Channel { R, G, B, A, D, S } + } + + //public struct ChromaSubsamplingInfo : this(int luma, int chroma1, int chroma2); +} + namespace Vulkan.Metadata; extension VulkanExtension { public enum Kind { Instance, Device } + + public struct DependencyIterator : IEnumerator + { + public VulkanExtension ext; + public int index; + public int count; + + public this(VulkanExtension ext) + { + this.ext = ext; + this.index = 0; + this.count = ext.DependencyCount; + } + + public Result GetNext() mut + { + if (index >= count) return .Err; + return .Ok(ext.GetDependency(index++)); + } + } + + public DependencyIterator Dependencies => .(this); } namespace Vulkan.External; diff --git a/src/Loader.bf b/src/Loader.bf index fa8e2cb..500bdd6 100644 --- a/src/Loader.bf +++ b/src/Loader.bf @@ -801,6 +801,7 @@ struct VulkanLoadedFunctions public void LoadInstance(VkInstance instance) mut { + this.vkGetDeviceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceProcAddr)); vkDestroyInstance = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyInstance)); vkEnumeratePhysicalDevices = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDevices)); vkGetInstanceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetInstanceProcAddr)); diff --git a/src/Metadata.bf b/src/Metadata.bf index fd46c2a..240f5db 100644 --- a/src/Metadata.bf +++ b/src/Metadata.bf @@ -30,6 +30,17 @@ enum VulkanApiVersion } } } + + [Optimize] public static Self ForFeatureStruct(VkStructureType val) + { + Self output = 0; + if (val == VkPhysicalDeviceFeatures2.SType) output = VK_VERSION_1_0; + if (val == VkPhysicalDeviceVulkan11Features.SType) output = VK_VERSION_1_1; + if (val == VkPhysicalDeviceVulkan12Features.SType) output = VK_VERSION_1_2; + if (val == VkPhysicalDeviceVulkan13Features.SType) output = VK_VERSION_1_3; + if (val == VkPhysicalDeviceVulkan14Features.SType) output = VK_VERSION_1_4; + return output; + } } enum VulkanExtension @@ -920,6 +931,450 @@ enum VulkanExtension } } + [Optimize] public static Self ForName(StringView val) + { + Self output = 0; + int hash = val.GetHashCode(); + if (hash == 8743063546775429071 && val == nameof(VK_KHR_surface)) output = VK_KHR_surface; + if (hash == 6486896262943679627 && val == nameof(VK_KHR_swapchain)) output = VK_KHR_swapchain; + if (hash == 2055499575234524367 && val == nameof(VK_KHR_display)) output = VK_KHR_display; + if (hash == 1300184948511142355 && val == nameof(VK_KHR_display_swapchain)) output = VK_KHR_display_swapchain; + if (hash == -8022610639545746499 && val == nameof(VK_KHR_xlib_surface)) output = VK_KHR_xlib_surface; + if (hash == -2914471236368938614 && val == nameof(VK_KHR_xcb_surface)) output = VK_KHR_xcb_surface; + if (hash == 1781714664280839955 && val == nameof(VK_KHR_wayland_surface)) output = VK_KHR_wayland_surface; + if (hash == 7967043933206391240 && val == nameof(VK_KHR_android_surface)) output = VK_KHR_android_surface; + if (hash == 7682077071559030206 && val == nameof(VK_KHR_win32_surface)) output = VK_KHR_win32_surface; + if (hash == -291247945447122538 && val == nameof(VK_EXT_debug_report)) output = VK_EXT_debug_report; + if (hash == 1185386388189347232 && val == nameof(VK_NV_glsl_shader)) output = VK_NV_glsl_shader; + if (hash == -686230304835972461 && val == nameof(VK_EXT_depth_range_unrestricted)) output = VK_EXT_depth_range_unrestricted; + if (hash == 5853137973999270875 && val == nameof(VK_KHR_sampler_mirror_clamp_to_edge)) output = VK_KHR_sampler_mirror_clamp_to_edge; + if (hash == 8676692966933324128 && val == nameof(VK_IMG_filter_cubic)) output = VK_IMG_filter_cubic; + if (hash == 2850452525100587307 && val == nameof(VK_AMD_rasterization_order)) output = VK_AMD_rasterization_order; + if (hash == -8349120680897837738 && val == nameof(VK_AMD_shader_trinary_minmax)) output = VK_AMD_shader_trinary_minmax; + if (hash == -5791463845990128146 && val == nameof(VK_AMD_shader_explicit_vertex_parameter)) output = VK_AMD_shader_explicit_vertex_parameter; + if (hash == -7994774581169842122 && val == nameof(VK_EXT_debug_marker)) output = VK_EXT_debug_marker; + if (hash == -657089890654062072 && val == nameof(VK_KHR_video_queue)) output = VK_KHR_video_queue; + if (hash == -5691271118451476580 && val == nameof(VK_KHR_video_decode_queue)) output = VK_KHR_video_decode_queue; + if (hash == 8624558983075722082 && val == nameof(VK_AMD_gcn_shader)) output = VK_AMD_gcn_shader; + if (hash == -3015848204578470776 && val == nameof(VK_NV_dedicated_allocation)) output = VK_NV_dedicated_allocation; + if (hash == 7947566610424930850 && val == nameof(VK_EXT_transform_feedback)) output = VK_EXT_transform_feedback; + if (hash == 698108996878631294 && val == nameof(VK_NVX_binary_import)) output = VK_NVX_binary_import; + if (hash == 8795489997854482341 && val == nameof(VK_NVX_image_view_handle)) output = VK_NVX_image_view_handle; + if (hash == 5960232606277835871 && val == nameof(VK_AMD_draw_indirect_count)) output = VK_AMD_draw_indirect_count; + if (hash == 273672408865378197 && val == nameof(VK_AMD_negative_viewport_height)) output = VK_AMD_negative_viewport_height; + if (hash == 6371033191843767453 && val == nameof(VK_AMD_gpu_shader_half_float)) output = VK_AMD_gpu_shader_half_float; + if (hash == 2341009102941086347 && val == nameof(VK_AMD_shader_ballot)) output = VK_AMD_shader_ballot; + if (hash == -8109525482146935292 && val == nameof(VK_KHR_video_encode_h264)) output = VK_KHR_video_encode_h264; + if (hash == -8109806957123645948 && val == nameof(VK_KHR_video_encode_h265)) output = VK_KHR_video_encode_h265; + if (hash == -8040540387453481468 && val == nameof(VK_KHR_video_decode_h264)) output = VK_KHR_video_decode_h264; + if (hash == 5132976202106309980 && val == nameof(VK_AMD_texture_gather_bias_lod)) output = VK_AMD_texture_gather_bias_lod; + if (hash == -4557863237365887093 && val == nameof(VK_AMD_shader_info)) output = VK_AMD_shader_info; + if (hash == 5658858624424576618 && val == nameof(VK_KHR_dynamic_rendering)) output = VK_KHR_dynamic_rendering; + if (hash == -2594876538022112139 && val == nameof(VK_AMD_shader_image_load_store_lod)) output = VK_AMD_shader_image_load_store_lod; + if (hash == -5900082732180772551 && val == nameof(VK_GGP_stream_descriptor_surface)) output = VK_GGP_stream_descriptor_surface; + if (hash == 5317453645990531052 && val == nameof(VK_NV_corner_sampled_image)) output = VK_NV_corner_sampled_image; + if (hash == 6872785227548926080 && val == nameof(VK_KHR_multiview)) output = VK_KHR_multiview; + if (hash == -2203425481690835482 && val == nameof(VK_IMG_format_pvrtc)) output = VK_IMG_format_pvrtc; + if (hash == 1406897960298061131 && val == nameof(VK_NV_external_memory_capabilities)) output = VK_NV_external_memory_capabilities; + if (hash == 7601690673586158681 && val == nameof(VK_NV_external_memory)) output = VK_NV_external_memory; + if (hash == -826673979142952079 && val == nameof(VK_NV_external_memory_win32)) output = VK_NV_external_memory_win32; + if (hash == 8694627684591669607 && val == nameof(VK_NV_win32_keyed_mutex)) output = VK_NV_win32_keyed_mutex; + if (hash == 8895742802585649527 && val == nameof(VK_KHR_get_physical_device_properties2)) output = VK_KHR_get_physical_device_properties2; + if (hash == -8438581111333076118 && val == nameof(VK_KHR_device_group)) output = VK_KHR_device_group; + if (hash == -8948844116434831712 && val == nameof(VK_EXT_validation_flags)) output = VK_EXT_validation_flags; + if (hash == 8356642701617406361 && val == nameof(VK_NN_vi_surface)) output = VK_NN_vi_surface; + if (hash == -4571747875975205389 && val == nameof(VK_KHR_shader_draw_parameters)) output = VK_KHR_shader_draw_parameters; + if (hash == 4333010870213860451 && val == nameof(VK_EXT_shader_subgroup_ballot)) output = VK_EXT_shader_subgroup_ballot; + if (hash == 3413966920990677283 && val == nameof(VK_EXT_shader_subgroup_vote)) output = VK_EXT_shader_subgroup_vote; + if (hash == 6934890326685763158 && val == nameof(VK_EXT_texture_compression_astc_hdr)) output = VK_EXT_texture_compression_astc_hdr; + if (hash == -3945297757011971352 && val == nameof(VK_EXT_astc_decode_mode)) output = VK_EXT_astc_decode_mode; + if (hash == -5406396661080782841 && val == nameof(VK_EXT_pipeline_robustness)) output = VK_EXT_pipeline_robustness; + if (hash == 7397034392233796093 && val == nameof(VK_KHR_maintenance1)) output = VK_KHR_maintenance1; + if (hash == 2712619271905777381 && val == nameof(VK_KHR_device_group_creation)) output = VK_KHR_device_group_creation; + if (hash == -8989459815271289332 && val == nameof(VK_KHR_external_memory_capabilities)) output = VK_KHR_external_memory_capabilities; + if (hash == -478389182379051272 && val == nameof(VK_KHR_external_memory)) output = VK_KHR_external_memory; + if (hash == -3977619849403306427 && val == nameof(VK_KHR_external_memory_win32)) output = VK_KHR_external_memory_win32; + if (hash == -4719066452975387077 && val == nameof(VK_KHR_external_memory_fd)) output = VK_KHR_external_memory_fd; + if (hash == 1920366320866941812 && val == nameof(VK_KHR_win32_keyed_mutex)) output = VK_KHR_win32_keyed_mutex; + if (hash == -8147477422563608359 && val == nameof(VK_KHR_external_semaphore_capabilities)) output = VK_KHR_external_semaphore_capabilities; + if (hash == 1521178739625328187 && val == nameof(VK_KHR_external_semaphore)) output = VK_KHR_external_semaphore; + if (hash == -383667588334960517 && val == nameof(VK_KHR_external_semaphore_win32)) output = VK_KHR_external_semaphore_win32; + if (hash == -6214356926297337403 && val == nameof(VK_KHR_external_semaphore_fd)) output = VK_KHR_external_semaphore_fd; + if (hash == -380089219124422343 && val == nameof(VK_KHR_push_descriptor)) output = VK_KHR_push_descriptor; + if (hash == 524555470348169804 && val == nameof(VK_EXT_conditional_rendering)) output = VK_EXT_conditional_rendering; + if (hash == -8945353300522708773 && val == nameof(VK_KHR_shader_float16_int8)) output = VK_KHR_shader_float16_int8; + if (hash == -1780410835384297398 && val == nameof(VK_KHR_16bit_storage)) output = VK_KHR_16bit_storage; + if (hash == -5596745269584889296 && val == nameof(VK_KHR_incremental_present)) output = VK_KHR_incremental_present; + if (hash == 4863542985406679256 && val == nameof(VK_KHR_descriptor_update_template)) output = VK_KHR_descriptor_update_template; + if (hash == 7674416071713817983 && val == nameof(VK_NV_clip_space_w_scaling)) output = VK_NV_clip_space_w_scaling; + if (hash == 4640563150580468013 && val == nameof(VK_EXT_direct_mode_display)) output = VK_EXT_direct_mode_display; + if (hash == -6961556243585555443 && val == nameof(VK_EXT_acquire_xlib_display)) output = VK_EXT_acquire_xlib_display; + if (hash == -6150809638503286426 && val == nameof(VK_EXT_display_surface_counter)) output = VK_EXT_display_surface_counter; + if (hash == 88121258120954585 && val == nameof(VK_EXT_display_control)) output = VK_EXT_display_control; + if (hash == -3436182818571452471 && val == nameof(VK_GOOGLE_display_timing)) output = VK_GOOGLE_display_timing; + if (hash == 4447576469439143961 && val == nameof(VK_NV_sample_mask_override_coverage)) output = VK_NV_sample_mask_override_coverage; + if (hash == 3853193367253399095 && val == nameof(VK_NV_geometry_shader_passthrough)) output = VK_NV_geometry_shader_passthrough; + if (hash == 7480416298054829291 && val == nameof(VK_NV_viewport_array2)) output = VK_NV_viewport_array2; + if (hash == 144495989000881695 && val == nameof(VK_NVX_multiview_per_view_attributes)) output = VK_NVX_multiview_per_view_attributes; + if (hash == -6586768760724981643 && val == nameof(VK_NV_viewport_swizzle)) output = VK_NV_viewport_swizzle; + if (hash == -2582352458755621461 && val == nameof(VK_EXT_discard_rectangles)) output = VK_EXT_discard_rectangles; + if (hash == 4219461531610090122 && val == nameof(VK_EXT_conservative_rasterization)) output = VK_EXT_conservative_rasterization; + if (hash == 6728687667070212951 && val == nameof(VK_EXT_depth_clip_enable)) output = VK_EXT_depth_clip_enable; + if (hash == 937014423961853511 && val == nameof(VK_EXT_swapchain_colorspace)) output = VK_EXT_swapchain_colorspace; + if (hash == 5984086924724244390 && val == nameof(VK_EXT_hdr_metadata)) output = VK_EXT_hdr_metadata; + if (hash == 8321969189838904190 && val == nameof(VK_KHR_imageless_framebuffer)) output = VK_KHR_imageless_framebuffer; + if (hash == 4307213488093655992 && val == nameof(VK_KHR_create_renderpass2)) output = VK_KHR_create_renderpass2; + if (hash == -1782703184223152742 && val == nameof(VK_IMG_relaxed_line_rasterization)) output = VK_IMG_relaxed_line_rasterization; + if (hash == -2119350697942255753 && val == nameof(VK_KHR_shared_presentable_image)) output = VK_KHR_shared_presentable_image; + if (hash == 3251653924213292867 && val == nameof(VK_KHR_external_fence_capabilities)) output = VK_KHR_external_fence_capabilities; + if (hash == -5503431248579125976 && val == nameof(VK_KHR_external_fence)) output = VK_KHR_external_fence; + if (hash == -7262514788746992421 && val == nameof(VK_KHR_external_fence_win32)) output = VK_KHR_external_fence_win32; + if (hash == 6316164263311405637 && val == nameof(VK_KHR_external_fence_fd)) output = VK_KHR_external_fence_fd; + if (hash == -984950501231767955 && val == nameof(VK_KHR_performance_query)) output = VK_KHR_performance_query; + if (hash == 7397034392233797021 && val == nameof(VK_KHR_maintenance2)) output = VK_KHR_maintenance2; + if (hash == -7631169936167794744 && val == nameof(VK_KHR_get_surface_capabilities2)) output = VK_KHR_get_surface_capabilities2; + if (hash == 8936953882201689699 && val == nameof(VK_KHR_variable_pointers)) output = VK_KHR_variable_pointers; + if (hash == 6566221755150483625 && val == nameof(VK_KHR_get_display_properties2)) output = VK_KHR_get_display_properties2; + if (hash == 8105268690119750105 && val == nameof(VK_MVK_ios_surface)) output = VK_MVK_ios_surface; + if (hash == 7896288837060864841 && val == nameof(VK_MVK_macos_surface)) output = VK_MVK_macos_surface; + if (hash == -2284828798706644475 && val == nameof(VK_EXT_external_memory_dma_buf)) output = VK_EXT_external_memory_dma_buf; + if (hash == 2125185268864634320 && val == nameof(VK_EXT_queue_family_foreign)) output = VK_EXT_queue_family_foreign; + if (hash == 3595696390282513823 && val == nameof(VK_KHR_dedicated_allocation)) output = VK_KHR_dedicated_allocation; + if (hash == 6810959356402637386 && val == nameof(VK_EXT_debug_utils)) output = VK_EXT_debug_utils; + if (hash == 7082860073672192210 && val == nameof(VK_ANDROID_external_memory_android_hardware_buffer)) output = VK_ANDROID_external_memory_android_hardware_buffer; + if (hash == 3683831156669654176 && val == nameof(VK_EXT_sampler_filter_minmax)) output = VK_EXT_sampler_filter_minmax; + if (hash == -8548886603791867894 && val == nameof(VK_KHR_storage_buffer_storage_class)) output = VK_KHR_storage_buffer_storage_class; + if (hash == -1069506367109294711 && val == nameof(VK_AMD_gpu_shader_int16)) output = VK_AMD_gpu_shader_int16; + if (hash == -3633573572598472828 && val == nameof(VK_AMDX_shader_enqueue)) output = VK_AMDX_shader_enqueue; + if (hash == -158076680219676979 && val == nameof(VK_AMD_mixed_attachment_samples)) output = VK_AMD_mixed_attachment_samples; + if (hash == 6899469499590155907 && val == nameof(VK_AMD_shader_fragment_mask)) output = VK_AMD_shader_fragment_mask; + if (hash == 6011467066922003706 && val == nameof(VK_EXT_inline_uniform_block)) output = VK_EXT_inline_uniform_block; + if (hash == -2314247111734117706 && val == nameof(VK_EXT_shader_stencil_export)) output = VK_EXT_shader_stencil_export; + if (hash == -4401676936060306677 && val == nameof(VK_KHR_shader_bfloat16)) output = VK_KHR_shader_bfloat16; + if (hash == -2024064393235031999 && val == nameof(VK_EXT_sample_locations)) output = VK_EXT_sample_locations; + if (hash == 8700689063293221873 && val == nameof(VK_KHR_relaxed_block_layout)) output = VK_KHR_relaxed_block_layout; + if (hash == -7776608367774482671 && val == nameof(VK_KHR_get_memory_requirements2)) output = VK_KHR_get_memory_requirements2; + if (hash == 6845445703548285883 && val == nameof(VK_KHR_image_format_list)) output = VK_KHR_image_format_list; + if (hash == 3636534966476379509 && val == nameof(VK_EXT_blend_operation_advanced)) output = VK_EXT_blend_operation_advanced; + if (hash == 865652869065638483 && val == nameof(VK_NV_fragment_coverage_to_color)) output = VK_NV_fragment_coverage_to_color; + if (hash == 2779617857641756911 && val == nameof(VK_KHR_acceleration_structure)) output = VK_KHR_acceleration_structure; + if (hash == 3390735615806375619 && val == nameof(VK_KHR_ray_tracing_pipeline)) output = VK_KHR_ray_tracing_pipeline; + if (hash == 4637894854775601043 && val == nameof(VK_KHR_ray_query)) output = VK_KHR_ray_query; + if (hash == 6164139310721479667 && val == nameof(VK_NV_framebuffer_mixed_samples)) output = VK_NV_framebuffer_mixed_samples; + if (hash == -85027228455294816 && val == nameof(VK_NV_fill_rectangle)) output = VK_NV_fill_rectangle; + if (hash == 4936202092474946069 && val == nameof(VK_NV_shader_sm_builtins)) output = VK_NV_shader_sm_builtins; + if (hash == -1327165992065664287 && val == nameof(VK_EXT_post_depth_coverage)) output = VK_EXT_post_depth_coverage; + if (hash == -3486613581854701674 && val == nameof(VK_KHR_sampler_ycbcr_conversion)) output = VK_KHR_sampler_ycbcr_conversion; + if (hash == -5259040508972499646 && val == nameof(VK_KHR_bind_memory2)) output = VK_KHR_bind_memory2; + if (hash == -6575200467579408405 && val == nameof(VK_EXT_image_drm_format_modifier)) output = VK_EXT_image_drm_format_modifier; + if (hash == -8948844113836147904 && val == nameof(VK_EXT_validation_cache)) output = VK_EXT_validation_cache; + if (hash == 8561248525047136929 && val == nameof(VK_EXT_descriptor_indexing)) output = VK_EXT_descriptor_indexing; + if (hash == 7230591853511506240 && val == nameof(VK_EXT_shader_viewport_index_layer)) output = VK_EXT_shader_viewport_index_layer; + if (hash == 1082183373882752175 && val == nameof(VK_KHR_portability_subset)) output = VK_KHR_portability_subset; + if (hash == 9045431611179474949 && val == nameof(VK_NV_shading_rate_image)) output = VK_NV_shading_rate_image; + if (hash == -8697104648214943725 && val == nameof(VK_NV_ray_tracing)) output = VK_NV_ray_tracing; + if (hash == 5740524694847516511 && val == nameof(VK_NV_representative_fragment_test)) output = VK_NV_representative_fragment_test; + if (hash == 7397034392233798077 && val == nameof(VK_KHR_maintenance3)) output = VK_KHR_maintenance3; + if (hash == 863000665587981407 && val == nameof(VK_KHR_draw_indirect_count)) output = VK_KHR_draw_indirect_count; + if (hash == 2352382946299142496 && val == nameof(VK_EXT_filter_cubic)) output = VK_EXT_filter_cubic; + if (hash == -4511794674190895226 && val == nameof(VK_QCOM_render_pass_shader_resolve)) output = VK_QCOM_render_pass_shader_resolve; + if (hash == 2301685051738722173 && val == nameof(VK_EXT_global_priority)) output = VK_EXT_global_priority; + if (hash == -2054182168941826768 && val == nameof(VK_KHR_shader_subgroup_extended_types)) output = VK_KHR_shader_subgroup_extended_types; + if (hash == -3554017955007271363 && val == nameof(VK_KHR_8bit_storage)) output = VK_KHR_8bit_storage; + if (hash == 7157140288582377243 && val == nameof(VK_EXT_external_memory_host)) output = VK_EXT_external_memory_host; + if (hash == -6403990713898771290 && val == nameof(VK_AMD_buffer_marker)) output = VK_AMD_buffer_marker; + if (hash == 5509599468790916183 && val == nameof(VK_KHR_shader_atomic_int64)) output = VK_KHR_shader_atomic_int64; + if (hash == 1214748047289636085 && val == nameof(VK_KHR_shader_clock)) output = VK_KHR_shader_clock; + if (hash == 9000250237621837417 && val == nameof(VK_AMD_pipeline_compiler_control)) output = VK_AMD_pipeline_compiler_control; + if (hash == -9023207658382243393 && val == nameof(VK_EXT_calibrated_timestamps)) output = VK_EXT_calibrated_timestamps; + if (hash == -2019025287368079007 && val == nameof(VK_AMD_shader_core_properties)) output = VK_AMD_shader_core_properties; + if (hash == -8040821862430192124 && val == nameof(VK_KHR_video_decode_h265)) output = VK_KHR_video_decode_h265; + if (hash == 873840902648270717 && val == nameof(VK_KHR_global_priority)) output = VK_KHR_global_priority; + if (hash == -7703117780159856609 && val == nameof(VK_AMD_memory_overallocation_behavior)) output = VK_AMD_memory_overallocation_behavior; + if (hash == 4850273223779667146 && val == nameof(VK_EXT_vertex_attribute_divisor)) output = VK_EXT_vertex_attribute_divisor; + if (hash == -6284328737898736533 && val == nameof(VK_GGP_frame_token)) output = VK_GGP_frame_token; + if (hash == 6600169170751072214 && val == nameof(VK_EXT_pipeline_creation_feedback)) output = VK_EXT_pipeline_creation_feedback; + if (hash == -2709601474235956180 && val == nameof(VK_KHR_driver_properties)) output = VK_KHR_driver_properties; + if (hash == -3173813599752481061 && val == nameof(VK_KHR_shader_float_controls)) output = VK_KHR_shader_float_controls; + if (hash == -8705435623437116188 && val == nameof(VK_NV_shader_subgroup_partitioned)) output = VK_NV_shader_subgroup_partitioned; + if (hash == -4378728241089500973 && val == nameof(VK_KHR_depth_stencil_resolve)) output = VK_KHR_depth_stencil_resolve; + if (hash == -3353909209589787735 && val == nameof(VK_KHR_swapchain_mutable_format)) output = VK_KHR_swapchain_mutable_format; + if (hash == -8592873529910230946 && val == nameof(VK_NV_compute_shader_derivatives)) output = VK_NV_compute_shader_derivatives; + if (hash == -3860844217721160164 && val == nameof(VK_NV_mesh_shader)) output = VK_NV_mesh_shader; + if (hash == 2063146423492821645 && val == nameof(VK_NV_fragment_shader_barycentric)) output = VK_NV_fragment_shader_barycentric; + if (hash == 5019480563627191621 && val == nameof(VK_NV_shader_image_footprint)) output = VK_NV_shader_image_footprint; + if (hash == -190317074440454169 && val == nameof(VK_NV_scissor_exclusive)) output = VK_NV_scissor_exclusive; + if (hash == -3776668533234908128 && val == nameof(VK_NV_device_diagnostic_checkpoints)) output = VK_NV_device_diagnostic_checkpoints; + if (hash == 849221741547986617 && val == nameof(VK_KHR_timeline_semaphore)) output = VK_KHR_timeline_semaphore; + if (hash == -5340998244505753895 && val == nameof(VK_EXT_present_timing)) output = VK_EXT_present_timing; + if (hash == 2227533800516097181 && val == nameof(VK_INTEL_shader_integer_functions2)) output = VK_INTEL_shader_integer_functions2; + if (hash == -8691953096090158586 && val == nameof(VK_INTEL_performance_query)) output = VK_INTEL_performance_query; + if (hash == 3944423158982037263 && val == nameof(VK_KHR_vulkan_memory_model)) output = VK_KHR_vulkan_memory_model; + if (hash == -6199230202903037923 && val == nameof(VK_EXT_pci_bus_info)) output = VK_EXT_pci_bus_info; + if (hash == -621814537319780008 && val == nameof(VK_AMD_display_native_hdr)) output = VK_AMD_display_native_hdr; + if (hash == -5015192502216253005 && val == nameof(VK_FUCHSIA_imagepipe_surface)) output = VK_FUCHSIA_imagepipe_surface; + if (hash == 4258272863858701902 && val == nameof(VK_KHR_shader_terminate_invocation)) output = VK_KHR_shader_terminate_invocation; + if (hash == 508802890343823448 && val == nameof(VK_EXT_metal_surface)) output = VK_EXT_metal_surface; + if (hash == -7249607572735370591 && val == nameof(VK_EXT_fragment_density_map)) output = VK_EXT_fragment_density_map; + if (hash == -3125712347224959271 && val == nameof(VK_EXT_scalar_block_layout)) output = VK_EXT_scalar_block_layout; + if (hash == -8708221564937483930 && val == nameof(VK_GOOGLE_hlsl_functionality1)) output = VK_GOOGLE_hlsl_functionality1; + if (hash == -6155484739610366943 && val == nameof(VK_GOOGLE_decorate_string)) output = VK_GOOGLE_decorate_string; + if (hash == -3589396754944871199 && val == nameof(VK_EXT_subgroup_size_control)) output = VK_EXT_subgroup_size_control; + if (hash == -1262149543259884140 && val == nameof(VK_KHR_fragment_shading_rate)) output = VK_KHR_fragment_shading_rate; + if (hash == -7249551687281802049 && val == nameof(VK_AMD_shader_core_properties2)) output = VK_AMD_shader_core_properties2; + if (hash == 7323264790155701643 && val == nameof(VK_AMD_device_coherent_memory)) output = VK_AMD_device_coherent_memory; + if (hash == -1270282036729192100 && val == nameof(VK_KHR_dynamic_rendering_local_read)) output = VK_KHR_dynamic_rendering_local_read; + if (hash == 5866395964746172773 && val == nameof(VK_EXT_shader_image_atomic_int64)) output = VK_EXT_shader_image_atomic_int64; + if (hash == 6415308449487905376 && val == nameof(VK_KHR_shader_quad_control)) output = VK_KHR_shader_quad_control; + if (hash == 4340414475841315459 && val == nameof(VK_KHR_spirv_1_4)) output = VK_KHR_spirv_1_4; + if (hash == -4255974680083515233 && val == nameof(VK_EXT_memory_budget)) output = VK_EXT_memory_budget; + if (hash == -7143771079712723969 && val == nameof(VK_EXT_memory_priority)) output = VK_EXT_memory_priority; + if (hash == -5174237927520671737 && val == nameof(VK_KHR_surface_protected_capabilities)) output = VK_KHR_surface_protected_capabilities; + if (hash == -36744817902709753 && val == nameof(VK_NV_dedicated_allocation_image_aliasing)) output = VK_NV_dedicated_allocation_image_aliasing; + if (hash == 1246561815014692838 && val == nameof(VK_KHR_separate_depth_stencil_layouts)) output = VK_KHR_separate_depth_stencil_layouts; + if (hash == -1034295384958544799 && val == nameof(VK_EXT_buffer_device_address)) output = VK_EXT_buffer_device_address; + if (hash == -5494099154812182557 && val == nameof(VK_EXT_tooling_info)) output = VK_EXT_tooling_info; + if (hash == 812355419167009188 && val == nameof(VK_EXT_separate_stencil_usage)) output = VK_EXT_separate_stencil_usage; + if (hash == -8580021588778121249 && val == nameof(VK_EXT_validation_features)) output = VK_EXT_validation_features; + if (hash == 8530488028046031449 && val == nameof(VK_KHR_present_wait)) output = VK_KHR_present_wait; + if (hash == 135534643381237079 && val == nameof(VK_NV_cooperative_matrix)) output = VK_NV_cooperative_matrix; + if (hash == -1303970333515308712 && val == nameof(VK_NV_coverage_reduction_mode)) output = VK_NV_coverage_reduction_mode; + if (hash == -4510798554448056036 && val == nameof(VK_EXT_fragment_shader_interlock)) output = VK_EXT_fragment_shader_interlock; + if (hash == -5081964843126271661 && val == nameof(VK_EXT_ycbcr_image_arrays)) output = VK_EXT_ycbcr_image_arrays; + if (hash == 4936869326909847446 && val == nameof(VK_KHR_uniform_buffer_standard_layout)) output = VK_KHR_uniform_buffer_standard_layout; + if (hash == -7722169894774954173 && val == nameof(VK_EXT_provoking_vertex)) output = VK_EXT_provoking_vertex; + if (hash == 3239137762033818382 && val == nameof(VK_EXT_full_screen_exclusive)) output = VK_EXT_full_screen_exclusive; + if (hash == 644671639182466229 && val == nameof(VK_EXT_headless_surface)) output = VK_EXT_headless_surface; + if (hash == 7161673897895023713 && val == nameof(VK_KHR_buffer_device_address)) output = VK_KHR_buffer_device_address; + if (hash == -8176342995933861766 && val == nameof(VK_EXT_line_rasterization)) output = VK_EXT_line_rasterization; + if (hash == -8240586451231204265 && val == nameof(VK_EXT_shader_atomic_float)) output = VK_EXT_shader_atomic_float; + if (hash == -2791448292902836825 && val == nameof(VK_EXT_host_query_reset)) output = VK_EXT_host_query_reset; + if (hash == 2750160548758591672 && val == nameof(VK_EXT_index_type_uint8)) output = VK_EXT_index_type_uint8; + if (hash == 3562397314877100055 && val == nameof(VK_EXT_extended_dynamic_state)) output = VK_EXT_extended_dynamic_state; + if (hash == -7983970780198928539 && val == nameof(VK_KHR_deferred_host_operations)) output = VK_KHR_deferred_host_operations; + if (hash == 8843447117816409691 && val == nameof(VK_KHR_pipeline_executable_properties)) output = VK_KHR_pipeline_executable_properties; + if (hash == -1185320362234232263 && val == nameof(VK_EXT_host_image_copy)) output = VK_EXT_host_image_copy; + if (hash == -8063361519565945988 && val == nameof(VK_KHR_map_memory2)) output = VK_KHR_map_memory2; + if (hash == 4448230886955176535 && val == nameof(VK_EXT_map_memory_placed)) output = VK_EXT_map_memory_placed; + if (hash == 2796237043766416393 && val == nameof(VK_EXT_shader_atomic_float2)) output = VK_EXT_shader_atomic_float2; + if (hash == 288202615903612511 && val == nameof(VK_EXT_surface_maintenance1)) output = VK_EXT_surface_maintenance1; + if (hash == 2276390439831334953 && val == nameof(VK_EXT_swapchain_maintenance1)) output = VK_EXT_swapchain_maintenance1; + if (hash == 111031315709560170 && val == nameof(VK_EXT_shader_demote_to_helper_invocation)) output = VK_EXT_shader_demote_to_helper_invocation; + if (hash == -8281571846360529098 && val == nameof(VK_NV_device_generated_commands)) output = VK_NV_device_generated_commands; + if (hash == 5857666041340197897 && val == nameof(VK_NV_inherited_viewport_scissor)) output = VK_NV_inherited_viewport_scissor; + if (hash == -4404953393644474637 && val == nameof(VK_KHR_shader_integer_dot_product)) output = VK_KHR_shader_integer_dot_product; + if (hash == 2947963909389619539 && val == nameof(VK_EXT_texel_buffer_alignment)) output = VK_EXT_texel_buffer_alignment; + if (hash == -3353573879317030777 && val == nameof(VK_QCOM_render_pass_transform)) output = VK_QCOM_render_pass_transform; + if (hash == 285956609351128681 && val == nameof(VK_EXT_depth_bias_control)) output = VK_EXT_depth_bias_control; + if (hash == -2873878547147488731 && val == nameof(VK_EXT_device_memory_report)) output = VK_EXT_device_memory_report; + if (hash == 8894184657131810871 && val == nameof(VK_EXT_acquire_drm_display)) output = VK_EXT_acquire_drm_display; + if (hash == -371621618341144982 && val == nameof(VK_EXT_robustness2)) output = VK_EXT_robustness2; + if (hash == 4218623945528478136 && val == nameof(VK_EXT_custom_border_color)) output = VK_EXT_custom_border_color; + if (hash == 5842360377196399603 && val == nameof(VK_GOOGLE_user_type)) output = VK_GOOGLE_user_type; + if (hash == 3789045476079700516 && val == nameof(VK_KHR_pipeline_library)) output = VK_KHR_pipeline_library; + if (hash == -1031277045087784729 && val == nameof(VK_NV_present_barrier)) output = VK_NV_present_barrier; + if (hash == -8894853490292274213 && val == nameof(VK_KHR_shader_non_semantic_info)) output = VK_KHR_shader_non_semantic_info; + if (hash == 5067314742106083897 && val == nameof(VK_KHR_present_id)) output = VK_KHR_present_id; + if (hash == -5175454889211749859 && val == nameof(VK_EXT_private_data)) output = VK_EXT_private_data; + if (hash == 1625339351198816711 && val == nameof(VK_EXT_pipeline_creation_cache_control)) output = VK_EXT_pipeline_creation_cache_control; + if (hash == -7828649902404896868 && val == nameof(VK_KHR_video_encode_queue)) output = VK_KHR_video_encode_queue; + if (hash == -8081677801026634886 && val == nameof(VK_NV_device_diagnostics_config)) output = VK_NV_device_diagnostics_config; + if (hash == 6543751180799926247 && val == nameof(VK_QCOM_render_pass_store_ops)) output = VK_QCOM_render_pass_store_ops; + if (hash == -6159127713552577627 && val == nameof(VK_NV_cuda_kernel_launch)) output = VK_NV_cuda_kernel_launch; + if (hash == 90012012998708131 && val == nameof(VK_QCOM_tile_shading)) output = VK_QCOM_tile_shading; + if (hash == 5292820458818756627 && val == nameof(VK_NV_low_latency)) output = VK_NV_low_latency; + if (hash == 1404892823891502200 && val == nameof(VK_EXT_metal_objects)) output = VK_EXT_metal_objects; + if (hash == 5057363678608298434 && val == nameof(VK_KHR_synchronization2)) output = VK_KHR_synchronization2; + if (hash == -8656322690041345119 && val == nameof(VK_EXT_descriptor_buffer)) output = VK_EXT_descriptor_buffer; + if (hash == 3465012858628115880 && val == nameof(VK_EXT_graphics_pipeline_library)) output = VK_EXT_graphics_pipeline_library; + if (hash == 8590893045668089057 && val == nameof(VK_AMD_shader_early_and_late_fragment_tests)) output = VK_AMD_shader_early_and_late_fragment_tests; + if (hash == 6228075860377206754 && val == nameof(VK_KHR_fragment_shader_barycentric)) output = VK_KHR_fragment_shader_barycentric; + if (hash == -7029158166133966870 && val == nameof(VK_KHR_shader_subgroup_uniform_control_flow)) output = VK_KHR_shader_subgroup_uniform_control_flow; + if (hash == -2217403110860242470 && val == nameof(VK_KHR_zero_initialize_workgroup_memory)) output = VK_KHR_zero_initialize_workgroup_memory; + if (hash == -6709923699988431760 && val == nameof(VK_NV_fragment_shading_rate_enums)) output = VK_NV_fragment_shading_rate_enums; + if (hash == -1762061983620049897 && val == nameof(VK_NV_ray_tracing_motion_blur)) output = VK_NV_ray_tracing_motion_blur; + if (hash == -3993661939284595463 && val == nameof(VK_EXT_mesh_shader)) output = VK_EXT_mesh_shader; + if (hash == 1355926743671174014 && val == nameof(VK_EXT_ycbcr_2plane_444_formats)) output = VK_EXT_ycbcr_2plane_444_formats; + if (hash == -3376905870281876609 && val == nameof(VK_EXT_fragment_density_map2)) output = VK_EXT_fragment_density_map2; + if (hash == 2154629824031805479 && val == nameof(VK_QCOM_rotated_copy_commands)) output = VK_QCOM_rotated_copy_commands; + if (hash == -1479224457313365899 && val == nameof(VK_EXT_image_robustness)) output = VK_EXT_image_robustness; + if (hash == 3974698264970347332 && val == nameof(VK_KHR_workgroup_memory_explicit_layout)) output = VK_KHR_workgroup_memory_explicit_layout; + if (hash == 3952721174134823524 && val == nameof(VK_KHR_copy_commands2)) output = VK_KHR_copy_commands2; + if (hash == 4555054662443405735 && val == nameof(VK_EXT_image_compression_control)) output = VK_EXT_image_compression_control; + if (hash == 5717066104911471457 && val == nameof(VK_EXT_attachment_feedback_loop_layout)) output = VK_EXT_attachment_feedback_loop_layout; + if (hash == 1211580721816759144 && val == nameof(VK_EXT_4444_formats)) output = VK_EXT_4444_formats; + if (hash == 7204705677322460618 && val == nameof(VK_EXT_device_fault)) output = VK_EXT_device_fault; + if (hash == -6235005026077182939 && val == nameof(VK_ARM_rasterization_order_attachment_access)) output = VK_ARM_rasterization_order_attachment_access; + if (hash == 8334581359801943062 && val == nameof(VK_EXT_rgba10x6_formats)) output = VK_EXT_rgba10x6_formats; + if (hash == -8605568526641033402 && val == nameof(VK_NV_acquire_winrt_display)) output = VK_NV_acquire_winrt_display; + if (hash == 8248584485722639750 && val == nameof(VK_EXT_directfb_surface)) output = VK_EXT_directfb_surface; + if (hash == -4657509754951235841 && val == nameof(VK_VALVE_mutable_descriptor_type)) output = VK_VALVE_mutable_descriptor_type; + if (hash == 5399769016321456805 && val == nameof(VK_EXT_vertex_input_dynamic_state)) output = VK_EXT_vertex_input_dynamic_state; + if (hash == 2017441179466893599 && val == nameof(VK_EXT_physical_device_drm)) output = VK_EXT_physical_device_drm; + if (hash == -8369234652251435052 && val == nameof(VK_EXT_device_address_binding_report)) output = VK_EXT_device_address_binding_report; + if (hash == -5551539686972025239 && val == nameof(VK_EXT_depth_clip_control)) output = VK_EXT_depth_clip_control; + if (hash == -8662634279206901921 && val == nameof(VK_EXT_primitive_topology_list_restart)) output = VK_EXT_primitive_topology_list_restart; + if (hash == -8422251281863311940 && val == nameof(VK_KHR_format_feature_flags2)) output = VK_KHR_format_feature_flags2; + if (hash == -1130188893211256892 && val == nameof(VK_EXT_present_mode_fifo_latest_ready)) output = VK_EXT_present_mode_fifo_latest_ready; + if (hash == 6124023774039709115 && val == nameof(VK_FUCHSIA_external_memory)) output = VK_FUCHSIA_external_memory; + if (hash == -559483212380197883 && val == nameof(VK_FUCHSIA_external_semaphore)) output = VK_FUCHSIA_external_semaphore; + if (hash == 5541180619187636101 && val == nameof(VK_FUCHSIA_buffer_collection)) output = VK_FUCHSIA_buffer_collection; + if (hash == -5531934526269389001 && val == nameof(VK_HUAWEI_subpass_shading)) output = VK_HUAWEI_subpass_shading; + if (hash == 4337908299782082981 && val == nameof(VK_HUAWEI_invocation_mask)) output = VK_HUAWEI_invocation_mask; + if (hash == 8672563436890019247 && val == nameof(VK_NV_external_memory_rdma)) output = VK_NV_external_memory_rdma; + if (hash == 1172956471266660418 && val == nameof(VK_EXT_pipeline_properties)) output = VK_EXT_pipeline_properties; + if (hash == -6548854686930314315 && val == nameof(VK_EXT_frame_boundary)) output = VK_EXT_frame_boundary; + if (hash == -7137781907661278765 && val == nameof(VK_EXT_multisampled_render_to_single_sampled)) output = VK_EXT_multisampled_render_to_single_sampled; + if (hash == -246147681067182007 && val == nameof(VK_EXT_extended_dynamic_state2)) output = VK_EXT_extended_dynamic_state2; + if (hash == -5349833932606625242 && val == nameof(VK_QNX_screen_surface)) output = VK_QNX_screen_surface; + if (hash == -3367107940876467685 && val == nameof(VK_EXT_color_write_enable)) output = VK_EXT_color_write_enable; + if (hash == -8384192069871844031 && val == nameof(VK_EXT_primitives_generated_query)) output = VK_EXT_primitives_generated_query; + if (hash == 1507005061001015907 && val == nameof(VK_KHR_ray_tracing_maintenance1)) output = VK_KHR_ray_tracing_maintenance1; + if (hash == 6296717572389690595 && val == nameof(VK_KHR_shader_untyped_pointers)) output = VK_KHR_shader_untyped_pointers; + if (hash == -3396937125487864903 && val == nameof(VK_EXT_global_priority_query)) output = VK_EXT_global_priority_query; + if (hash == -5109063015636583075 && val == nameof(VK_VALVE_video_encode_rgb_conversion)) output = VK_VALVE_video_encode_rgb_conversion; + if (hash == 5538699612739942107 && val == nameof(VK_EXT_image_view_min_lod)) output = VK_EXT_image_view_min_lod; + if (hash == -1692126360074390368 && val == nameof(VK_EXT_multi_draw)) output = VK_EXT_multi_draw; + if (hash == -3428938822065141677 && val == nameof(VK_EXT_image_2d_view_of_3d)) output = VK_EXT_image_2d_view_of_3d; + if (hash == 9059976316562683281 && val == nameof(VK_KHR_portability_enumeration)) output = VK_KHR_portability_enumeration; + if (hash == 1337800759425620671 && val == nameof(VK_EXT_shader_tile_image)) output = VK_EXT_shader_tile_image; + if (hash == -58309685799660811 && val == nameof(VK_EXT_opacity_micromap)) output = VK_EXT_opacity_micromap; + if (hash == -8069735361719369148 && val == nameof(VK_NV_displacement_micromap)) output = VK_NV_displacement_micromap; + if (hash == -7059982757930694949 && val == nameof(VK_EXT_load_store_op_none)) output = VK_EXT_load_store_op_none; + if (hash == 664007766890545153 && val == nameof(VK_HUAWEI_cluster_culling_shader)) output = VK_HUAWEI_cluster_culling_shader; + if (hash == -4718644126875636035 && val == nameof(VK_EXT_border_color_swizzle)) output = VK_EXT_border_color_swizzle; + if (hash == -779636798839624425 && val == nameof(VK_EXT_pageable_device_local_memory)) output = VK_EXT_pageable_device_local_memory; + if (hash == 7397034392233791069 && val == nameof(VK_KHR_maintenance4)) output = VK_KHR_maintenance4; + if (hash == -6911417675828360863 && val == nameof(VK_ARM_shader_core_properties)) output = VK_ARM_shader_core_properties; + if (hash == 3285132549848155651 && val == nameof(VK_KHR_shader_subgroup_rotate)) output = VK_KHR_shader_subgroup_rotate; + if (hash == 294056207280187687 && val == nameof(VK_ARM_scheduling_controls)) output = VK_ARM_scheduling_controls; + if (hash == 5059264394703175295 && val == nameof(VK_EXT_image_sliced_view_of_3d)) output = VK_EXT_image_sliced_view_of_3d; + if (hash == -2651594835157364195 && val == nameof(VK_VALVE_descriptor_set_host_mapping)) output = VK_VALVE_descriptor_set_host_mapping; + if (hash == 8798484570383019200 && val == nameof(VK_EXT_depth_clamp_zero_one)) output = VK_EXT_depth_clamp_zero_one; + if (hash == -2146308134125601721 && val == nameof(VK_EXT_non_seamless_cube_map)) output = VK_EXT_non_seamless_cube_map; + if (hash == 7572938400964574983 && val == nameof(VK_ARM_render_pass_striped)) output = VK_ARM_render_pass_striped; + if (hash == -269683006876630885 && val == nameof(VK_QCOM_fragment_density_map_offset)) output = VK_QCOM_fragment_density_map_offset; + if (hash == 8382488352926632789 && val == nameof(VK_NV_copy_memory_indirect)) output = VK_NV_copy_memory_indirect; + if (hash == 5318744821072417207 && val == nameof(VK_NV_memory_decompression)) output = VK_NV_memory_decompression; + if (hash == 6995903851627039707 && val == nameof(VK_NV_device_generated_commands_compute)) output = VK_NV_device_generated_commands_compute; + if (hash == 7023565248244600997 && val == nameof(VK_NV_ray_tracing_linear_swept_spheres)) output = VK_NV_ray_tracing_linear_swept_spheres; + if (hash == -1073694421824496986 && val == nameof(VK_NV_linear_color_attachment)) output = VK_NV_linear_color_attachment; + if (hash == 853935984852001448 && val == nameof(VK_GOOGLE_surfaceless_query)) output = VK_GOOGLE_surfaceless_query; + if (hash == 5166779901405192667 && val == nameof(VK_KHR_shader_maximal_reconvergence)) output = VK_KHR_shader_maximal_reconvergence; + if (hash == -3951953007889459303 && val == nameof(VK_EXT_image_compression_control_swapchain)) output = VK_EXT_image_compression_control_swapchain; + if (hash == -2163413524616214775 && val == nameof(VK_QCOM_image_processing)) output = VK_QCOM_image_processing; + if (hash == 5476129642090324879 && val == nameof(VK_EXT_nested_command_buffer)) output = VK_EXT_nested_command_buffer; + if (hash == 5435452641035975148 && val == nameof(VK_OHOS_external_memory)) output = VK_OHOS_external_memory; + if (hash == 8888249359545092057 && val == nameof(VK_EXT_external_memory_acquire_unmodified)) output = VK_EXT_external_memory_acquire_unmodified; + if (hash == -246147681067180951 && val == nameof(VK_EXT_extended_dynamic_state3)) output = VK_EXT_extended_dynamic_state3; + if (hash == -2132641384727468470 && val == nameof(VK_EXT_subpass_merge_feedback)) output = VK_EXT_subpass_merge_feedback; + if (hash == 6086140788221933952 && val == nameof(VK_LUNARG_direct_driver_loading)) output = VK_LUNARG_direct_driver_loading; + if (hash == 3630066011088766543 && val == nameof(VK_ARM_tensors)) output = VK_ARM_tensors; + if (hash == 2758894452214535249 && val == nameof(VK_EXT_shader_module_identifier)) output = VK_EXT_shader_module_identifier; + if (hash == 8728444293978846245 && val == nameof(VK_EXT_rasterization_order_attachment_access)) output = VK_EXT_rasterization_order_attachment_access; + if (hash == 4910079623848005507 && val == nameof(VK_NV_optical_flow)) output = VK_NV_optical_flow; + if (hash == 6075321756970995803 && val == nameof(VK_EXT_legacy_dithering)) output = VK_EXT_legacy_dithering; + if (hash == -1007676432764946301 && val == nameof(VK_EXT_pipeline_protected_access)) output = VK_EXT_pipeline_protected_access; + if (hash == -7005307792126661112 && val == nameof(VK_ANDROID_external_format_resolve)) output = VK_ANDROID_external_format_resolve; + if (hash == 7397034392233792125 && val == nameof(VK_KHR_maintenance5)) output = VK_KHR_maintenance5; + if (hash == 7420110226813773873 && val == nameof(VK_AMD_anti_lag)) output = VK_AMD_anti_lag; + if (hash == -2239206808699882607 && val == nameof(VK_AMDX_dense_geometry_format)) output = VK_AMDX_dense_geometry_format; + if (hash == -8933939658097356057 && val == nameof(VK_KHR_present_id2)) output = VK_KHR_present_id2; + if (hash == 6190711837493257927 && val == nameof(VK_KHR_present_wait2)) output = VK_KHR_present_wait2; + if (hash == -6387135885359384217 && val == nameof(VK_KHR_ray_tracing_position_fetch)) output = VK_KHR_ray_tracing_position_fetch; + if (hash == -4873837500881220309 && val == nameof(VK_EXT_shader_object)) output = VK_EXT_shader_object; + if (hash == -4466214359704944548 && val == nameof(VK_KHR_pipeline_binary)) output = VK_KHR_pipeline_binary; + if (hash == 2306343823861779197 && val == nameof(VK_QCOM_tile_properties)) output = VK_QCOM_tile_properties; + if (hash == -480254238177026173 && val == nameof(VK_SEC_amigo_profiling)) output = VK_SEC_amigo_profiling; + if (hash == -3718029045386580385 && val == nameof(VK_KHR_surface_maintenance1)) output = VK_KHR_surface_maintenance1; + if (hash == 5299026789264125993 && val == nameof(VK_KHR_swapchain_maintenance1)) output = VK_KHR_swapchain_maintenance1; + if (hash == 2103759385992052561 && val == nameof(VK_QCOM_multiview_per_view_viewports)) output = VK_QCOM_multiview_per_view_viewports; + if (hash == 4717418707697446027 && val == nameof(VK_NV_ray_tracing_invocation_reorder)) output = VK_NV_ray_tracing_invocation_reorder; + if (hash == 137216921555394647 && val == nameof(VK_NV_cooperative_vector)) output = VK_NV_cooperative_vector; + if (hash == -912595799130901610 && val == nameof(VK_NV_extended_sparse_address_space)) output = VK_NV_extended_sparse_address_space; + if (hash == 356535378043995891 && val == nameof(VK_EXT_mutable_descriptor_type)) output = VK_EXT_mutable_descriptor_type; + if (hash == 7529854350310301968 && val == nameof(VK_EXT_legacy_vertex_attributes)) output = VK_EXT_legacy_vertex_attributes; + if (hash == 2317258614414291789 && val == nameof(VK_EXT_layer_settings)) output = VK_EXT_layer_settings; + if (hash == -7633990929006658591 && val == nameof(VK_ARM_shader_core_builtins)) output = VK_ARM_shader_core_builtins; + if (hash == 5526188419789247226 && val == nameof(VK_EXT_pipeline_library_group_handles)) output = VK_EXT_pipeline_library_group_handles; + if (hash == 361979727674338416 && val == nameof(VK_EXT_dynamic_rendering_unused_attachments)) output = VK_EXT_dynamic_rendering_unused_attachments; + if (hash == -1943262440004483123 && val == nameof(VK_NV_low_latency2)) output = VK_NV_low_latency2; + if (hash == 7744223364342125281 && val == nameof(VK_KHR_cooperative_matrix)) output = VK_KHR_cooperative_matrix; + if (hash == 20055718926581896 && val == nameof(VK_ARM_data_graph)) output = VK_ARM_data_graph; + if (hash == 646680708331867343 && val == nameof(VK_QCOM_multiview_per_view_render_areas)) output = VK_QCOM_multiview_per_view_render_areas; + if (hash == -4094642076587080819 && val == nameof(VK_KHR_compute_shader_derivatives)) output = VK_KHR_compute_shader_derivatives; + if (hash == -7150199554805346600 && val == nameof(VK_KHR_video_decode_av1)) output = VK_KHR_video_decode_av1; + if (hash == 6709887924905430744 && val == nameof(VK_KHR_video_encode_av1)) output = VK_KHR_video_encode_av1; + if (hash == -7150199554810186632 && val == nameof(VK_KHR_video_decode_vp9)) output = VK_KHR_video_decode_vp9; + if (hash == 6439659461651036556 && val == nameof(VK_KHR_video_maintenance1)) output = VK_KHR_video_maintenance1; + if (hash == -6278298053854112417 && val == nameof(VK_NV_per_stage_descriptor_set)) output = VK_NV_per_stage_descriptor_set; + if (hash == -556659966095172361 && val == nameof(VK_QCOM_image_processing2)) output = VK_QCOM_image_processing2; + if (hash == 4154599735511440602 && val == nameof(VK_QCOM_filter_cubic_weights)) output = VK_QCOM_filter_cubic_weights; + if (hash == 877986220828222711 && val == nameof(VK_QCOM_ycbcr_degamma)) output = VK_QCOM_ycbcr_degamma; + if (hash == -3043682729054528326 && val == nameof(VK_QCOM_filter_cubic_clamp)) output = VK_QCOM_filter_cubic_clamp; + if (hash == 6166950314275876725 && val == nameof(VK_EXT_attachment_feedback_loop_dynamic_state)) output = VK_EXT_attachment_feedback_loop_dynamic_state; + if (hash == -1506763765709157174 && val == nameof(VK_KHR_vertex_attribute_divisor)) output = VK_KHR_vertex_attribute_divisor; + if (hash == 3186315116789925595 && val == nameof(VK_KHR_load_store_op_none)) output = VK_KHR_load_store_op_none; + if (hash == -8555900740827200773 && val == nameof(VK_KHR_unified_image_layouts)) output = VK_KHR_unified_image_layouts; + if (hash == -6154501223779145211 && val == nameof(VK_KHR_shader_float_controls2)) output = VK_KHR_shader_float_controls2; + if (hash == 3627842962371455894 && val == nameof(VK_QNX_external_memory_screen_buffer)) output = VK_QNX_external_memory_screen_buffer; + if (hash == -8899854035280560981 && val == nameof(VK_MSFT_layered_driver)) output = VK_MSFT_layered_driver; + if (hash == 3227816790908508344 && val == nameof(VK_KHR_index_type_uint8)) output = VK_KHR_index_type_uint8; + if (hash == -5730284439844689798 && val == nameof(VK_KHR_line_rasterization)) output = VK_KHR_line_rasterization; + if (hash == 8504111020181735871 && val == nameof(VK_KHR_calibrated_timestamps)) output = VK_KHR_calibrated_timestamps; + if (hash == 900327791568599489 && val == nameof(VK_KHR_shader_expect_assume)) output = VK_KHR_shader_expect_assume; + if (hash == 7397034392233793053 && val == nameof(VK_KHR_maintenance6)) output = VK_KHR_maintenance6; + if (hash == -7582437673460165598 && val == nameof(VK_NV_descriptor_pool_overallocation)) output = VK_NV_descriptor_pool_overallocation; + if (hash == 1649754821711697962 && val == nameof(VK_QCOM_tile_memory_heap)) output = VK_QCOM_tile_memory_heap; + if (hash == -1517335133448838297 && val == nameof(VK_KHR_copy_memory_indirect)) output = VK_KHR_copy_memory_indirect; + if (hash == -2405128264817949661 && val == nameof(VK_EXT_memory_decompression)) output = VK_EXT_memory_decompression; + if (hash == -351716864829928900 && val == nameof(VK_NV_display_stereo)) output = VK_NV_display_stereo; + if (hash == 9153426085132600601 && val == nameof(VK_KHR_video_encode_intra_refresh)) output = VK_KHR_video_encode_intra_refresh; + if (hash == 2361762476928438169 && val == nameof(VK_KHR_video_encode_quantization_map)) output = VK_KHR_video_encode_quantization_map; + if (hash == -6531882351207403501 && val == nameof(VK_NV_raw_access_chains)) output = VK_NV_raw_access_chains; + if (hash == 2732441648177315439 && val == nameof(VK_NV_external_compute_queue)) output = VK_NV_external_compute_queue; + if (hash == -11065945275147687 && val == nameof(VK_KHR_shader_relaxed_extended_instruction)) output = VK_KHR_shader_relaxed_extended_instruction; + if (hash == -7178473865965110042 && val == nameof(VK_NV_command_buffer_inheritance)) output = VK_NV_command_buffer_inheritance; + if (hash == 7397034392233794109 && val == nameof(VK_KHR_maintenance7)) output = VK_KHR_maintenance7; + if (hash == -5516814426782159069 && val == nameof(VK_NV_shader_atomic_float16_vector)) output = VK_NV_shader_atomic_float16_vector; + if (hash == 4705006180764896957 && val == nameof(VK_EXT_shader_replicated_composites)) output = VK_EXT_shader_replicated_composites; + if (hash == 5166226484313529483 && val == nameof(VK_EXT_shader_float8)) output = VK_EXT_shader_float8; + if (hash == 6295308729950071721 && val == nameof(VK_NV_ray_tracing_validation)) output = VK_NV_ray_tracing_validation; + if (hash == 3734900582390897358 && val == nameof(VK_NV_cluster_acceleration_structure)) output = VK_NV_cluster_acceleration_structure; + if (hash == -4979945726380808502 && val == nameof(VK_NV_partitioned_acceleration_structure)) output = VK_NV_partitioned_acceleration_structure; + if (hash == 5954639735705995401 && val == nameof(VK_EXT_device_generated_commands)) output = VK_EXT_device_generated_commands; + if (hash == 7397034392233787101 && val == nameof(VK_KHR_maintenance8)) output = VK_KHR_maintenance8; + if (hash == -2439815842068706949 && val == nameof(VK_MESA_image_alignment_control)) output = VK_MESA_image_alignment_control; + if (hash == 7808698000067716021 && val == nameof(VK_KHR_shader_fma)) output = VK_KHR_shader_fma; + if (hash == 696356410872730032 && val == nameof(VK_EXT_ray_tracing_invocation_reorder)) output = VK_EXT_ray_tracing_invocation_reorder; + if (hash == 4043848314290773280 && val == nameof(VK_EXT_depth_clamp_control)) output = VK_EXT_depth_clamp_control; + if (hash == 7397034392233788157 && val == nameof(VK_KHR_maintenance9)) output = VK_KHR_maintenance9; + if (hash == 4205874046475270540 && val == nameof(VK_KHR_video_maintenance2)) output = VK_KHR_video_maintenance2; + if (hash == 1041022262182266737 && val == nameof(VK_OHOS_surface)) output = VK_OHOS_surface; + if (hash == -1049520848282420267 && val == nameof(VK_OHOS_native_buffer)) output = VK_OHOS_native_buffer; + if (hash == 9012737781998821811 && val == nameof(VK_HUAWEI_hdr_vivid)) output = VK_HUAWEI_hdr_vivid; + if (hash == 9173547933435378281 && val == nameof(VK_NV_cooperative_matrix2)) output = VK_NV_cooperative_matrix2; + if (hash == -5768347191248937111 && val == nameof(VK_ARM_pipeline_opacity_micromap)) output = VK_ARM_pipeline_opacity_micromap; + if (hash == 6311900806519878021 && val == nameof(VK_EXT_external_memory_metal)) output = VK_EXT_external_memory_metal; + if (hash == -3815024766069281600 && val == nameof(VK_KHR_depth_clamp_zero_one)) output = VK_KHR_depth_clamp_zero_one; + if (hash == 6244336793198158218 && val == nameof(VK_ARM_performance_counters_by_region)) output = VK_ARM_performance_counters_by_region; + if (hash == 3690261356107744795 && val == nameof(VK_EXT_vertex_attribute_robustness)) output = VK_EXT_vertex_attribute_robustness; + if (hash == 1781819421877633370 && val == nameof(VK_ARM_format_pack)) output = VK_ARM_format_pack; + if (hash == 5539782923875671387 && val == nameof(VK_VALVE_fragment_density_map_layered)) output = VK_VALVE_fragment_density_map_layered; + if (hash == 4669007830387234410 && val == nameof(VK_KHR_robustness2)) output = VK_KHR_robustness2; + if (hash == 6776500990194004441 && val == nameof(VK_NV_present_metering)) output = VK_NV_present_metering; + if (hash == 3642386042148585771 && val == nameof(VK_EXT_fragment_density_map_offset)) output = VK_EXT_fragment_density_map_offset; + if (hash == -662444708518047286 && val == nameof(VK_EXT_zero_initialize_device_memory)) output = VK_EXT_zero_initialize_device_memory; + if (hash == -2165516886160369724 && val == nameof(VK_KHR_present_mode_fifo_latest_ready)) output = VK_KHR_present_mode_fifo_latest_ready; + if (hash == -6138189301841409325 && val == nameof(VK_EXT_shader_64bit_indexing)) output = VK_EXT_shader_64bit_indexing; + if (hash == 2827826481059069031 && val == nameof(VK_EXT_custom_resolve)) output = VK_EXT_custom_resolve; + if (hash == 8108333887721749172 && val == nameof(VK_QCOM_data_graph_model)) output = VK_QCOM_data_graph_model; + if (hash == 7947137274733069155 && val == nameof(VK_KHR_maintenance10)) output = VK_KHR_maintenance10; + if (hash == 4736967454655661190 && val == nameof(VK_SEC_pipeline_cache_incremental_mode)) output = VK_SEC_pipeline_cache_incremental_mode; + if (hash == -5321997516956382466 && val == nameof(VK_EXT_shader_uniform_buffer_unsized_array)) output = VK_EXT_shader_uniform_buffer_unsized_array; + return output; + } + public String Tag { get @@ -2361,363 +2816,3028 @@ enum VulkanExtension } } - public Span Dependencies + public VkStructureType FeatureStruct { get { switch (this) { - case VK_KHR_swapchain: return Self[?](VK_KHR_surface); - case VK_KHR_display: return Self[?](VK_KHR_surface); - case VK_KHR_display_swapchain: return Self[?](VK_KHR_swapchain, VK_KHR_display); - case VK_KHR_xlib_surface: return Self[?](VK_KHR_surface); - case VK_KHR_xcb_surface: return Self[?](VK_KHR_surface); - case VK_KHR_wayland_surface: return Self[?](VK_KHR_surface); - case VK_KHR_android_surface: return Self[?](VK_KHR_surface); - case VK_KHR_win32_surface: return Self[?](VK_KHR_surface); - case VK_EXT_debug_marker: return Self[?](VK_EXT_debug_report); - case VK_KHR_video_queue: return Self[?](VK_KHR_synchronization2); - case VK_KHR_video_decode_queue: return Self[?](VK_KHR_video_queue, VK_KHR_synchronization2); - case VK_EXT_transform_feedback: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_video_encode_h264: return Self[?](VK_KHR_video_encode_queue); - case VK_KHR_video_encode_h265: return Self[?](VK_KHR_video_encode_queue); - case VK_KHR_video_decode_h264: return Self[?](VK_KHR_video_decode_queue); - case VK_AMD_texture_gather_bias_lod: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_dynamic_rendering: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_depth_stencil_resolve); - case VK_GGP_stream_descriptor_surface: return Self[?](VK_KHR_surface); - case VK_NV_corner_sampled_image: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_multiview: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_external_memory: return Self[?](VK_NV_external_memory_capabilities); - case VK_NV_external_memory_win32: return Self[?](VK_NV_external_memory); - case VK_NV_win32_keyed_mutex: return Self[?](VK_NV_external_memory_win32); - case VK_KHR_device_group: return Self[?](VK_KHR_device_group_creation); - case VK_NN_vi_surface: return Self[?](VK_KHR_surface); - case VK_EXT_texture_compression_astc_hdr: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_astc_decode_mode: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_pipeline_robustness: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_external_memory_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_external_memory: return Self[?](VK_KHR_external_memory_capabilities); - case VK_KHR_external_memory_win32: return Self[?](VK_KHR_external_memory); - case VK_KHR_external_memory_fd: return Self[?](VK_KHR_external_memory); - case VK_KHR_win32_keyed_mutex: return Self[?](VK_KHR_external_memory_win32); - case VK_KHR_external_semaphore_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_external_semaphore: return Self[?](VK_KHR_external_semaphore_capabilities); - case VK_KHR_external_semaphore_win32: return Self[?](VK_KHR_external_semaphore); - case VK_KHR_external_semaphore_fd: return Self[?](VK_KHR_external_semaphore); - case VK_KHR_push_descriptor: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_conditional_rendering: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_float16_int8: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_16bit_storage: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); - case VK_KHR_incremental_present: return Self[?](VK_KHR_swapchain); - case VK_EXT_direct_mode_display: return Self[?](VK_KHR_display); - case VK_EXT_acquire_xlib_display: return Self[?](VK_EXT_direct_mode_display); - case VK_EXT_display_surface_counter: return Self[?](VK_KHR_display); - case VK_EXT_display_control: return Self[?](VK_EXT_display_surface_counter, VK_KHR_swapchain); - case VK_GOOGLE_display_timing: return Self[?](VK_KHR_swapchain); - case VK_NVX_multiview_per_view_attributes: return Self[?](VK_KHR_multiview); - case VK_EXT_discard_rectangles: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_conservative_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_depth_clip_enable: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_swapchain_colorspace: return Self[?](VK_KHR_surface); - case VK_EXT_hdr_metadata: return Self[?](VK_KHR_swapchain); - case VK_KHR_imageless_framebuffer: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance2, VK_KHR_image_format_list); - case VK_KHR_create_renderpass2: return Self[?](VK_KHR_multiview, VK_KHR_maintenance2); - case VK_IMG_relaxed_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shared_presentable_image: return Self[?](VK_KHR_swapchain, VK_KHR_get_surface_capabilities2, VK_KHR_get_physical_device_properties2); - case VK_KHR_external_fence_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_external_fence: return Self[?](VK_KHR_external_fence_capabilities); - case VK_KHR_external_fence_win32: return Self[?](VK_KHR_external_fence); - case VK_KHR_external_fence_fd: return Self[?](VK_KHR_external_fence); - case VK_KHR_performance_query: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_get_surface_capabilities2: return Self[?](VK_KHR_surface); - case VK_KHR_variable_pointers: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); - case VK_KHR_get_display_properties2: return Self[?](VK_KHR_display); - case VK_MVK_ios_surface: return Self[?](VK_KHR_surface); - case VK_MVK_macos_surface: return Self[?](VK_KHR_surface); - case VK_EXT_external_memory_dma_buf: return Self[?](VK_KHR_external_memory_fd); - case VK_EXT_queue_family_foreign: return Self[?](VK_KHR_external_memory); - case VK_KHR_dedicated_allocation: return Self[?](VK_KHR_get_memory_requirements2); - case VK_ANDROID_external_memory_android_hardware_buffer: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); - case VK_EXT_sampler_filter_minmax: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_AMDX_shader_enqueue: return Self[?](VK_KHR_synchronization2, VK_KHR_spirv_1_4, VK_EXT_extended_dynamic_state, VK_KHR_maintenance5, VK_KHR_pipeline_library); - case VK_EXT_inline_uniform_block: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance1); - case VK_KHR_shader_bfloat16: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_sample_locations: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_blend_operation_advanced: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_acceleration_structure: return Self[?](VK_EXT_descriptor_indexing, VK_KHR_buffer_device_address, VK_KHR_deferred_host_operations); - case VK_KHR_ray_tracing_pipeline: return Self[?](VK_KHR_spirv_1_4, VK_KHR_acceleration_structure); - case VK_KHR_ray_query: return Self[?](VK_KHR_spirv_1_4, VK_KHR_acceleration_structure); - case VK_KHR_sampler_ycbcr_conversion: return Self[?](VK_KHR_maintenance1, VK_KHR_bind_memory2, VK_KHR_get_memory_requirements2, VK_KHR_get_physical_device_properties2); - case VK_EXT_image_drm_format_modifier: return Self[?](VK_KHR_bind_memory2, VK_KHR_get_physical_device_properties2, VK_KHR_sampler_ycbcr_conversion, VK_KHR_image_format_list); - case VK_EXT_descriptor_indexing: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance3); - case VK_KHR_portability_subset: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_shading_rate_image: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_ray_tracing: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_get_memory_requirements2); - case VK_NV_representative_fragment_test: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_maintenance3: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_8bit_storage: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); - case VK_EXT_external_memory_host: return Self[?](VK_KHR_external_memory); - case VK_KHR_shader_atomic_int64: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_clock: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_calibrated_timestamps: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_AMD_shader_core_properties: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_video_decode_h265: return Self[?](VK_KHR_video_decode_queue); - case VK_KHR_global_priority: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_vertex_attribute_divisor: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_GGP_frame_token: return Self[?](VK_KHR_swapchain, VK_GGP_stream_descriptor_surface); - case VK_KHR_driver_properties: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_float_controls: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_depth_stencil_resolve: return Self[?](VK_KHR_create_renderpass2); - case VK_KHR_swapchain_mutable_format: return Self[?](VK_KHR_swapchain, VK_KHR_maintenance2, VK_KHR_image_format_list); - case VK_NV_compute_shader_derivatives: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_mesh_shader: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_fragment_shader_barycentric: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_shader_image_footprint: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_scissor_exclusive: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_device_diagnostic_checkpoints: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_timeline_semaphore: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_present_timing: return Self[?](VK_KHR_swapchain, VK_KHR_present_id2, VK_KHR_get_surface_capabilities2, VK_KHR_calibrated_timestamps); - case VK_INTEL_shader_integer_functions2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_vulkan_memory_model: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_pci_bus_info: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_AMD_display_native_hdr: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); - case VK_FUCHSIA_imagepipe_surface: return Self[?](VK_KHR_surface); - case VK_KHR_shader_terminate_invocation: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_metal_surface: return Self[?](VK_KHR_surface); - case VK_EXT_fragment_density_map: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_scalar_block_layout: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_fragment_shading_rate: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_create_renderpass2); - case VK_AMD_shader_core_properties2: return Self[?](VK_AMD_shader_core_properties); - case VK_AMD_device_coherent_memory: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_dynamic_rendering_local_read: return Self[?](VK_KHR_dynamic_rendering); - case VK_EXT_shader_image_atomic_int64: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_quad_control: return Self[?](VK_KHR_vulkan_memory_model, VK_KHR_shader_maximal_reconvergence); - case VK_KHR_spirv_1_4: return Self[?](VK_KHR_shader_float_controls); - case VK_EXT_memory_budget: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_memory_priority: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_surface_protected_capabilities: return Self[?](VK_KHR_get_surface_capabilities2); - case VK_NV_dedicated_allocation_image_aliasing: return Self[?](VK_KHR_dedicated_allocation, VK_KHR_get_physical_device_properties2); - case VK_KHR_separate_depth_stencil_layouts: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_create_renderpass2); - case VK_EXT_buffer_device_address: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_present_wait: return Self[?](VK_KHR_swapchain, VK_KHR_present_id); - case VK_NV_cooperative_matrix: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_coverage_reduction_mode: return Self[?](VK_NV_framebuffer_mixed_samples, VK_KHR_get_physical_device_properties2); - case VK_EXT_fragment_shader_interlock: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_ycbcr_image_arrays: return Self[?](VK_KHR_sampler_ycbcr_conversion); - case VK_KHR_uniform_buffer_standard_layout: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_provoking_vertex: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_full_screen_exclusive: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_surface, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); - case VK_EXT_headless_surface: return Self[?](VK_KHR_surface); - case VK_KHR_buffer_device_address: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_device_group); - case VK_EXT_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_atomic_float: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_host_query_reset: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_index_type_uint8: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_extended_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_pipeline_executable_properties: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_host_image_copy: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_copy_commands2, VK_KHR_format_feature_flags2); - case VK_EXT_map_memory_placed: return Self[?](VK_KHR_map_memory2); - case VK_EXT_shader_atomic_float2: return Self[?](VK_EXT_shader_atomic_float); - case VK_EXT_surface_maintenance1: return Self[?](VK_KHR_surface, VK_KHR_get_surface_capabilities2); - case VK_EXT_swapchain_maintenance1: return Self[?](VK_KHR_swapchain, VK_EXT_surface_maintenance1, VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_demote_to_helper_invocation: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_device_generated_commands: return Self[?](VK_KHR_buffer_device_address); - case VK_NV_inherited_viewport_scissor: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_integer_dot_product: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_texel_buffer_alignment: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_depth_bias_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_device_memory_report: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_acquire_drm_display: return Self[?](VK_EXT_direct_mode_display); - case VK_EXT_robustness2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_custom_border_color: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_present_barrier: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_surface, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); - case VK_KHR_present_id: return Self[?](VK_KHR_swapchain, VK_KHR_get_physical_device_properties2); - case VK_EXT_private_data: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_pipeline_creation_cache_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_video_encode_queue: return Self[?](VK_KHR_video_queue, VK_KHR_synchronization2); - case VK_NV_device_diagnostics_config: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_cuda_kernel_launch: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_QCOM_tile_shading: return Self[?](VK_QCOM_tile_properties, VK_KHR_get_physical_device_properties2); - case VK_KHR_synchronization2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_descriptor_buffer: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address, VK_EXT_descriptor_indexing, VK_KHR_synchronization2); - case VK_EXT_graphics_pipeline_library: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_pipeline_library); - case VK_AMD_shader_early_and_late_fragment_tests: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_fragment_shader_barycentric: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_zero_initialize_workgroup_memory: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_fragment_shading_rate_enums: return Self[?](VK_KHR_fragment_shading_rate); - case VK_NV_ray_tracing_motion_blur: return Self[?](VK_KHR_ray_tracing_pipeline); - case VK_EXT_mesh_shader: return Self[?](VK_KHR_spirv_1_4); - case VK_EXT_ycbcr_2plane_444_formats: return Self[?](VK_KHR_sampler_ycbcr_conversion); - case VK_EXT_fragment_density_map2: return Self[?](VK_EXT_fragment_density_map); - case VK_QCOM_rotated_copy_commands: return Self[?](VK_KHR_copy_commands2); - case VK_EXT_image_robustness: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_workgroup_memory_explicit_layout: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_copy_commands2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_image_compression_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_attachment_feedback_loop_layout: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_4444_formats: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_device_fault: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_rasterization_order_attachment_access: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_rgba10x6_formats: return Self[?](VK_KHR_sampler_ycbcr_conversion); - case VK_NV_acquire_winrt_display: return Self[?](VK_EXT_direct_mode_display); - case VK_EXT_directfb_surface: return Self[?](VK_KHR_surface); - case VK_VALVE_mutable_descriptor_type: return Self[?](VK_KHR_maintenance3); - case VK_EXT_vertex_input_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_physical_device_drm: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_device_address_binding_report: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_debug_utils); - case VK_EXT_depth_clip_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_primitive_topology_list_restart: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_format_feature_flags2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_present_mode_fifo_latest_ready: return Self[?](VK_KHR_swapchain); - case VK_FUCHSIA_external_memory: return Self[?](VK_KHR_external_memory_capabilities, VK_KHR_external_memory); - case VK_FUCHSIA_external_semaphore: return Self[?](VK_KHR_external_semaphore_capabilities, VK_KHR_external_semaphore); - case VK_FUCHSIA_buffer_collection: return Self[?](VK_FUCHSIA_external_memory, VK_KHR_sampler_ycbcr_conversion); - case VK_HUAWEI_subpass_shading: return Self[?](VK_KHR_create_renderpass2, VK_KHR_synchronization2); - case VK_HUAWEI_invocation_mask: return Self[?](VK_KHR_ray_tracing_pipeline, VK_KHR_synchronization2); - case VK_NV_external_memory_rdma: return Self[?](VK_KHR_external_memory); - case VK_EXT_pipeline_properties: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_frame_boundary: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_multisampled_render_to_single_sampled: return Self[?](VK_KHR_create_renderpass2, VK_KHR_depth_stencil_resolve); - case VK_EXT_extended_dynamic_state2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_QNX_screen_surface: return Self[?](VK_KHR_surface); - case VK_EXT_color_write_enable: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_primitives_generated_query: return Self[?](VK_EXT_transform_feedback); - case VK_KHR_ray_tracing_maintenance1: return Self[?](VK_KHR_acceleration_structure); - case VK_KHR_shader_untyped_pointers: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_global_priority_query: return Self[?](VK_EXT_global_priority, VK_KHR_get_physical_device_properties2); - case VK_VALVE_video_encode_rgb_conversion: return Self[?](VK_KHR_video_encode_queue, VK_KHR_sampler_ycbcr_conversion); - case VK_EXT_image_view_min_lod: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_multi_draw: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_image_2d_view_of_3d: return Self[?](VK_KHR_maintenance1, VK_KHR_get_physical_device_properties2); - case VK_EXT_opacity_micromap: return Self[?](VK_KHR_acceleration_structure, VK_KHR_synchronization2); - case VK_NV_displacement_micromap: return Self[?](VK_EXT_opacity_micromap); - case VK_HUAWEI_cluster_culling_shader: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_border_color_swizzle: return Self[?](VK_EXT_custom_border_color); - case VK_EXT_pageable_device_local_memory: return Self[?](VK_EXT_memory_priority); - case VK_KHR_shader_subgroup_rotate: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_scheduling_controls: return Self[?](VK_ARM_shader_core_builtins); - case VK_EXT_image_sliced_view_of_3d: return Self[?](VK_KHR_maintenance1, VK_KHR_get_physical_device_properties2); - case VK_VALVE_descriptor_set_host_mapping: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_depth_clamp_zero_one: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_non_seamless_cube_map: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_render_pass_striped: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_synchronization2); - case VK_QCOM_fragment_density_map_offset: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_fragment_density_map); - case VK_NV_copy_memory_indirect: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); - case VK_NV_memory_decompression: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); - case VK_NV_device_generated_commands_compute: return Self[?](VK_NV_device_generated_commands); - case VK_NV_ray_tracing_linear_swept_spheres: return Self[?](VK_KHR_ray_tracing_pipeline); - case VK_NV_linear_color_attachment: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_GOOGLE_surfaceless_query: return Self[?](VK_KHR_surface); - case VK_EXT_image_compression_control_swapchain: return Self[?](VK_EXT_image_compression_control); - case VK_QCOM_image_processing: return Self[?](VK_KHR_format_feature_flags2); - case VK_EXT_nested_command_buffer: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_OHOS_external_memory: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); - case VK_EXT_external_memory_acquire_unmodified: return Self[?](VK_KHR_external_memory); - case VK_EXT_extended_dynamic_state3: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_subpass_merge_feedback: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_module_identifier: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_pipeline_creation_cache_control); - case VK_EXT_rasterization_order_attachment_access: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_optical_flow: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_format_feature_flags2, VK_KHR_synchronization2); - case VK_EXT_legacy_dithering: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_pipeline_protected_access: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ANDROID_external_format_resolve: return Self[?](VK_ANDROID_external_memory_android_hardware_buffer); - case VK_KHR_maintenance5: return Self[?](VK_KHR_dynamic_rendering); - case VK_AMD_anti_lag: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_AMDX_dense_geometry_format: return Self[?](VK_KHR_acceleration_structure, VK_KHR_maintenance5); - case VK_KHR_present_id2: return Self[?](VK_KHR_get_surface_capabilities2, VK_KHR_surface, VK_KHR_swapchain); - case VK_KHR_present_wait2: return Self[?](VK_KHR_get_surface_capabilities2, VK_KHR_surface, VK_KHR_swapchain, VK_KHR_present_id2); - case VK_KHR_ray_tracing_position_fetch: return Self[?](VK_KHR_acceleration_structure); - case VK_EXT_shader_object: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_dynamic_rendering); - case VK_KHR_pipeline_binary: return Self[?](VK_KHR_maintenance5); - case VK_QCOM_tile_properties: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_SEC_amigo_profiling: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_surface_maintenance1: return Self[?](VK_KHR_surface, VK_KHR_get_surface_capabilities2); - case VK_KHR_swapchain_maintenance1: return Self[?](VK_KHR_swapchain, VK_KHR_surface_maintenance1, VK_KHR_get_physical_device_properties2); - case VK_QCOM_multiview_per_view_viewports: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_ray_tracing_invocation_reorder: return Self[?](VK_KHR_ray_tracing_pipeline); - case VK_NV_cooperative_vector: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_extended_sparse_address_space: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_mutable_descriptor_type: return Self[?](VK_KHR_maintenance3); - case VK_EXT_legacy_vertex_attributes: return Self[?](VK_EXT_vertex_input_dynamic_state); - case VK_ARM_shader_core_builtins: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_pipeline_library_group_handles: return Self[?](VK_KHR_ray_tracing_pipeline, VK_KHR_pipeline_library); - case VK_EXT_dynamic_rendering_unused_attachments: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_dynamic_rendering); - case VK_NV_low_latency2: return Self[?](VK_KHR_timeline_semaphore, VK_KHR_present_id, VK_KHR_present_id2); - case VK_KHR_cooperative_matrix: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_data_graph: return Self[?](VK_KHR_maintenance5, VK_KHR_deferred_host_operations); - case VK_QCOM_multiview_per_view_render_areas: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_compute_shader_derivatives: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_video_decode_av1: return Self[?](VK_KHR_video_decode_queue); - case VK_KHR_video_encode_av1: return Self[?](VK_KHR_video_encode_queue); - case VK_KHR_video_decode_vp9: return Self[?](VK_KHR_video_decode_queue); - case VK_KHR_video_maintenance1: return Self[?](VK_KHR_video_queue); - case VK_NV_per_stage_descriptor_set: return Self[?](VK_KHR_maintenance6); - case VK_QCOM_image_processing2: return Self[?](VK_QCOM_image_processing); - case VK_QCOM_filter_cubic_weights: return Self[?](VK_EXT_filter_cubic); - case VK_QCOM_ycbcr_degamma: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_QCOM_filter_cubic_clamp: return Self[?](VK_EXT_filter_cubic, VK_EXT_sampler_filter_minmax); - case VK_EXT_attachment_feedback_loop_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_attachment_feedback_loop_layout); - case VK_KHR_vertex_attribute_divisor: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_unified_image_layouts: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_float_controls2: return Self[?](VK_KHR_shader_float_controls); - case VK_QNX_external_memory_screen_buffer: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); - case VK_MSFT_layered_driver: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_index_type_uint8: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_calibrated_timestamps: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_expect_assume: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_QCOM_tile_memory_heap: return Self[?](VK_KHR_get_memory_requirements2, VK_KHR_get_physical_device_properties2); - case VK_KHR_copy_memory_indirect: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); - case VK_EXT_memory_decompression: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); - case VK_NV_display_stereo: return Self[?](VK_KHR_display, VK_KHR_get_display_properties2); - case VK_KHR_video_encode_intra_refresh: return Self[?](VK_KHR_video_encode_queue); - case VK_KHR_video_encode_quantization_map: return Self[?](VK_KHR_video_encode_queue, VK_KHR_format_feature_flags2); - case VK_NV_raw_access_chains: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_relaxed_extended_instruction: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_command_buffer_inheritance: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_shader_atomic_float16_vector: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_replicated_composites: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_float8: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_ray_tracing_validation: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_cluster_acceleration_structure: return Self[?](VK_KHR_acceleration_structure); - case VK_NV_partitioned_acceleration_structure: return Self[?](VK_KHR_acceleration_structure); - case VK_EXT_device_generated_commands: return Self[?](VK_KHR_buffer_device_address, VK_KHR_maintenance5); - case VK_MESA_image_alignment_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_shader_fma: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_ray_tracing_invocation_reorder: return Self[?](VK_KHR_ray_tracing_pipeline); - case VK_EXT_depth_clamp_control: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_maintenance9: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_video_maintenance2: return Self[?](VK_KHR_video_queue); - case VK_OHOS_surface: return Self[?](VK_KHR_surface); - case VK_HUAWEI_hdr_vivid: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_swapchain, VK_EXT_hdr_metadata); - case VK_NV_cooperative_matrix2: return Self[?](VK_KHR_cooperative_matrix); - case VK_ARM_pipeline_opacity_micromap: return Self[?](VK_EXT_opacity_micromap); - case VK_EXT_external_memory_metal: return Self[?](VK_KHR_external_memory); - case VK_KHR_depth_clamp_zero_one: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_performance_counters_by_region: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_vertex_attribute_robustness: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_ARM_format_pack: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_VALVE_fragment_density_map_layered: return Self[?](VK_KHR_maintenance5, VK_EXT_fragment_density_map); - case VK_KHR_robustness2: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_NV_present_metering: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_fragment_density_map_offset: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_fragment_density_map, VK_KHR_create_renderpass2, VK_KHR_dynamic_rendering); - case VK_EXT_zero_initialize_device_memory: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_KHR_present_mode_fifo_latest_ready: return Self[?](VK_KHR_swapchain); - case VK_EXT_shader_64bit_indexing: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_custom_resolve: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_QCOM_data_graph_model: return Self[?](VK_ARM_data_graph); - case VK_KHR_maintenance10: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_SEC_pipeline_cache_incremental_mode: return Self[?](VK_KHR_get_physical_device_properties2); - case VK_EXT_shader_uniform_buffer_unsized_array: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_dynamic_rendering: return VkPhysicalDeviceDynamicRenderingFeaturesKHR.SType; + case VK_NV_corner_sampled_image: return VkPhysicalDeviceCornerSampledImageFeaturesNV.SType; + case VK_KHR_multiview: return VkPhysicalDeviceMultiviewFeaturesKHR.SType; + case VK_KHR_shader_float16_int8: return VkPhysicalDeviceFloat16Int8FeaturesKHR.SType; + case VK_KHR_16bit_storage: return VkPhysicalDevice16BitStorageFeaturesKHR.SType; + case VK_EXT_depth_clip_enable: return VkPhysicalDeviceDepthClipEnableFeaturesEXT.SType; + case VK_KHR_imageless_framebuffer: return VkPhysicalDeviceImagelessFramebufferFeaturesKHR.SType; + case VK_IMG_relaxed_line_rasterization: return VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.SType; + case VK_KHR_performance_query: return VkPhysicalDevicePerformanceQueryFeaturesKHR.SType; + case VK_KHR_variable_pointers: return VkPhysicalDeviceVariablePointersFeaturesKHR.SType; + case VK_EXT_inline_uniform_block: return VkPhysicalDeviceInlineUniformBlockFeaturesEXT.SType; + case VK_KHR_shader_bfloat16: return VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType; + case VK_KHR_acceleration_structure: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; + case VK_KHR_ray_tracing_pipeline: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; + case VK_KHR_ray_query: return VkPhysicalDeviceRayQueryFeaturesKHR.SType; + case VK_NV_shader_sm_builtins: return VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.SType; + case VK_KHR_sampler_ycbcr_conversion: return VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.SType; + case VK_KHR_portability_subset: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; + case VK_NV_shading_rate_image: return VkPhysicalDeviceShadingRateImageFeaturesNV.SType; + case VK_NV_representative_fragment_test: return VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.SType; + case VK_KHR_shader_subgroup_extended_types: return VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.SType; + case VK_KHR_8bit_storage: return VkPhysicalDevice8BitStorageFeaturesKHR.SType; + case VK_KHR_shader_atomic_int64: return VkPhysicalDeviceShaderAtomicInt64FeaturesKHR.SType; + case VK_KHR_shader_clock: return VkPhysicalDeviceShaderClockFeaturesKHR.SType; + case VK_KHR_global_priority: return VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.SType; + case VK_NV_compute_shader_derivatives: return VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.SType; + case VK_NV_mesh_shader: return VkPhysicalDeviceMeshShaderFeaturesNV.SType; + case VK_NV_fragment_shader_barycentric: return VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.SType; + case VK_NV_shader_image_footprint: return VkPhysicalDeviceShaderImageFootprintFeaturesNV.SType; + case VK_NV_scissor_exclusive: return VkPhysicalDeviceExclusiveScissorFeaturesNV.SType; + case VK_KHR_timeline_semaphore: return VkPhysicalDeviceTimelineSemaphoreFeaturesKHR.SType; + case VK_EXT_present_timing: return VkPhysicalDevicePresentTimingFeaturesEXT.SType; + case VK_INTEL_shader_integer_functions2: return VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.SType; + case VK_KHR_vulkan_memory_model: return VkPhysicalDeviceVulkanMemoryModelFeaturesKHR.SType; + case VK_KHR_shader_terminate_invocation: return VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.SType; + case VK_EXT_fragment_density_map: return VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType; + case VK_EXT_scalar_block_layout: return VkPhysicalDeviceScalarBlockLayoutFeaturesEXT.SType; + case VK_EXT_subgroup_size_control: return VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.SType; + case VK_KHR_fragment_shading_rate: return VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType; + case VK_AMD_device_coherent_memory: return VkPhysicalDeviceCoherentMemoryFeaturesAMD.SType; + case VK_EXT_shader_image_atomic_int64: return VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType; + case VK_KHR_shader_quad_control: return VkPhysicalDeviceShaderQuadControlFeaturesKHR.SType; + case VK_EXT_memory_priority: return VkPhysicalDeviceMemoryPriorityFeaturesEXT.SType; + case VK_KHR_separate_depth_stencil_layouts: return VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.SType; + case VK_KHR_present_wait: return VkPhysicalDevicePresentWaitFeaturesKHR.SType; + case VK_NV_cooperative_matrix: return VkPhysicalDeviceCooperativeMatrixFeaturesNV.SType; + case VK_NV_coverage_reduction_mode: return VkPhysicalDeviceCoverageReductionModeFeaturesNV.SType; + case VK_EXT_fragment_shader_interlock: return VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType; + case VK_EXT_ycbcr_image_arrays: return VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.SType; + case VK_KHR_uniform_buffer_standard_layout: return VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR.SType; + case VK_EXT_provoking_vertex: return VkPhysicalDeviceProvokingVertexFeaturesEXT.SType; + case VK_KHR_buffer_device_address: return VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.SType; + case VK_EXT_line_rasterization: return VkPhysicalDeviceLineRasterizationFeaturesEXT.SType; + case VK_EXT_host_query_reset: return VkPhysicalDeviceHostQueryResetFeaturesEXT.SType; + case VK_EXT_index_type_uint8: return VkPhysicalDeviceIndexTypeUint8FeaturesEXT.SType; + case VK_EXT_extended_dynamic_state: return VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.SType; + case VK_KHR_pipeline_executable_properties: return VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.SType; + case VK_EXT_host_image_copy: return VkPhysicalDeviceHostImageCopyFeaturesEXT.SType; + case VK_EXT_map_memory_placed: return VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType; + case VK_EXT_shader_atomic_float2: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; + case VK_EXT_swapchain_maintenance1: return VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.SType; + case VK_EXT_shader_demote_to_helper_invocation: return VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.SType; + case VK_NV_device_generated_commands: return VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.SType; + case VK_NV_inherited_viewport_scissor: return VkPhysicalDeviceInheritedViewportScissorFeaturesNV.SType; + case VK_KHR_shader_integer_dot_product: return VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.SType; + case VK_EXT_texel_buffer_alignment: return VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.SType; + case VK_EXT_depth_bias_control: return VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType; + case VK_EXT_device_memory_report: return VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.SType; + case VK_EXT_robustness2: return VkPhysicalDeviceRobustness2FeaturesEXT.SType; + case VK_EXT_custom_border_color: return VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType; + case VK_NV_present_barrier: return VkPhysicalDevicePresentBarrierFeaturesNV.SType; + case VK_KHR_present_id: return VkPhysicalDevicePresentIdFeaturesKHR.SType; + case VK_NV_device_diagnostics_config: return VkPhysicalDeviceDiagnosticsConfigFeaturesNV.SType; + case VK_NV_cuda_kernel_launch: return VkPhysicalDeviceCudaKernelLaunchFeaturesNV.SType; + case VK_QCOM_tile_shading: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; + case VK_KHR_synchronization2: return VkPhysicalDeviceSynchronization2FeaturesKHR.SType; + case VK_EXT_descriptor_buffer: return VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType; + case VK_KHR_fragment_shader_barycentric: return VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.SType; + case VK_KHR_shader_subgroup_uniform_control_flow: return VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.SType; + case VK_KHR_zero_initialize_workgroup_memory: return VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.SType; + case VK_NV_fragment_shading_rate_enums: return VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType; + case VK_NV_ray_tracing_motion_blur: return VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType; + case VK_EXT_mesh_shader: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; + case VK_EXT_ycbcr_2plane_444_formats: return VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.SType; + case VK_EXT_fragment_density_map2: return VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.SType; + case VK_EXT_image_robustness: return VkPhysicalDeviceImageRobustnessFeaturesEXT.SType; + case VK_KHR_workgroup_memory_explicit_layout: return VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType; + case VK_EXT_image_compression_control: return VkPhysicalDeviceImageCompressionControlFeaturesEXT.SType; + case VK_EXT_attachment_feedback_loop_layout: return VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.SType; + case VK_EXT_4444_formats: return VkPhysicalDevice4444FormatsFeaturesEXT.SType; + case VK_EXT_device_fault: return VkPhysicalDeviceFaultFeaturesEXT.SType; + case VK_ARM_rasterization_order_attachment_access: return VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.SType; + case VK_EXT_rgba10x6_formats: return VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.SType; + case VK_VALVE_mutable_descriptor_type: return VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.SType; + case VK_EXT_vertex_input_dynamic_state: return VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.SType; + case VK_EXT_device_address_binding_report: return VkPhysicalDeviceAddressBindingReportFeaturesEXT.SType; + case VK_EXT_depth_clip_control: return VkPhysicalDeviceDepthClipControlFeaturesEXT.SType; + case VK_EXT_primitive_topology_list_restart: return VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType; + case VK_EXT_present_mode_fifo_latest_ready: return VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.SType; + case VK_HUAWEI_subpass_shading: return VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.SType; + case VK_NV_external_memory_rdma: return VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.SType; + case VK_EXT_pipeline_properties: return VkPhysicalDevicePipelinePropertiesFeaturesEXT.SType; + case VK_EXT_frame_boundary: return VkPhysicalDeviceFrameBoundaryFeaturesEXT.SType; + case VK_EXT_multisampled_render_to_single_sampled: return VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.SType; + case VK_EXT_extended_dynamic_state2: return VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType; + case VK_EXT_color_write_enable: return VkPhysicalDeviceColorWriteEnableFeaturesEXT.SType; + case VK_EXT_primitives_generated_query: return VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType; + case VK_KHR_ray_tracing_maintenance1: return VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType; + case VK_KHR_shader_untyped_pointers: return VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.SType; + case VK_EXT_global_priority_query: return VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.SType; + case VK_VALVE_video_encode_rgb_conversion: return VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.SType; + case VK_EXT_image_view_min_lod: return VkPhysicalDeviceImageViewMinLodFeaturesEXT.SType; + case VK_EXT_multi_draw: return VkPhysicalDeviceMultiDrawFeaturesEXT.SType; + case VK_EXT_image_2d_view_of_3d: return VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType; + case VK_EXT_shader_tile_image: return VkPhysicalDeviceShaderTileImageFeaturesEXT.SType; + case VK_EXT_opacity_micromap: return VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType; + case VK_NV_displacement_micromap: return VkPhysicalDeviceDisplacementMicromapFeaturesNV.SType; + case VK_HUAWEI_cluster_culling_shader: return VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.SType; + case VK_EXT_border_color_swizzle: return VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType; + case VK_EXT_pageable_device_local_memory: return VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.SType; + case VK_KHR_maintenance4: return VkPhysicalDeviceMaintenance4FeaturesKHR.SType; + case VK_KHR_shader_subgroup_rotate: return VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR.SType; + case VK_ARM_scheduling_controls: return VkPhysicalDeviceSchedulingControlsFeaturesARM.SType; + case VK_EXT_image_sliced_view_of_3d: return VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.SType; + case VK_VALVE_descriptor_set_host_mapping: return VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.SType; + case VK_EXT_depth_clamp_zero_one: return VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.SType; + case VK_EXT_non_seamless_cube_map: return VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.SType; + case VK_ARM_render_pass_striped: return VkPhysicalDeviceRenderPassStripedFeaturesARM.SType; + case VK_QCOM_fragment_density_map_offset: return VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.SType; + case VK_NV_copy_memory_indirect: return VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.SType; + case VK_NV_memory_decompression: return VkPhysicalDeviceMemoryDecompressionFeaturesNV.SType; + case VK_NV_device_generated_commands_compute: return VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType; + case VK_NV_ray_tracing_linear_swept_spheres: return VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType; + case VK_KHR_shader_maximal_reconvergence: return VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.SType; + case VK_EXT_image_compression_control_swapchain: return VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.SType; + case VK_QCOM_image_processing: return VkPhysicalDeviceImageProcessingFeaturesQCOM.SType; + case VK_EXT_nested_command_buffer: return VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType; + case VK_EXT_subpass_merge_feedback: return VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.SType; + case VK_ARM_tensors: return VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.SType; + case VK_EXT_shader_module_identifier: return VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.SType; + case VK_NV_optical_flow: return VkPhysicalDeviceOpticalFlowFeaturesNV.SType; + case VK_EXT_legacy_dithering: return VkPhysicalDeviceLegacyDitheringFeaturesEXT.SType; + case VK_EXT_pipeline_protected_access: return VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.SType; + case VK_ANDROID_external_format_resolve: return VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.SType; + case VK_KHR_maintenance5: return VkPhysicalDeviceMaintenance5FeaturesKHR.SType; + case VK_AMD_anti_lag: return VkPhysicalDeviceAntiLagFeaturesAMD.SType; + case VK_KHR_present_id2: return VkPhysicalDevicePresentId2FeaturesKHR.SType; + case VK_KHR_present_wait2: return VkPhysicalDevicePresentWait2FeaturesKHR.SType; + case VK_KHR_ray_tracing_position_fetch: return VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.SType; + case VK_EXT_shader_object: return VkPhysicalDeviceShaderObjectFeaturesEXT.SType; + case VK_KHR_pipeline_binary: return VkPhysicalDevicePipelineBinaryFeaturesKHR.SType; + case VK_QCOM_tile_properties: return VkPhysicalDeviceTilePropertiesFeaturesQCOM.SType; + case VK_SEC_amigo_profiling: return VkPhysicalDeviceAmigoProfilingFeaturesSEC.SType; + case VK_KHR_swapchain_maintenance1: return VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.SType; + case VK_QCOM_multiview_per_view_viewports: return VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.SType; + case VK_NV_ray_tracing_invocation_reorder: return VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.SType; + case VK_NV_cooperative_vector: return VkPhysicalDeviceCooperativeVectorFeaturesNV.SType; + case VK_NV_extended_sparse_address_space: return VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.SType; + case VK_EXT_mutable_descriptor_type: return VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.SType; + case VK_EXT_legacy_vertex_attributes: return VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.SType; + case VK_ARM_shader_core_builtins: return VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.SType; + case VK_EXT_pipeline_library_group_handles: return VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.SType; + case VK_EXT_dynamic_rendering_unused_attachments: return VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.SType; + case VK_KHR_cooperative_matrix: return VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType; + case VK_ARM_data_graph: return VkPhysicalDeviceDataGraphFeaturesARM.SType; + case VK_QCOM_multiview_per_view_render_areas: return VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.SType; + case VK_KHR_compute_shader_derivatives: return VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType; + case VK_KHR_video_encode_av1: return VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.SType; + case VK_KHR_video_decode_vp9: return VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.SType; + case VK_KHR_video_maintenance1: return VkPhysicalDeviceVideoMaintenance1FeaturesKHR.SType; + case VK_NV_per_stage_descriptor_set: return VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType; + case VK_QCOM_image_processing2: return VkPhysicalDeviceImageProcessing2FeaturesQCOM.SType; + case VK_QCOM_filter_cubic_weights: return VkPhysicalDeviceCubicWeightsFeaturesQCOM.SType; + case VK_QCOM_ycbcr_degamma: return VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.SType; + case VK_QCOM_filter_cubic_clamp: return VkPhysicalDeviceCubicClampFeaturesQCOM.SType; + case VK_EXT_attachment_feedback_loop_dynamic_state: return VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.SType; + case VK_KHR_vertex_attribute_divisor: return VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR.SType; + case VK_KHR_unified_image_layouts: return VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType; + case VK_KHR_shader_float_controls2: return VkPhysicalDeviceShaderFloatControls2FeaturesKHR.SType; + case VK_QNX_external_memory_screen_buffer: return VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.SType; + case VK_KHR_index_type_uint8: return VkPhysicalDeviceIndexTypeUint8FeaturesKHR.SType; + case VK_KHR_line_rasterization: return VkPhysicalDeviceLineRasterizationFeaturesKHR.SType; + case VK_KHR_shader_expect_assume: return VkPhysicalDeviceShaderExpectAssumeFeaturesKHR.SType; + case VK_KHR_maintenance6: return VkPhysicalDeviceMaintenance6FeaturesKHR.SType; + case VK_NV_descriptor_pool_overallocation: return VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.SType; + case VK_QCOM_tile_memory_heap: return VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.SType; + case VK_KHR_copy_memory_indirect: return VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType; + case VK_EXT_memory_decompression: return VkPhysicalDeviceMemoryDecompressionFeaturesEXT.SType; + case VK_KHR_video_encode_intra_refresh: return VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.SType; + case VK_KHR_video_encode_quantization_map: return VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.SType; + case VK_NV_raw_access_chains: return VkPhysicalDeviceRawAccessChainsFeaturesNV.SType; + case VK_KHR_shader_relaxed_extended_instruction: return VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.SType; + case VK_NV_command_buffer_inheritance: return VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.SType; + case VK_KHR_maintenance7: return VkPhysicalDeviceMaintenance7FeaturesKHR.SType; + case VK_NV_shader_atomic_float16_vector: return VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.SType; + case VK_EXT_shader_replicated_composites: return VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.SType; + case VK_EXT_shader_float8: return VkPhysicalDeviceShaderFloat8FeaturesEXT.SType; + case VK_NV_ray_tracing_validation: return VkPhysicalDeviceRayTracingValidationFeaturesNV.SType; + case VK_NV_cluster_acceleration_structure: return VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.SType; + case VK_NV_partitioned_acceleration_structure: return VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.SType; + case VK_EXT_device_generated_commands: return VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType; + case VK_KHR_maintenance8: return VkPhysicalDeviceMaintenance8FeaturesKHR.SType; + case VK_MESA_image_alignment_control: return VkPhysicalDeviceImageAlignmentControlFeaturesMESA.SType; + case VK_KHR_shader_fma: return VkPhysicalDeviceShaderFmaFeaturesKHR.SType; + case VK_EXT_ray_tracing_invocation_reorder: return VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT.SType; + case VK_EXT_depth_clamp_control: return VkPhysicalDeviceDepthClampControlFeaturesEXT.SType; + case VK_KHR_maintenance9: return VkPhysicalDeviceMaintenance9FeaturesKHR.SType; + case VK_KHR_video_maintenance2: return VkPhysicalDeviceVideoMaintenance2FeaturesKHR.SType; + case VK_HUAWEI_hdr_vivid: return VkPhysicalDeviceHdrVividFeaturesHUAWEI.SType; + case VK_NV_cooperative_matrix2: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; + case VK_ARM_pipeline_opacity_micromap: return VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.SType; + case VK_KHR_depth_clamp_zero_one: return VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.SType; + case VK_ARM_performance_counters_by_region: return VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.SType; + case VK_EXT_vertex_attribute_robustness: return VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.SType; + case VK_ARM_format_pack: return VkPhysicalDeviceFormatPackFeaturesARM.SType; + case VK_VALVE_fragment_density_map_layered: return VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.SType; + case VK_KHR_robustness2: return VkPhysicalDeviceRobustness2FeaturesKHR.SType; + case VK_NV_present_metering: return VkPhysicalDevicePresentMeteringFeaturesNV.SType; + case VK_EXT_fragment_density_map_offset: return VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.SType; + case VK_EXT_zero_initialize_device_memory: return VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.SType; + case VK_KHR_present_mode_fifo_latest_ready: return VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.SType; + case VK_EXT_shader_64bit_indexing: return VkPhysicalDeviceShader64BitIndexingFeaturesEXT.SType; + case VK_EXT_custom_resolve: return VkPhysicalDeviceCustomResolveFeaturesEXT.SType; + case VK_QCOM_data_graph_model: return VkPhysicalDeviceDataGraphModelFeaturesQCOM.SType; + case VK_KHR_maintenance10: return VkPhysicalDeviceMaintenance10FeaturesKHR.SType; + case VK_SEC_pipeline_cache_incremental_mode: return VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.SType; + case VK_EXT_shader_uniform_buffer_unsized_array: return VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.SType; default: return default; } } } + + [Optimize] public static Self ForFeatureStruct(VkStructureType val) + { + Self output = 0; + if (val == VkPhysicalDeviceDynamicRenderingFeaturesKHR.SType) output = VK_KHR_dynamic_rendering; + if (val == VkPhysicalDeviceCornerSampledImageFeaturesNV.SType) output = VK_NV_corner_sampled_image; + if (val == VkPhysicalDeviceMultiviewFeaturesKHR.SType) output = VK_KHR_multiview; + if (val == VkPhysicalDeviceFloat16Int8FeaturesKHR.SType) output = VK_KHR_shader_float16_int8; + if (val == VkPhysicalDevice16BitStorageFeaturesKHR.SType) output = VK_KHR_16bit_storage; + if (val == VkPhysicalDeviceDepthClipEnableFeaturesEXT.SType) output = VK_EXT_depth_clip_enable; + if (val == VkPhysicalDeviceImagelessFramebufferFeaturesKHR.SType) output = VK_KHR_imageless_framebuffer; + if (val == VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.SType) output = VK_IMG_relaxed_line_rasterization; + if (val == VkPhysicalDevicePerformanceQueryFeaturesKHR.SType) output = VK_KHR_performance_query; + if (val == VkPhysicalDeviceVariablePointersFeaturesKHR.SType) output = VK_KHR_variable_pointers; + if (val == VkPhysicalDeviceInlineUniformBlockFeaturesEXT.SType) output = VK_EXT_inline_uniform_block; + if (val == VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType) output = VK_KHR_shader_bfloat16; + if (val == VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType) output = VK_KHR_acceleration_structure; + if (val == VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType) output = VK_KHR_ray_tracing_pipeline; + if (val == VkPhysicalDeviceRayQueryFeaturesKHR.SType) output = VK_KHR_ray_query; + if (val == VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.SType) output = VK_NV_shader_sm_builtins; + if (val == VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.SType) output = VK_KHR_sampler_ycbcr_conversion; + if (val == VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType) output = VK_KHR_portability_subset; + if (val == VkPhysicalDeviceShadingRateImageFeaturesNV.SType) output = VK_NV_shading_rate_image; + if (val == VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.SType) output = VK_NV_representative_fragment_test; + if (val == VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.SType) output = VK_KHR_shader_subgroup_extended_types; + if (val == VkPhysicalDevice8BitStorageFeaturesKHR.SType) output = VK_KHR_8bit_storage; + if (val == VkPhysicalDeviceShaderAtomicInt64FeaturesKHR.SType) output = VK_KHR_shader_atomic_int64; + if (val == VkPhysicalDeviceShaderClockFeaturesKHR.SType) output = VK_KHR_shader_clock; + if (val == VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.SType) output = VK_KHR_global_priority; + if (val == VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.SType) output = VK_NV_compute_shader_derivatives; + if (val == VkPhysicalDeviceMeshShaderFeaturesNV.SType) output = VK_NV_mesh_shader; + if (val == VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.SType) output = VK_NV_fragment_shader_barycentric; + if (val == VkPhysicalDeviceShaderImageFootprintFeaturesNV.SType) output = VK_NV_shader_image_footprint; + if (val == VkPhysicalDeviceExclusiveScissorFeaturesNV.SType) output = VK_NV_scissor_exclusive; + if (val == VkPhysicalDeviceTimelineSemaphoreFeaturesKHR.SType) output = VK_KHR_timeline_semaphore; + if (val == VkPhysicalDevicePresentTimingFeaturesEXT.SType) output = VK_EXT_present_timing; + if (val == VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.SType) output = VK_INTEL_shader_integer_functions2; + if (val == VkPhysicalDeviceVulkanMemoryModelFeaturesKHR.SType) output = VK_KHR_vulkan_memory_model; + if (val == VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.SType) output = VK_KHR_shader_terminate_invocation; + if (val == VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType) output = VK_EXT_fragment_density_map; + if (val == VkPhysicalDeviceScalarBlockLayoutFeaturesEXT.SType) output = VK_EXT_scalar_block_layout; + if (val == VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.SType) output = VK_EXT_subgroup_size_control; + if (val == VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType) output = VK_KHR_fragment_shading_rate; + if (val == VkPhysicalDeviceCoherentMemoryFeaturesAMD.SType) output = VK_AMD_device_coherent_memory; + if (val == VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType) output = VK_EXT_shader_image_atomic_int64; + if (val == VkPhysicalDeviceShaderQuadControlFeaturesKHR.SType) output = VK_KHR_shader_quad_control; + if (val == VkPhysicalDeviceMemoryPriorityFeaturesEXT.SType) output = VK_EXT_memory_priority; + if (val == VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.SType) output = VK_KHR_separate_depth_stencil_layouts; + if (val == VkPhysicalDevicePresentWaitFeaturesKHR.SType) output = VK_KHR_present_wait; + if (val == VkPhysicalDeviceCooperativeMatrixFeaturesNV.SType) output = VK_NV_cooperative_matrix; + if (val == VkPhysicalDeviceCoverageReductionModeFeaturesNV.SType) output = VK_NV_coverage_reduction_mode; + if (val == VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType) output = VK_EXT_fragment_shader_interlock; + if (val == VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.SType) output = VK_EXT_ycbcr_image_arrays; + if (val == VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR.SType) output = VK_KHR_uniform_buffer_standard_layout; + if (val == VkPhysicalDeviceProvokingVertexFeaturesEXT.SType) output = VK_EXT_provoking_vertex; + if (val == VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.SType) output = VK_KHR_buffer_device_address; + if (val == VkPhysicalDeviceLineRasterizationFeaturesEXT.SType) output = VK_EXT_line_rasterization; + if (val == VkPhysicalDeviceHostQueryResetFeaturesEXT.SType) output = VK_EXT_host_query_reset; + if (val == VkPhysicalDeviceIndexTypeUint8FeaturesEXT.SType) output = VK_EXT_index_type_uint8; + if (val == VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.SType) output = VK_EXT_extended_dynamic_state; + if (val == VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.SType) output = VK_KHR_pipeline_executable_properties; + if (val == VkPhysicalDeviceHostImageCopyFeaturesEXT.SType) output = VK_EXT_host_image_copy; + if (val == VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType) output = VK_EXT_map_memory_placed; + if (val == VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType) output = VK_EXT_shader_atomic_float2; + if (val == VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.SType) output = VK_EXT_swapchain_maintenance1; + if (val == VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.SType) output = VK_EXT_shader_demote_to_helper_invocation; + if (val == VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.SType) output = VK_NV_device_generated_commands; + if (val == VkPhysicalDeviceInheritedViewportScissorFeaturesNV.SType) output = VK_NV_inherited_viewport_scissor; + if (val == VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.SType) output = VK_KHR_shader_integer_dot_product; + if (val == VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.SType) output = VK_EXT_texel_buffer_alignment; + if (val == VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType) output = VK_EXT_depth_bias_control; + if (val == VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.SType) output = VK_EXT_device_memory_report; + if (val == VkPhysicalDeviceRobustness2FeaturesEXT.SType) output = VK_EXT_robustness2; + if (val == VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType) output = VK_EXT_custom_border_color; + if (val == VkPhysicalDevicePresentBarrierFeaturesNV.SType) output = VK_NV_present_barrier; + if (val == VkPhysicalDevicePresentIdFeaturesKHR.SType) output = VK_KHR_present_id; + if (val == VkPhysicalDeviceDiagnosticsConfigFeaturesNV.SType) output = VK_NV_device_diagnostics_config; + if (val == VkPhysicalDeviceCudaKernelLaunchFeaturesNV.SType) output = VK_NV_cuda_kernel_launch; + if (val == VkPhysicalDeviceTileShadingFeaturesQCOM.SType) output = VK_QCOM_tile_shading; + if (val == VkPhysicalDeviceSynchronization2FeaturesKHR.SType) output = VK_KHR_synchronization2; + if (val == VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType) output = VK_EXT_descriptor_buffer; + if (val == VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.SType) output = VK_KHR_fragment_shader_barycentric; + if (val == VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.SType) output = VK_KHR_shader_subgroup_uniform_control_flow; + if (val == VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.SType) output = VK_KHR_zero_initialize_workgroup_memory; + if (val == VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType) output = VK_NV_fragment_shading_rate_enums; + if (val == VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType) output = VK_NV_ray_tracing_motion_blur; + if (val == VkPhysicalDeviceMeshShaderFeaturesEXT.SType) output = VK_EXT_mesh_shader; + if (val == VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.SType) output = VK_EXT_ycbcr_2plane_444_formats; + if (val == VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.SType) output = VK_EXT_fragment_density_map2; + if (val == VkPhysicalDeviceImageRobustnessFeaturesEXT.SType) output = VK_EXT_image_robustness; + if (val == VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType) output = VK_KHR_workgroup_memory_explicit_layout; + if (val == VkPhysicalDeviceImageCompressionControlFeaturesEXT.SType) output = VK_EXT_image_compression_control; + if (val == VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.SType) output = VK_EXT_attachment_feedback_loop_layout; + if (val == VkPhysicalDevice4444FormatsFeaturesEXT.SType) output = VK_EXT_4444_formats; + if (val == VkPhysicalDeviceFaultFeaturesEXT.SType) output = VK_EXT_device_fault; + if (val == VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.SType) output = VK_ARM_rasterization_order_attachment_access; + if (val == VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.SType) output = VK_EXT_rgba10x6_formats; + if (val == VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.SType) output = VK_VALVE_mutable_descriptor_type; + if (val == VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.SType) output = VK_EXT_vertex_input_dynamic_state; + if (val == VkPhysicalDeviceAddressBindingReportFeaturesEXT.SType) output = VK_EXT_device_address_binding_report; + if (val == VkPhysicalDeviceDepthClipControlFeaturesEXT.SType) output = VK_EXT_depth_clip_control; + if (val == VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType) output = VK_EXT_primitive_topology_list_restart; + if (val == VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.SType) output = VK_EXT_present_mode_fifo_latest_ready; + if (val == VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.SType) output = VK_HUAWEI_subpass_shading; + if (val == VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.SType) output = VK_NV_external_memory_rdma; + if (val == VkPhysicalDevicePipelinePropertiesFeaturesEXT.SType) output = VK_EXT_pipeline_properties; + if (val == VkPhysicalDeviceFrameBoundaryFeaturesEXT.SType) output = VK_EXT_frame_boundary; + if (val == VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.SType) output = VK_EXT_multisampled_render_to_single_sampled; + if (val == VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType) output = VK_EXT_extended_dynamic_state2; + if (val == VkPhysicalDeviceColorWriteEnableFeaturesEXT.SType) output = VK_EXT_color_write_enable; + if (val == VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType) output = VK_EXT_primitives_generated_query; + if (val == VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType) output = VK_KHR_ray_tracing_maintenance1; + if (val == VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.SType) output = VK_KHR_shader_untyped_pointers; + if (val == VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.SType) output = VK_EXT_global_priority_query; + if (val == VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.SType) output = VK_VALVE_video_encode_rgb_conversion; + if (val == VkPhysicalDeviceImageViewMinLodFeaturesEXT.SType) output = VK_EXT_image_view_min_lod; + if (val == VkPhysicalDeviceMultiDrawFeaturesEXT.SType) output = VK_EXT_multi_draw; + if (val == VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType) output = VK_EXT_image_2d_view_of_3d; + if (val == VkPhysicalDeviceShaderTileImageFeaturesEXT.SType) output = VK_EXT_shader_tile_image; + if (val == VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType) output = VK_EXT_opacity_micromap; + if (val == VkPhysicalDeviceDisplacementMicromapFeaturesNV.SType) output = VK_NV_displacement_micromap; + if (val == VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.SType) output = VK_HUAWEI_cluster_culling_shader; + if (val == VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType) output = VK_EXT_border_color_swizzle; + if (val == VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.SType) output = VK_EXT_pageable_device_local_memory; + if (val == VkPhysicalDeviceMaintenance4FeaturesKHR.SType) output = VK_KHR_maintenance4; + if (val == VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR.SType) output = VK_KHR_shader_subgroup_rotate; + if (val == VkPhysicalDeviceSchedulingControlsFeaturesARM.SType) output = VK_ARM_scheduling_controls; + if (val == VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.SType) output = VK_EXT_image_sliced_view_of_3d; + if (val == VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.SType) output = VK_VALVE_descriptor_set_host_mapping; + if (val == VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.SType) output = VK_EXT_depth_clamp_zero_one; + if (val == VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.SType) output = VK_EXT_non_seamless_cube_map; + if (val == VkPhysicalDeviceRenderPassStripedFeaturesARM.SType) output = VK_ARM_render_pass_striped; + if (val == VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.SType) output = VK_QCOM_fragment_density_map_offset; + if (val == VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.SType) output = VK_NV_copy_memory_indirect; + if (val == VkPhysicalDeviceMemoryDecompressionFeaturesNV.SType) output = VK_NV_memory_decompression; + if (val == VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType) output = VK_NV_device_generated_commands_compute; + if (val == VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType) output = VK_NV_ray_tracing_linear_swept_spheres; + if (val == VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.SType) output = VK_KHR_shader_maximal_reconvergence; + if (val == VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.SType) output = VK_EXT_image_compression_control_swapchain; + if (val == VkPhysicalDeviceImageProcessingFeaturesQCOM.SType) output = VK_QCOM_image_processing; + if (val == VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType) output = VK_EXT_nested_command_buffer; + if (val == VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.SType) output = VK_EXT_subpass_merge_feedback; + if (val == VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.SType) output = VK_ARM_tensors; + if (val == VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.SType) output = VK_EXT_shader_module_identifier; + if (val == VkPhysicalDeviceOpticalFlowFeaturesNV.SType) output = VK_NV_optical_flow; + if (val == VkPhysicalDeviceLegacyDitheringFeaturesEXT.SType) output = VK_EXT_legacy_dithering; + if (val == VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.SType) output = VK_EXT_pipeline_protected_access; + if (val == VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.SType) output = VK_ANDROID_external_format_resolve; + if (val == VkPhysicalDeviceMaintenance5FeaturesKHR.SType) output = VK_KHR_maintenance5; + if (val == VkPhysicalDeviceAntiLagFeaturesAMD.SType) output = VK_AMD_anti_lag; + if (val == VkPhysicalDevicePresentId2FeaturesKHR.SType) output = VK_KHR_present_id2; + if (val == VkPhysicalDevicePresentWait2FeaturesKHR.SType) output = VK_KHR_present_wait2; + if (val == VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.SType) output = VK_KHR_ray_tracing_position_fetch; + if (val == VkPhysicalDeviceShaderObjectFeaturesEXT.SType) output = VK_EXT_shader_object; + if (val == VkPhysicalDevicePipelineBinaryFeaturesKHR.SType) output = VK_KHR_pipeline_binary; + if (val == VkPhysicalDeviceTilePropertiesFeaturesQCOM.SType) output = VK_QCOM_tile_properties; + if (val == VkPhysicalDeviceAmigoProfilingFeaturesSEC.SType) output = VK_SEC_amigo_profiling; + if (val == VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.SType) output = VK_KHR_swapchain_maintenance1; + if (val == VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.SType) output = VK_QCOM_multiview_per_view_viewports; + if (val == VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.SType) output = VK_NV_ray_tracing_invocation_reorder; + if (val == VkPhysicalDeviceCooperativeVectorFeaturesNV.SType) output = VK_NV_cooperative_vector; + if (val == VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.SType) output = VK_NV_extended_sparse_address_space; + if (val == VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.SType) output = VK_EXT_mutable_descriptor_type; + if (val == VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.SType) output = VK_EXT_legacy_vertex_attributes; + if (val == VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.SType) output = VK_ARM_shader_core_builtins; + if (val == VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.SType) output = VK_EXT_pipeline_library_group_handles; + if (val == VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.SType) output = VK_EXT_dynamic_rendering_unused_attachments; + if (val == VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType) output = VK_KHR_cooperative_matrix; + if (val == VkPhysicalDeviceDataGraphFeaturesARM.SType) output = VK_ARM_data_graph; + if (val == VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.SType) output = VK_QCOM_multiview_per_view_render_areas; + if (val == VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType) output = VK_KHR_compute_shader_derivatives; + if (val == VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.SType) output = VK_KHR_video_encode_av1; + if (val == VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.SType) output = VK_KHR_video_decode_vp9; + if (val == VkPhysicalDeviceVideoMaintenance1FeaturesKHR.SType) output = VK_KHR_video_maintenance1; + if (val == VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType) output = VK_NV_per_stage_descriptor_set; + if (val == VkPhysicalDeviceImageProcessing2FeaturesQCOM.SType) output = VK_QCOM_image_processing2; + if (val == VkPhysicalDeviceCubicWeightsFeaturesQCOM.SType) output = VK_QCOM_filter_cubic_weights; + if (val == VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.SType) output = VK_QCOM_ycbcr_degamma; + if (val == VkPhysicalDeviceCubicClampFeaturesQCOM.SType) output = VK_QCOM_filter_cubic_clamp; + if (val == VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.SType) output = VK_EXT_attachment_feedback_loop_dynamic_state; + if (val == VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR.SType) output = VK_KHR_vertex_attribute_divisor; + if (val == VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType) output = VK_KHR_unified_image_layouts; + if (val == VkPhysicalDeviceShaderFloatControls2FeaturesKHR.SType) output = VK_KHR_shader_float_controls2; + if (val == VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.SType) output = VK_QNX_external_memory_screen_buffer; + if (val == VkPhysicalDeviceIndexTypeUint8FeaturesKHR.SType) output = VK_KHR_index_type_uint8; + if (val == VkPhysicalDeviceLineRasterizationFeaturesKHR.SType) output = VK_KHR_line_rasterization; + if (val == VkPhysicalDeviceShaderExpectAssumeFeaturesKHR.SType) output = VK_KHR_shader_expect_assume; + if (val == VkPhysicalDeviceMaintenance6FeaturesKHR.SType) output = VK_KHR_maintenance6; + if (val == VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.SType) output = VK_NV_descriptor_pool_overallocation; + if (val == VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.SType) output = VK_QCOM_tile_memory_heap; + if (val == VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType) output = VK_KHR_copy_memory_indirect; + if (val == VkPhysicalDeviceMemoryDecompressionFeaturesEXT.SType) output = VK_EXT_memory_decompression; + if (val == VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.SType) output = VK_KHR_video_encode_intra_refresh; + if (val == VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.SType) output = VK_KHR_video_encode_quantization_map; + if (val == VkPhysicalDeviceRawAccessChainsFeaturesNV.SType) output = VK_NV_raw_access_chains; + if (val == VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.SType) output = VK_KHR_shader_relaxed_extended_instruction; + if (val == VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.SType) output = VK_NV_command_buffer_inheritance; + if (val == VkPhysicalDeviceMaintenance7FeaturesKHR.SType) output = VK_KHR_maintenance7; + if (val == VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.SType) output = VK_NV_shader_atomic_float16_vector; + if (val == VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.SType) output = VK_EXT_shader_replicated_composites; + if (val == VkPhysicalDeviceShaderFloat8FeaturesEXT.SType) output = VK_EXT_shader_float8; + if (val == VkPhysicalDeviceRayTracingValidationFeaturesNV.SType) output = VK_NV_ray_tracing_validation; + if (val == VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.SType) output = VK_NV_cluster_acceleration_structure; + if (val == VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.SType) output = VK_NV_partitioned_acceleration_structure; + if (val == VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType) output = VK_EXT_device_generated_commands; + if (val == VkPhysicalDeviceMaintenance8FeaturesKHR.SType) output = VK_KHR_maintenance8; + if (val == VkPhysicalDeviceImageAlignmentControlFeaturesMESA.SType) output = VK_MESA_image_alignment_control; + if (val == VkPhysicalDeviceShaderFmaFeaturesKHR.SType) output = VK_KHR_shader_fma; + if (val == VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT.SType) output = VK_EXT_ray_tracing_invocation_reorder; + if (val == VkPhysicalDeviceDepthClampControlFeaturesEXT.SType) output = VK_EXT_depth_clamp_control; + if (val == VkPhysicalDeviceMaintenance9FeaturesKHR.SType) output = VK_KHR_maintenance9; + if (val == VkPhysicalDeviceVideoMaintenance2FeaturesKHR.SType) output = VK_KHR_video_maintenance2; + if (val == VkPhysicalDeviceHdrVividFeaturesHUAWEI.SType) output = VK_HUAWEI_hdr_vivid; + if (val == VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType) output = VK_NV_cooperative_matrix2; + if (val == VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.SType) output = VK_ARM_pipeline_opacity_micromap; + if (val == VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.SType) output = VK_KHR_depth_clamp_zero_one; + if (val == VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.SType) output = VK_ARM_performance_counters_by_region; + if (val == VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.SType) output = VK_EXT_vertex_attribute_robustness; + if (val == VkPhysicalDeviceFormatPackFeaturesARM.SType) output = VK_ARM_format_pack; + if (val == VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.SType) output = VK_VALVE_fragment_density_map_layered; + if (val == VkPhysicalDeviceRobustness2FeaturesKHR.SType) output = VK_KHR_robustness2; + if (val == VkPhysicalDevicePresentMeteringFeaturesNV.SType) output = VK_NV_present_metering; + if (val == VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.SType) output = VK_EXT_fragment_density_map_offset; + if (val == VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.SType) output = VK_EXT_zero_initialize_device_memory; + if (val == VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.SType) output = VK_KHR_present_mode_fifo_latest_ready; + if (val == VkPhysicalDeviceShader64BitIndexingFeaturesEXT.SType) output = VK_EXT_shader_64bit_indexing; + if (val == VkPhysicalDeviceCustomResolveFeaturesEXT.SType) output = VK_EXT_custom_resolve; + if (val == VkPhysicalDeviceDataGraphModelFeaturesQCOM.SType) output = VK_QCOM_data_graph_model; + if (val == VkPhysicalDeviceMaintenance10FeaturesKHR.SType) output = VK_KHR_maintenance10; + if (val == VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.SType) output = VK_SEC_pipeline_cache_incremental_mode; + if (val == VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.SType) output = VK_EXT_shader_uniform_buffer_unsized_array; + return output; + } + + public int DependencyCount + { + get + { + switch (this) + { + case VK_KHR_swapchain: return 1; + case VK_KHR_display: return 1; + case VK_KHR_display_swapchain: return 2; + case VK_KHR_xlib_surface: return 1; + case VK_KHR_xcb_surface: return 1; + case VK_KHR_wayland_surface: return 1; + case VK_KHR_android_surface: return 1; + case VK_KHR_win32_surface: return 1; + case VK_EXT_debug_marker: return 1; + case VK_KHR_video_queue: return 1; + case VK_KHR_video_decode_queue: return 2; + case VK_EXT_transform_feedback: return 1; + case VK_KHR_video_encode_h264: return 1; + case VK_KHR_video_encode_h265: return 1; + case VK_KHR_video_decode_h264: return 1; + case VK_AMD_texture_gather_bias_lod: return 1; + case VK_KHR_dynamic_rendering: return 2; + case VK_GGP_stream_descriptor_surface: return 1; + case VK_NV_corner_sampled_image: return 1; + case VK_KHR_multiview: return 1; + case VK_NV_external_memory: return 1; + case VK_NV_external_memory_win32: return 1; + case VK_NV_win32_keyed_mutex: return 1; + case VK_KHR_device_group: return 1; + case VK_NN_vi_surface: return 1; + case VK_EXT_texture_compression_astc_hdr: return 1; + case VK_EXT_astc_decode_mode: return 1; + case VK_EXT_pipeline_robustness: return 1; + case VK_KHR_external_memory_capabilities: return 1; + case VK_KHR_external_memory: return 1; + case VK_KHR_external_memory_win32: return 1; + case VK_KHR_external_memory_fd: return 1; + case VK_KHR_win32_keyed_mutex: return 1; + case VK_KHR_external_semaphore_capabilities: return 1; + case VK_KHR_external_semaphore: return 1; + case VK_KHR_external_semaphore_win32: return 1; + case VK_KHR_external_semaphore_fd: return 1; + case VK_KHR_push_descriptor: return 1; + case VK_EXT_conditional_rendering: return 1; + case VK_KHR_shader_float16_int8: return 1; + case VK_KHR_16bit_storage: return 2; + case VK_KHR_incremental_present: return 1; + case VK_EXT_direct_mode_display: return 1; + case VK_EXT_acquire_xlib_display: return 1; + case VK_EXT_display_surface_counter: return 1; + case VK_EXT_display_control: return 2; + case VK_GOOGLE_display_timing: return 1; + case VK_NVX_multiview_per_view_attributes: return 1; + case VK_EXT_discard_rectangles: return 1; + case VK_EXT_conservative_rasterization: return 1; + case VK_EXT_depth_clip_enable: return 1; + case VK_EXT_swapchain_colorspace: return 1; + case VK_EXT_hdr_metadata: return 1; + case VK_KHR_imageless_framebuffer: return 3; + case VK_KHR_create_renderpass2: return 2; + case VK_IMG_relaxed_line_rasterization: return 1; + case VK_KHR_shared_presentable_image: return 3; + case VK_KHR_external_fence_capabilities: return 1; + case VK_KHR_external_fence: return 1; + case VK_KHR_external_fence_win32: return 1; + case VK_KHR_external_fence_fd: return 1; + case VK_KHR_performance_query: return 1; + case VK_KHR_get_surface_capabilities2: return 1; + case VK_KHR_variable_pointers: return 2; + case VK_KHR_get_display_properties2: return 1; + case VK_MVK_ios_surface: return 1; + case VK_MVK_macos_surface: return 1; + case VK_EXT_external_memory_dma_buf: return 1; + case VK_EXT_queue_family_foreign: return 1; + case VK_KHR_dedicated_allocation: return 1; + case VK_ANDROID_external_memory_android_hardware_buffer: return 4; + case VK_EXT_sampler_filter_minmax: return 1; + case VK_AMDX_shader_enqueue: return 5; + case VK_EXT_inline_uniform_block: return 2; + case VK_KHR_shader_bfloat16: return 1; + case VK_EXT_sample_locations: return 1; + case VK_EXT_blend_operation_advanced: return 1; + case VK_KHR_acceleration_structure: return 3; + case VK_KHR_ray_tracing_pipeline: return 2; + case VK_KHR_ray_query: return 2; + case VK_NV_shader_sm_builtins: return 0; + case VK_KHR_sampler_ycbcr_conversion: return 4; + case VK_EXT_image_drm_format_modifier: return 4; + case VK_EXT_descriptor_indexing: return 2; + case VK_KHR_portability_subset: return 1; + case VK_NV_shading_rate_image: return 1; + case VK_NV_ray_tracing: return 2; + case VK_NV_representative_fragment_test: return 1; + case VK_KHR_maintenance3: return 1; + case VK_KHR_shader_subgroup_extended_types: return 0; + case VK_KHR_8bit_storage: return 2; + case VK_EXT_external_memory_host: return 1; + case VK_KHR_shader_atomic_int64: return 1; + case VK_KHR_shader_clock: return 1; + case VK_EXT_calibrated_timestamps: return 1; + case VK_AMD_shader_core_properties: return 1; + case VK_KHR_video_decode_h265: return 1; + case VK_KHR_global_priority: return 1; + case VK_EXT_vertex_attribute_divisor: return 1; + case VK_GGP_frame_token: return 2; + case VK_KHR_driver_properties: return 1; + case VK_KHR_shader_float_controls: return 1; + case VK_NV_shader_subgroup_partitioned: return 0; + case VK_KHR_depth_stencil_resolve: return 1; + case VK_KHR_swapchain_mutable_format: return 3; + case VK_NV_compute_shader_derivatives: return 1; + case VK_NV_mesh_shader: return 1; + case VK_NV_fragment_shader_barycentric: return 1; + case VK_NV_shader_image_footprint: return 1; + case VK_NV_scissor_exclusive: return 1; + case VK_NV_device_diagnostic_checkpoints: return 1; + case VK_KHR_timeline_semaphore: return 1; + case VK_EXT_present_timing: return 4; + case VK_INTEL_shader_integer_functions2: return 1; + case VK_KHR_vulkan_memory_model: return 1; + case VK_EXT_pci_bus_info: return 1; + case VK_AMD_display_native_hdr: return 3; + case VK_FUCHSIA_imagepipe_surface: return 1; + case VK_KHR_shader_terminate_invocation: return 1; + case VK_EXT_metal_surface: return 1; + case VK_EXT_fragment_density_map: return 1; + case VK_EXT_scalar_block_layout: return 1; + case VK_EXT_subgroup_size_control: return 0; + case VK_KHR_fragment_shading_rate: return 2; + case VK_AMD_shader_core_properties2: return 1; + case VK_AMD_device_coherent_memory: return 1; + case VK_KHR_dynamic_rendering_local_read: return 1; + case VK_EXT_shader_image_atomic_int64: return 1; + case VK_KHR_shader_quad_control: return 2; + case VK_KHR_spirv_1_4: return 1; + case VK_EXT_memory_budget: return 1; + case VK_EXT_memory_priority: return 1; + case VK_KHR_surface_protected_capabilities: return 1; + case VK_NV_dedicated_allocation_image_aliasing: return 2; + case VK_KHR_separate_depth_stencil_layouts: return 2; + case VK_EXT_buffer_device_address: return 1; + case VK_KHR_present_wait: return 2; + case VK_NV_cooperative_matrix: return 1; + case VK_NV_coverage_reduction_mode: return 2; + case VK_EXT_fragment_shader_interlock: return 1; + case VK_EXT_ycbcr_image_arrays: return 1; + case VK_KHR_uniform_buffer_standard_layout: return 1; + case VK_EXT_provoking_vertex: return 1; + case VK_EXT_full_screen_exclusive: return 4; + case VK_EXT_headless_surface: return 1; + case VK_KHR_buffer_device_address: return 2; + case VK_EXT_line_rasterization: return 1; + case VK_EXT_shader_atomic_float: return 1; + case VK_EXT_host_query_reset: return 1; + case VK_EXT_index_type_uint8: return 1; + case VK_EXT_extended_dynamic_state: return 1; + case VK_KHR_pipeline_executable_properties: return 1; + case VK_EXT_host_image_copy: return 3; + case VK_EXT_map_memory_placed: return 1; + case VK_EXT_shader_atomic_float2: return 1; + case VK_EXT_surface_maintenance1: return 2; + case VK_EXT_swapchain_maintenance1: return 3; + case VK_EXT_shader_demote_to_helper_invocation: return 1; + case VK_NV_device_generated_commands: return 1; + case VK_NV_inherited_viewport_scissor: return 1; + case VK_KHR_shader_integer_dot_product: return 1; + case VK_EXT_texel_buffer_alignment: return 1; + case VK_EXT_depth_bias_control: return 1; + case VK_EXT_device_memory_report: return 1; + case VK_EXT_acquire_drm_display: return 1; + case VK_EXT_robustness2: return 1; + case VK_EXT_custom_border_color: return 1; + case VK_NV_present_barrier: return 4; + case VK_KHR_present_id: return 2; + case VK_EXT_private_data: return 1; + case VK_EXT_pipeline_creation_cache_control: return 1; + case VK_KHR_video_encode_queue: return 2; + case VK_NV_device_diagnostics_config: return 1; + case VK_NV_cuda_kernel_launch: return 1; + case VK_QCOM_tile_shading: return 2; + case VK_KHR_synchronization2: return 1; + case VK_EXT_descriptor_buffer: return 4; + case VK_EXT_graphics_pipeline_library: return 2; + case VK_AMD_shader_early_and_late_fragment_tests: return 1; + case VK_KHR_fragment_shader_barycentric: return 1; + case VK_KHR_shader_subgroup_uniform_control_flow: return 0; + case VK_KHR_zero_initialize_workgroup_memory: return 1; + case VK_NV_fragment_shading_rate_enums: return 1; + case VK_NV_ray_tracing_motion_blur: return 1; + case VK_EXT_mesh_shader: return 1; + case VK_EXT_ycbcr_2plane_444_formats: return 1; + case VK_EXT_fragment_density_map2: return 1; + case VK_QCOM_rotated_copy_commands: return 1; + case VK_EXT_image_robustness: return 1; + case VK_KHR_workgroup_memory_explicit_layout: return 1; + case VK_KHR_copy_commands2: return 1; + case VK_EXT_image_compression_control: return 1; + case VK_EXT_attachment_feedback_loop_layout: return 1; + case VK_EXT_4444_formats: return 1; + case VK_EXT_device_fault: return 1; + case VK_ARM_rasterization_order_attachment_access: return 1; + case VK_EXT_rgba10x6_formats: return 1; + case VK_NV_acquire_winrt_display: return 1; + case VK_EXT_directfb_surface: return 1; + case VK_VALVE_mutable_descriptor_type: return 1; + case VK_EXT_vertex_input_dynamic_state: return 1; + case VK_EXT_physical_device_drm: return 1; + case VK_EXT_device_address_binding_report: return 2; + case VK_EXT_depth_clip_control: return 1; + case VK_EXT_primitive_topology_list_restart: return 1; + case VK_KHR_format_feature_flags2: return 1; + case VK_EXT_present_mode_fifo_latest_ready: return 1; + case VK_FUCHSIA_external_memory: return 2; + case VK_FUCHSIA_external_semaphore: return 2; + case VK_FUCHSIA_buffer_collection: return 2; + case VK_HUAWEI_subpass_shading: return 2; + case VK_HUAWEI_invocation_mask: return 2; + case VK_NV_external_memory_rdma: return 1; + case VK_EXT_pipeline_properties: return 1; + case VK_EXT_frame_boundary: return 1; + case VK_EXT_multisampled_render_to_single_sampled: return 2; + case VK_EXT_extended_dynamic_state2: return 1; + case VK_QNX_screen_surface: return 1; + case VK_EXT_color_write_enable: return 1; + case VK_EXT_primitives_generated_query: return 1; + case VK_KHR_ray_tracing_maintenance1: return 1; + case VK_KHR_shader_untyped_pointers: return 1; + case VK_EXT_global_priority_query: return 2; + case VK_VALVE_video_encode_rgb_conversion: return 2; + case VK_EXT_image_view_min_lod: return 1; + case VK_EXT_multi_draw: return 1; + case VK_EXT_image_2d_view_of_3d: return 2; + case VK_EXT_shader_tile_image: return 0; + case VK_EXT_opacity_micromap: return 2; + case VK_NV_displacement_micromap: return 1; + case VK_HUAWEI_cluster_culling_shader: return 1; + case VK_EXT_border_color_swizzle: return 1; + case VK_EXT_pageable_device_local_memory: return 1; + case VK_KHR_maintenance4: return 0; + case VK_ARM_shader_core_properties: return 0; + case VK_KHR_shader_subgroup_rotate: return 1; + case VK_ARM_scheduling_controls: return 1; + case VK_EXT_image_sliced_view_of_3d: return 2; + case VK_VALVE_descriptor_set_host_mapping: return 1; + case VK_EXT_depth_clamp_zero_one: return 1; + case VK_EXT_non_seamless_cube_map: return 1; + case VK_ARM_render_pass_striped: return 2; + case VK_QCOM_fragment_density_map_offset: return 2; + case VK_NV_copy_memory_indirect: return 2; + case VK_NV_memory_decompression: return 2; + case VK_NV_device_generated_commands_compute: return 1; + case VK_NV_ray_tracing_linear_swept_spheres: return 1; + case VK_NV_linear_color_attachment: return 1; + case VK_GOOGLE_surfaceless_query: return 1; + case VK_KHR_shader_maximal_reconvergence: return 0; + case VK_EXT_image_compression_control_swapchain: return 1; + case VK_QCOM_image_processing: return 1; + case VK_EXT_nested_command_buffer: return 1; + case VK_OHOS_external_memory: return 4; + case VK_EXT_external_memory_acquire_unmodified: return 1; + case VK_EXT_extended_dynamic_state3: return 1; + case VK_EXT_subpass_merge_feedback: return 1; + case VK_ARM_tensors: return 0; + case VK_EXT_shader_module_identifier: return 2; + case VK_EXT_rasterization_order_attachment_access: return 1; + case VK_NV_optical_flow: return 3; + case VK_EXT_legacy_dithering: return 1; + case VK_EXT_pipeline_protected_access: return 1; + case VK_ANDROID_external_format_resolve: return 1; + case VK_KHR_maintenance5: return 1; + case VK_AMD_anti_lag: return 1; + case VK_AMDX_dense_geometry_format: return 2; + case VK_KHR_present_id2: return 3; + case VK_KHR_present_wait2: return 4; + case VK_KHR_ray_tracing_position_fetch: return 1; + case VK_EXT_shader_object: return 2; + case VK_KHR_pipeline_binary: return 1; + case VK_QCOM_tile_properties: return 1; + case VK_SEC_amigo_profiling: return 1; + case VK_KHR_surface_maintenance1: return 2; + case VK_KHR_swapchain_maintenance1: return 3; + case VK_QCOM_multiview_per_view_viewports: return 1; + case VK_NV_ray_tracing_invocation_reorder: return 1; + case VK_NV_cooperative_vector: return 1; + case VK_NV_extended_sparse_address_space: return 1; + case VK_EXT_mutable_descriptor_type: return 1; + case VK_EXT_legacy_vertex_attributes: return 1; + case VK_ARM_shader_core_builtins: return 1; + case VK_EXT_pipeline_library_group_handles: return 2; + case VK_EXT_dynamic_rendering_unused_attachments: return 2; + case VK_NV_low_latency2: return 3; + case VK_KHR_cooperative_matrix: return 1; + case VK_ARM_data_graph: return 2; + case VK_QCOM_multiview_per_view_render_areas: return 1; + case VK_KHR_compute_shader_derivatives: return 1; + case VK_KHR_video_decode_av1: return 1; + case VK_KHR_video_encode_av1: return 1; + case VK_KHR_video_decode_vp9: return 1; + case VK_KHR_video_maintenance1: return 1; + case VK_NV_per_stage_descriptor_set: return 1; + case VK_QCOM_image_processing2: return 1; + case VK_QCOM_filter_cubic_weights: return 1; + case VK_QCOM_ycbcr_degamma: return 1; + case VK_QCOM_filter_cubic_clamp: return 2; + case VK_EXT_attachment_feedback_loop_dynamic_state: return 2; + case VK_KHR_vertex_attribute_divisor: return 1; + case VK_KHR_unified_image_layouts: return 1; + case VK_KHR_shader_float_controls2: return 1; + case VK_QNX_external_memory_screen_buffer: return 4; + case VK_MSFT_layered_driver: return 1; + case VK_KHR_index_type_uint8: return 1; + case VK_KHR_line_rasterization: return 1; + case VK_KHR_calibrated_timestamps: return 1; + case VK_KHR_shader_expect_assume: return 1; + case VK_KHR_maintenance6: return 0; + case VK_NV_descriptor_pool_overallocation: return 0; + case VK_QCOM_tile_memory_heap: return 2; + case VK_KHR_copy_memory_indirect: return 2; + case VK_EXT_memory_decompression: return 2; + case VK_NV_display_stereo: return 2; + case VK_KHR_video_encode_intra_refresh: return 1; + case VK_KHR_video_encode_quantization_map: return 2; + case VK_NV_raw_access_chains: return 1; + case VK_KHR_shader_relaxed_extended_instruction: return 1; + case VK_NV_command_buffer_inheritance: return 1; + case VK_KHR_maintenance7: return 0; + case VK_NV_shader_atomic_float16_vector: return 1; + case VK_EXT_shader_replicated_composites: return 1; + case VK_EXT_shader_float8: return 1; + case VK_NV_ray_tracing_validation: return 1; + case VK_NV_cluster_acceleration_structure: return 1; + case VK_NV_partitioned_acceleration_structure: return 1; + case VK_EXT_device_generated_commands: return 2; + case VK_KHR_maintenance8: return 0; + case VK_MESA_image_alignment_control: return 1; + case VK_KHR_shader_fma: return 1; + case VK_EXT_ray_tracing_invocation_reorder: return 1; + case VK_EXT_depth_clamp_control: return 1; + case VK_KHR_maintenance9: return 1; + case VK_KHR_video_maintenance2: return 1; + case VK_OHOS_surface: return 1; + case VK_HUAWEI_hdr_vivid: return 3; + case VK_NV_cooperative_matrix2: return 1; + case VK_ARM_pipeline_opacity_micromap: return 1; + case VK_EXT_external_memory_metal: return 1; + case VK_KHR_depth_clamp_zero_one: return 1; + case VK_ARM_performance_counters_by_region: return 1; + case VK_EXT_vertex_attribute_robustness: return 1; + case VK_ARM_format_pack: return 1; + case VK_VALVE_fragment_density_map_layered: return 2; + case VK_KHR_robustness2: return 1; + case VK_NV_present_metering: return 1; + case VK_EXT_fragment_density_map_offset: return 4; + case VK_EXT_zero_initialize_device_memory: return 1; + case VK_KHR_present_mode_fifo_latest_ready: return 1; + case VK_EXT_shader_64bit_indexing: return 1; + case VK_EXT_custom_resolve: return 1; + case VK_QCOM_data_graph_model: return 1; + case VK_KHR_maintenance10: return 1; + case VK_SEC_pipeline_cache_incremental_mode: return 1; + case VK_EXT_shader_uniform_buffer_unsized_array: return 1; + default: return default; + } + } + } + + public VulkanExtension GetDependency(int idx) + { + switch (this) + { + case VK_KHR_swapchain: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_display: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_display_swapchain: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_xlib_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_xcb_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_wayland_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_android_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_win32_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_debug_marker: + switch (idx) + { + case 0: return VK_EXT_debug_report; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_queue: + switch (idx) + { + case 0: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_decode_queue: + switch (idx) + { + case 0: return VK_KHR_video_queue; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_transform_feedback: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_h264: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_h265: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_decode_h264: + switch (idx) + { + case 0: return VK_KHR_video_decode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_texture_gather_bias_lod: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_dynamic_rendering: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_depth_stencil_resolve; + default: Runtime.FatalError("Index out of range"); + } + case VK_GGP_stream_descriptor_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_corner_sampled_image: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_multiview: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_external_memory: + switch (idx) + { + case 0: return VK_NV_external_memory_capabilities; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_external_memory_win32: + switch (idx) + { + case 0: return VK_NV_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_win32_keyed_mutex: + switch (idx) + { + case 0: return VK_NV_external_memory_win32; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_device_group: + switch (idx) + { + case 0: return VK_KHR_device_group_creation; + default: Runtime.FatalError("Index out of range"); + } + case VK_NN_vi_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_texture_compression_astc_hdr: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_astc_decode_mode: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pipeline_robustness: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_memory_capabilities: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_memory: + switch (idx) + { + case 0: return VK_KHR_external_memory_capabilities; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_memory_win32: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_memory_fd: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_win32_keyed_mutex: + switch (idx) + { + case 0: return VK_KHR_external_memory_win32; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_semaphore_capabilities: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_semaphore: + switch (idx) + { + case 0: return VK_KHR_external_semaphore_capabilities; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_semaphore_win32: + switch (idx) + { + case 0: return VK_KHR_external_semaphore; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_semaphore_fd: + switch (idx) + { + case 0: return VK_KHR_external_semaphore; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_push_descriptor: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_conditional_rendering: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_float16_int8: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_16bit_storage: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_storage_buffer_storage_class; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_incremental_present: + switch (idx) + { + case 0: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_direct_mode_display: + switch (idx) + { + case 0: return VK_KHR_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_acquire_xlib_display: + switch (idx) + { + case 0: return VK_EXT_direct_mode_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_display_surface_counter: + switch (idx) + { + case 0: return VK_KHR_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_display_control: + switch (idx) + { + case 0: return VK_EXT_display_surface_counter; + case 1: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_GOOGLE_display_timing: + switch (idx) + { + case 0: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_NVX_multiview_per_view_attributes: + switch (idx) + { + case 0: return VK_KHR_multiview; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_discard_rectangles: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_conservative_rasterization: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_depth_clip_enable: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_swapchain_colorspace: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_hdr_metadata: + switch (idx) + { + case 0: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_imageless_framebuffer: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_maintenance2; + case 2: return VK_KHR_image_format_list; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_create_renderpass2: + switch (idx) + { + case 0: return VK_KHR_multiview; + case 1: return VK_KHR_maintenance2; + default: Runtime.FatalError("Index out of range"); + } + case VK_IMG_relaxed_line_rasterization: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shared_presentable_image: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_get_surface_capabilities2; + case 2: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_fence_capabilities: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_fence: + switch (idx) + { + case 0: return VK_KHR_external_fence_capabilities; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_fence_win32: + switch (idx) + { + case 0: return VK_KHR_external_fence; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_external_fence_fd: + switch (idx) + { + case 0: return VK_KHR_external_fence; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_performance_query: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_get_surface_capabilities2: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_variable_pointers: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_storage_buffer_storage_class; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_get_display_properties2: + switch (idx) + { + case 0: return VK_KHR_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_MVK_ios_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_MVK_macos_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_external_memory_dma_buf: + switch (idx) + { + case 0: return VK_KHR_external_memory_fd; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_queue_family_foreign: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_dedicated_allocation: + switch (idx) + { + case 0: return VK_KHR_get_memory_requirements2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ANDROID_external_memory_android_hardware_buffer: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + case 1: return VK_KHR_external_memory; + case 2: return VK_KHR_dedicated_allocation; + case 3: return VK_EXT_queue_family_foreign; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_sampler_filter_minmax: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMDX_shader_enqueue: + switch (idx) + { + case 0: return VK_KHR_synchronization2; + case 1: return VK_KHR_spirv_1_4; + case 2: return VK_EXT_extended_dynamic_state; + case 3: return VK_KHR_maintenance5; + case 4: return VK_KHR_pipeline_library; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_inline_uniform_block: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_maintenance1; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_bfloat16: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_sample_locations: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_blend_operation_advanced: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_acceleration_structure: + switch (idx) + { + case 0: return VK_EXT_descriptor_indexing; + case 1: return VK_KHR_buffer_device_address; + case 2: return VK_KHR_deferred_host_operations; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_ray_tracing_pipeline: + switch (idx) + { + case 0: return VK_KHR_spirv_1_4; + case 1: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_ray_query: + switch (idx) + { + case 0: return VK_KHR_spirv_1_4; + case 1: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_sampler_ycbcr_conversion: + switch (idx) + { + case 0: return VK_KHR_maintenance1; + case 1: return VK_KHR_bind_memory2; + case 2: return VK_KHR_get_memory_requirements2; + case 3: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_drm_format_modifier: + switch (idx) + { + case 0: return VK_KHR_bind_memory2; + case 1: return VK_KHR_get_physical_device_properties2; + case 2: return VK_KHR_sampler_ycbcr_conversion; + case 3: return VK_KHR_image_format_list; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_descriptor_indexing: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_maintenance3; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_portability_subset: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_shading_rate_image: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_ray_tracing: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_get_memory_requirements2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_representative_fragment_test: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_maintenance3: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_8bit_storage: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_storage_buffer_storage_class; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_external_memory_host: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_atomic_int64: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_clock: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_calibrated_timestamps: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_shader_core_properties: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_decode_h265: + switch (idx) + { + case 0: return VK_KHR_video_decode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_global_priority: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_vertex_attribute_divisor: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_GGP_frame_token: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_GGP_stream_descriptor_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_driver_properties: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_float_controls: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_depth_stencil_resolve: + switch (idx) + { + case 0: return VK_KHR_create_renderpass2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_swapchain_mutable_format: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_maintenance2; + case 2: return VK_KHR_image_format_list; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_compute_shader_derivatives: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_mesh_shader: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_fragment_shader_barycentric: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_shader_image_footprint: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_scissor_exclusive: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_device_diagnostic_checkpoints: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_timeline_semaphore: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_present_timing: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_present_id2; + case 2: return VK_KHR_get_surface_capabilities2; + case 3: return VK_KHR_calibrated_timestamps; + default: Runtime.FatalError("Index out of range"); + } + case VK_INTEL_shader_integer_functions2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_vulkan_memory_model: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pci_bus_info: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_display_native_hdr: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_get_surface_capabilities2; + case 2: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_FUCHSIA_imagepipe_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_terminate_invocation: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_metal_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_fragment_density_map: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_scalar_block_layout: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_fragment_shading_rate: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_create_renderpass2; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_shader_core_properties2: + switch (idx) + { + case 0: return VK_AMD_shader_core_properties; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_device_coherent_memory: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_dynamic_rendering_local_read: + switch (idx) + { + case 0: return VK_KHR_dynamic_rendering; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_image_atomic_int64: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_quad_control: + switch (idx) + { + case 0: return VK_KHR_vulkan_memory_model; + case 1: return VK_KHR_shader_maximal_reconvergence; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_spirv_1_4: + switch (idx) + { + case 0: return VK_KHR_shader_float_controls; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_memory_budget: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_memory_priority: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_surface_protected_capabilities: + switch (idx) + { + case 0: return VK_KHR_get_surface_capabilities2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_dedicated_allocation_image_aliasing: + switch (idx) + { + case 0: return VK_KHR_dedicated_allocation; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_separate_depth_stencil_layouts: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_create_renderpass2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_buffer_device_address: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_present_wait: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_present_id; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_cooperative_matrix: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_coverage_reduction_mode: + switch (idx) + { + case 0: return VK_NV_framebuffer_mixed_samples; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_fragment_shader_interlock: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_ycbcr_image_arrays: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_uniform_buffer_standard_layout: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_provoking_vertex: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_full_screen_exclusive: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_surface; + case 2: return VK_KHR_get_surface_capabilities2; + case 3: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_headless_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_buffer_device_address: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_device_group; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_line_rasterization: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_atomic_float: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_host_query_reset: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_index_type_uint8: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_extended_dynamic_state: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_pipeline_executable_properties: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_host_image_copy: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_copy_commands2; + case 2: return VK_KHR_format_feature_flags2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_map_memory_placed: + switch (idx) + { + case 0: return VK_KHR_map_memory2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_atomic_float2: + switch (idx) + { + case 0: return VK_EXT_shader_atomic_float; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_surface_maintenance1: + switch (idx) + { + case 0: return VK_KHR_surface; + case 1: return VK_KHR_get_surface_capabilities2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_swapchain_maintenance1: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_EXT_surface_maintenance1; + case 2: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_demote_to_helper_invocation: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_device_generated_commands: + switch (idx) + { + case 0: return VK_KHR_buffer_device_address; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_inherited_viewport_scissor: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_integer_dot_product: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_texel_buffer_alignment: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_depth_bias_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_device_memory_report: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_acquire_drm_display: + switch (idx) + { + case 0: return VK_EXT_direct_mode_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_robustness2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_custom_border_color: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_present_barrier: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_surface; + case 2: return VK_KHR_get_surface_capabilities2; + case 3: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_present_id: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_private_data: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pipeline_creation_cache_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_queue: + switch (idx) + { + case 0: return VK_KHR_video_queue; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_device_diagnostics_config: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_cuda_kernel_launch: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_tile_shading: + switch (idx) + { + case 0: return VK_QCOM_tile_properties; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_synchronization2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_descriptor_buffer: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_buffer_device_address; + case 2: return VK_EXT_descriptor_indexing; + case 3: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_graphics_pipeline_library: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_pipeline_library; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_shader_early_and_late_fragment_tests: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_fragment_shader_barycentric: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_zero_initialize_workgroup_memory: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_fragment_shading_rate_enums: + switch (idx) + { + case 0: return VK_KHR_fragment_shading_rate; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_ray_tracing_motion_blur: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_mesh_shader: + switch (idx) + { + case 0: return VK_KHR_spirv_1_4; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_ycbcr_2plane_444_formats: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_fragment_density_map2: + switch (idx) + { + case 0: return VK_EXT_fragment_density_map; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_rotated_copy_commands: + switch (idx) + { + case 0: return VK_KHR_copy_commands2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_robustness: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_workgroup_memory_explicit_layout: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_copy_commands2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_compression_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_attachment_feedback_loop_layout: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_4444_formats: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_device_fault: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_rasterization_order_attachment_access: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_rgba10x6_formats: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_acquire_winrt_display: + switch (idx) + { + case 0: return VK_EXT_direct_mode_display; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_directfb_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_VALVE_mutable_descriptor_type: + switch (idx) + { + case 0: return VK_KHR_maintenance3; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_vertex_input_dynamic_state: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_physical_device_drm: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_device_address_binding_report: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_EXT_debug_utils; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_depth_clip_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_primitive_topology_list_restart: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_format_feature_flags2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_present_mode_fifo_latest_ready: + switch (idx) + { + case 0: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_FUCHSIA_external_memory: + switch (idx) + { + case 0: return VK_KHR_external_memory_capabilities; + case 1: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_FUCHSIA_external_semaphore: + switch (idx) + { + case 0: return VK_KHR_external_semaphore_capabilities; + case 1: return VK_KHR_external_semaphore; + default: Runtime.FatalError("Index out of range"); + } + case VK_FUCHSIA_buffer_collection: + switch (idx) + { + case 0: return VK_FUCHSIA_external_memory; + case 1: return VK_KHR_sampler_ycbcr_conversion; + default: Runtime.FatalError("Index out of range"); + } + case VK_HUAWEI_subpass_shading: + switch (idx) + { + case 0: return VK_KHR_create_renderpass2; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_HUAWEI_invocation_mask: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_external_memory_rdma: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pipeline_properties: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_frame_boundary: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_multisampled_render_to_single_sampled: + switch (idx) + { + case 0: return VK_KHR_create_renderpass2; + case 1: return VK_KHR_depth_stencil_resolve; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_extended_dynamic_state2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QNX_screen_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_color_write_enable: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_primitives_generated_query: + switch (idx) + { + case 0: return VK_EXT_transform_feedback; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_ray_tracing_maintenance1: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_untyped_pointers: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_global_priority_query: + switch (idx) + { + case 0: return VK_EXT_global_priority; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_VALVE_video_encode_rgb_conversion: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + case 1: return VK_KHR_sampler_ycbcr_conversion; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_view_min_lod: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_multi_draw: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_2d_view_of_3d: + switch (idx) + { + case 0: return VK_KHR_maintenance1; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_opacity_micromap: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_displacement_micromap: + switch (idx) + { + case 0: return VK_EXT_opacity_micromap; + default: Runtime.FatalError("Index out of range"); + } + case VK_HUAWEI_cluster_culling_shader: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_border_color_swizzle: + switch (idx) + { + case 0: return VK_EXT_custom_border_color; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pageable_device_local_memory: + switch (idx) + { + case 0: return VK_EXT_memory_priority; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_subgroup_rotate: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_scheduling_controls: + switch (idx) + { + case 0: return VK_ARM_shader_core_builtins; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_sliced_view_of_3d: + switch (idx) + { + case 0: return VK_KHR_maintenance1; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_VALVE_descriptor_set_host_mapping: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_depth_clamp_zero_one: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_non_seamless_cube_map: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_render_pass_striped: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_fragment_density_map_offset: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_EXT_fragment_density_map; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_copy_memory_indirect: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_buffer_device_address; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_memory_decompression: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_buffer_device_address; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_device_generated_commands_compute: + switch (idx) + { + case 0: return VK_NV_device_generated_commands; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_ray_tracing_linear_swept_spheres: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_linear_color_attachment: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_GOOGLE_surfaceless_query: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_image_compression_control_swapchain: + switch (idx) + { + case 0: return VK_EXT_image_compression_control; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_image_processing: + switch (idx) + { + case 0: return VK_KHR_format_feature_flags2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_nested_command_buffer: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_OHOS_external_memory: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + case 1: return VK_KHR_external_memory; + case 2: return VK_KHR_dedicated_allocation; + case 3: return VK_EXT_queue_family_foreign; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_external_memory_acquire_unmodified: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_extended_dynamic_state3: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_subpass_merge_feedback: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_module_identifier: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_EXT_pipeline_creation_cache_control; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_rasterization_order_attachment_access: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_optical_flow: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_format_feature_flags2; + case 2: return VK_KHR_synchronization2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_legacy_dithering: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pipeline_protected_access: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ANDROID_external_format_resolve: + switch (idx) + { + case 0: return VK_ANDROID_external_memory_android_hardware_buffer; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_maintenance5: + switch (idx) + { + case 0: return VK_KHR_dynamic_rendering; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMD_anti_lag: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_AMDX_dense_geometry_format: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + case 1: return VK_KHR_maintenance5; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_present_id2: + switch (idx) + { + case 0: return VK_KHR_get_surface_capabilities2; + case 1: return VK_KHR_surface; + case 2: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_present_wait2: + switch (idx) + { + case 0: return VK_KHR_get_surface_capabilities2; + case 1: return VK_KHR_surface; + case 2: return VK_KHR_swapchain; + case 3: return VK_KHR_present_id2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_ray_tracing_position_fetch: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_object: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_dynamic_rendering; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_pipeline_binary: + switch (idx) + { + case 0: return VK_KHR_maintenance5; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_tile_properties: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_SEC_amigo_profiling: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_surface_maintenance1: + switch (idx) + { + case 0: return VK_KHR_surface; + case 1: return VK_KHR_get_surface_capabilities2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_swapchain_maintenance1: + switch (idx) + { + case 0: return VK_KHR_swapchain; + case 1: return VK_KHR_surface_maintenance1; + case 2: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_multiview_per_view_viewports: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_ray_tracing_invocation_reorder: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_cooperative_vector: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_extended_sparse_address_space: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_mutable_descriptor_type: + switch (idx) + { + case 0: return VK_KHR_maintenance3; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_legacy_vertex_attributes: + switch (idx) + { + case 0: return VK_EXT_vertex_input_dynamic_state; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_shader_core_builtins: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_pipeline_library_group_handles: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + case 1: return VK_KHR_pipeline_library; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_dynamic_rendering_unused_attachments: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_dynamic_rendering; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_low_latency2: + switch (idx) + { + case 0: return VK_KHR_timeline_semaphore; + case 1: return VK_KHR_present_id; + case 2: return VK_KHR_present_id2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_cooperative_matrix: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_data_graph: + switch (idx) + { + case 0: return VK_KHR_maintenance5; + case 1: return VK_KHR_deferred_host_operations; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_multiview_per_view_render_areas: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_compute_shader_derivatives: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_decode_av1: + switch (idx) + { + case 0: return VK_KHR_video_decode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_av1: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_decode_vp9: + switch (idx) + { + case 0: return VK_KHR_video_decode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_maintenance1: + switch (idx) + { + case 0: return VK_KHR_video_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_per_stage_descriptor_set: + switch (idx) + { + case 0: return VK_KHR_maintenance6; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_image_processing2: + switch (idx) + { + case 0: return VK_QCOM_image_processing; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_filter_cubic_weights: + switch (idx) + { + case 0: return VK_EXT_filter_cubic; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_ycbcr_degamma: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_filter_cubic_clamp: + switch (idx) + { + case 0: return VK_EXT_filter_cubic; + case 1: return VK_EXT_sampler_filter_minmax; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_attachment_feedback_loop_dynamic_state: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_EXT_attachment_feedback_loop_layout; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_vertex_attribute_divisor: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_unified_image_layouts: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_float_controls2: + switch (idx) + { + case 0: return VK_KHR_shader_float_controls; + default: Runtime.FatalError("Index out of range"); + } + case VK_QNX_external_memory_screen_buffer: + switch (idx) + { + case 0: return VK_KHR_sampler_ycbcr_conversion; + case 1: return VK_KHR_external_memory; + case 2: return VK_KHR_dedicated_allocation; + case 3: return VK_EXT_queue_family_foreign; + default: Runtime.FatalError("Index out of range"); + } + case VK_MSFT_layered_driver: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_index_type_uint8: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_line_rasterization: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_calibrated_timestamps: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_expect_assume: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_tile_memory_heap: + switch (idx) + { + case 0: return VK_KHR_get_memory_requirements2; + case 1: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_copy_memory_indirect: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_buffer_device_address; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_memory_decompression: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_buffer_device_address; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_display_stereo: + switch (idx) + { + case 0: return VK_KHR_display; + case 1: return VK_KHR_get_display_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_intra_refresh: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_encode_quantization_map: + switch (idx) + { + case 0: return VK_KHR_video_encode_queue; + case 1: return VK_KHR_format_feature_flags2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_raw_access_chains: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_relaxed_extended_instruction: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_command_buffer_inheritance: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_shader_atomic_float16_vector: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_replicated_composites: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_float8: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_ray_tracing_validation: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_cluster_acceleration_structure: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_partitioned_acceleration_structure: + switch (idx) + { + case 0: return VK_KHR_acceleration_structure; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_device_generated_commands: + switch (idx) + { + case 0: return VK_KHR_buffer_device_address; + case 1: return VK_KHR_maintenance5; + default: Runtime.FatalError("Index out of range"); + } + case VK_MESA_image_alignment_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_shader_fma: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_ray_tracing_invocation_reorder: + switch (idx) + { + case 0: return VK_KHR_ray_tracing_pipeline; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_depth_clamp_control: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_maintenance9: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_video_maintenance2: + switch (idx) + { + case 0: return VK_KHR_video_queue; + default: Runtime.FatalError("Index out of range"); + } + case VK_OHOS_surface: + switch (idx) + { + case 0: return VK_KHR_surface; + default: Runtime.FatalError("Index out of range"); + } + case VK_HUAWEI_hdr_vivid: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_KHR_swapchain; + case 2: return VK_EXT_hdr_metadata; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_cooperative_matrix2: + switch (idx) + { + case 0: return VK_KHR_cooperative_matrix; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_pipeline_opacity_micromap: + switch (idx) + { + case 0: return VK_EXT_opacity_micromap; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_external_memory_metal: + switch (idx) + { + case 0: return VK_KHR_external_memory; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_depth_clamp_zero_one: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_performance_counters_by_region: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_vertex_attribute_robustness: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_ARM_format_pack: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_VALVE_fragment_density_map_layered: + switch (idx) + { + case 0: return VK_KHR_maintenance5; + case 1: return VK_EXT_fragment_density_map; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_robustness2: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_NV_present_metering: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_fragment_density_map_offset: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + case 1: return VK_EXT_fragment_density_map; + case 2: return VK_KHR_create_renderpass2; + case 3: return VK_KHR_dynamic_rendering; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_zero_initialize_device_memory: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_present_mode_fifo_latest_ready: + switch (idx) + { + case 0: return VK_KHR_swapchain; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_64bit_indexing: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_custom_resolve: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_QCOM_data_graph_model: + switch (idx) + { + case 0: return VK_ARM_data_graph; + default: Runtime.FatalError("Index out of range"); + } + case VK_KHR_maintenance10: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_SEC_pipeline_cache_incremental_mode: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + case VK_EXT_shader_uniform_buffer_unsized_array: + switch (idx) + { + case 0: return VK_KHR_get_physical_device_properties2; + default: Runtime.FatalError("Index out of range"); + } + default: + Runtime.FatalError("Index out of range"); + } + } } enum VulkanFeature { - case robustBufferAccess; + case robustBufferAccess = 1; case fullDrawIndexUint32; case imageCubeArray; case independentBlend; @@ -3393,463 +6513,463 @@ enum VulkanFeature } } - public VkStructureType ExtensionStruct + public VulkanExtension Extension { get { switch (this) { - case deviceGeneratedCommands: return VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType; - case deviceGeneratedCompute: return VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType; - case deviceGeneratedComputePipelines: return VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType; - case deviceGeneratedComputeCaptureReplay: return VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType; - case privateData: return VkPhysicalDevicePrivateDataFeatures.SType; - case clusterAccelerationStructure: return VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.SType; - case variablePointersStorageBuffer: return VkPhysicalDeviceVariablePointersFeatures.SType; - case variablePointers: return VkPhysicalDeviceVariablePointersFeatures.SType; - case multiview: return VkPhysicalDeviceMultiviewFeatures.SType; - case multiviewGeometryShader: return VkPhysicalDeviceMultiviewFeatures.SType; - case multiviewTessellationShader: return VkPhysicalDeviceMultiviewFeatures.SType; - case presentId: return VkPhysicalDevicePresentIdFeaturesKHR.SType; - case presentId2: return VkPhysicalDevicePresentId2FeaturesKHR.SType; - case presentWait: return VkPhysicalDevicePresentWaitFeaturesKHR.SType; - case presentWait2: return VkPhysicalDevicePresentWait2FeaturesKHR.SType; - case presentTiming: return VkPhysicalDevicePresentTimingFeaturesEXT.SType; - case presentAtAbsoluteTime: return VkPhysicalDevicePresentTimingFeaturesEXT.SType; - case presentAtRelativeTime: return VkPhysicalDevicePresentTimingFeaturesEXT.SType; - case storageBuffer16BitAccess: return VkPhysicalDevice16BitStorageFeatures.SType; - case uniformAndStorageBuffer16BitAccess: return VkPhysicalDevice16BitStorageFeatures.SType; - case storagePushConstant16: return VkPhysicalDevice16BitStorageFeatures.SType; - case storageInputOutput16: return VkPhysicalDevice16BitStorageFeatures.SType; - case shaderSubgroupExtendedTypes: return VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.SType; - case samplerYcbcrConversion: return VkPhysicalDeviceSamplerYcbcrConversionFeatures.SType; - case protectedMemory: return VkPhysicalDeviceProtectedMemoryFeatures.SType; - case advancedBlendCoherentOperations: return VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.SType; - case multiDraw: return VkPhysicalDeviceMultiDrawFeaturesEXT.SType; - case inlineUniformBlock: return VkPhysicalDeviceInlineUniformBlockFeatures.SType; - case descriptorBindingInlineUniformBlockUpdateAfterBind: return VkPhysicalDeviceInlineUniformBlockFeatures.SType; - case maintenance4: return VkPhysicalDeviceMaintenance4Features.SType; - case maintenance5: return VkPhysicalDeviceMaintenance5Features.SType; - case maintenance6: return VkPhysicalDeviceMaintenance6Features.SType; - case maintenance7: return VkPhysicalDeviceMaintenance7FeaturesKHR.SType; - case maintenance8: return VkPhysicalDeviceMaintenance8FeaturesKHR.SType; - case maintenance9: return VkPhysicalDeviceMaintenance9FeaturesKHR.SType; - case maintenance10: return VkPhysicalDeviceMaintenance10FeaturesKHR.SType; - case shaderDrawParameters: return VkPhysicalDeviceShaderDrawParametersFeatures.SType; - case shaderFloat16: return VkPhysicalDeviceShaderFloat16Int8Features.SType; - case shaderInt8: return VkPhysicalDeviceShaderFloat16Int8Features.SType; - case hostQueryReset: return VkPhysicalDeviceHostQueryResetFeatures.SType; - case globalPriorityQuery: return VkPhysicalDeviceGlobalPriorityQueryFeatures.SType; - case deviceMemoryReport: return VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.SType; - case shaderInputAttachmentArrayDynamicIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderUniformTexelBufferArrayDynamicIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderStorageTexelBufferArrayDynamicIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderUniformBufferArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderSampledImageArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderStorageBufferArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderStorageImageArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderInputAttachmentArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderUniformTexelBufferArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case shaderStorageTexelBufferArrayNonUniformIndexing: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingUniformBufferUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingSampledImageUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingStorageImageUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingStorageBufferUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingUniformTexelBufferUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingStorageTexelBufferUpdateAfterBind: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingUpdateUnusedWhilePending: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingPartiallyBound: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case descriptorBindingVariableDescriptorCount: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case runtimeDescriptorArray: return VkPhysicalDeviceDescriptorIndexingFeatures.SType; - case timelineSemaphore: return VkPhysicalDeviceTimelineSemaphoreFeatures.SType; - case storageBuffer8BitAccess: return VkPhysicalDevice8BitStorageFeatures.SType; - case uniformAndStorageBuffer8BitAccess: return VkPhysicalDevice8BitStorageFeatures.SType; - case storagePushConstant8: return VkPhysicalDevice8BitStorageFeatures.SType; - case conditionalRendering: return VkPhysicalDeviceConditionalRenderingFeaturesEXT.SType; - case inheritedConditionalRendering: return VkPhysicalDeviceConditionalRenderingFeaturesEXT.SType; - case vulkanMemoryModel: return VkPhysicalDeviceVulkanMemoryModelFeatures.SType; - case vulkanMemoryModelDeviceScope: return VkPhysicalDeviceVulkanMemoryModelFeatures.SType; - case vulkanMemoryModelAvailabilityVisibilityChains: return VkPhysicalDeviceVulkanMemoryModelFeatures.SType; - case shaderBufferInt64Atomics: return VkPhysicalDeviceShaderAtomicInt64Features.SType; - case shaderSharedInt64Atomics: return VkPhysicalDeviceShaderAtomicInt64Features.SType; - case shaderBufferFloat32Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderBufferFloat32AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderBufferFloat64Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderBufferFloat64AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderSharedFloat32Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderSharedFloat32AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderSharedFloat64Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderSharedFloat64AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderImageFloat32Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderImageFloat32AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case sparseImageFloat32Atomics: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case sparseImageFloat32AtomicAdd: return VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType; - case shaderBufferFloat16Atomics: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderBufferFloat16AtomicAdd: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderBufferFloat16AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderBufferFloat32AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderBufferFloat64AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderSharedFloat16Atomics: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderSharedFloat16AtomicAdd: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderSharedFloat16AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderSharedFloat32AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderSharedFloat64AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case shaderImageFloat32AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case sparseImageFloat32AtomicMinMax: return VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType; - case vertexAttributeInstanceRateDivisor: return VkPhysicalDeviceVertexAttributeDivisorFeatures.SType; - case vertexAttributeInstanceRateZeroDivisor: return VkPhysicalDeviceVertexAttributeDivisorFeatures.SType; - case decodeModeSharedExponent: return VkPhysicalDeviceASTCDecodeFeaturesEXT.SType; - case transformFeedback: return VkPhysicalDeviceTransformFeedbackFeaturesEXT.SType; - case geometryStreams: return VkPhysicalDeviceTransformFeedbackFeaturesEXT.SType; - case representativeFragmentTest: return VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.SType; - case exclusiveScissor: return VkPhysicalDeviceExclusiveScissorFeaturesNV.SType; - case cornerSampledImage: return VkPhysicalDeviceCornerSampledImageFeaturesNV.SType; - case computeDerivativeGroupQuads: return VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType; - case computeDerivativeGroupLinear: return VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType; - case imageFootprint: return VkPhysicalDeviceShaderImageFootprintFeaturesNV.SType; - case dedicatedAllocationImageAliasing: return VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.SType; - case indirectMemoryCopy: return VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType; - case indirectMemoryToImageCopy: return VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType; - case indirectCopy: return VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.SType; - case memoryDecompression: return VkPhysicalDeviceMemoryDecompressionFeaturesEXT.SType; - case shadingRateImage: return VkPhysicalDeviceShadingRateImageFeaturesNV.SType; - case shadingRateCoarseSampleOrder: return VkPhysicalDeviceShadingRateImageFeaturesNV.SType; - case invocationMask: return VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.SType; - case taskShader: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; - case meshShader: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; - case multiviewMeshShader: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; - case primitiveFragmentShadingRateMeshShader: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; - case meshShaderQueries: return VkPhysicalDeviceMeshShaderFeaturesEXT.SType; - case accelerationStructure: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; - case accelerationStructureCaptureReplay: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; - case accelerationStructureIndirectBuild: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; - case accelerationStructureHostCommands: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; - case descriptorBindingAccelerationStructureUpdateAfterBind: return VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType; - case rayTracingPipeline: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; - case rayTracingPipelineShaderGroupHandleCaptureReplay: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; - case rayTracingPipelineShaderGroupHandleCaptureReplayMixed: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; - case rayTracingPipelineTraceRaysIndirect: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; - case rayTraversalPrimitiveCulling: return VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType; - case rayQuery: return VkPhysicalDeviceRayQueryFeaturesKHR.SType; - case rayTracingMaintenance1: return VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType; - case rayTracingPipelineTraceRaysIndirect2: return VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType; - case fragmentDensityMap: return VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType; - case fragmentDensityMapDynamic: return VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType; - case fragmentDensityMapNonSubsampledImages: return VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType; - case fragmentDensityMapDeferred: return VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.SType; - case fragmentDensityMapOffset: return VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.SType; - case scalarBlockLayout: return VkPhysicalDeviceScalarBlockLayoutFeatures.SType; - case uniformBufferStandardLayout: return VkPhysicalDeviceUniformBufferStandardLayoutFeatures.SType; - case depthClipEnable: return VkPhysicalDeviceDepthClipEnableFeaturesEXT.SType; - case memoryPriority: return VkPhysicalDeviceMemoryPriorityFeaturesEXT.SType; - case pageableDeviceLocalMemory: return VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.SType; - case bufferDeviceAddress: return VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType; - case bufferDeviceAddressCaptureReplay: return VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType; - case bufferDeviceAddressMultiDevice: return VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType; - case imagelessFramebuffer: return VkPhysicalDeviceImagelessFramebufferFeatures.SType; - case textureCompressionASTC_HDR: return VkPhysicalDeviceTextureCompressionASTCHDRFeatures.SType; - case cooperativeMatrix: return VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType; - case cooperativeMatrixRobustBufferAccess: return VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType; - case ycbcrImageArrays: return VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.SType; - case presentBarrier: return VkPhysicalDevicePresentBarrierFeaturesNV.SType; - case performanceCounterQueryPools: return VkPhysicalDevicePerformanceQueryFeaturesKHR.SType; - case performanceCounterMultipleQueryPools: return VkPhysicalDevicePerformanceQueryFeaturesKHR.SType; - case coverageReductionMode: return VkPhysicalDeviceCoverageReductionModeFeaturesNV.SType; - case shaderIntegerFunctions2: return VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.SType; - case shaderSubgroupClock: return VkPhysicalDeviceShaderClockFeaturesKHR.SType; - case shaderDeviceClock: return VkPhysicalDeviceShaderClockFeaturesKHR.SType; - case indexTypeUint8: return VkPhysicalDeviceIndexTypeUint8Features.SType; - case shaderSMBuiltins: return VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.SType; - case fragmentShaderSampleInterlock: return VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType; - case fragmentShaderPixelInterlock: return VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType; - case fragmentShaderShadingRateInterlock: return VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType; - case separateDepthStencilLayouts: return VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.SType; - case primitiveTopologyListRestart: return VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType; - case primitiveTopologyPatchListRestart: return VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType; - case pipelineExecutableInfo: return VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.SType; - case shaderDemoteToHelperInvocation: return VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.SType; - case texelBufferAlignment: return VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.SType; - case subgroupSizeControl: return VkPhysicalDeviceSubgroupSizeControlFeatures.SType; - case computeFullSubgroups: return VkPhysicalDeviceSubgroupSizeControlFeatures.SType; - case rectangularLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case bresenhamLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case smoothLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case stippledRectangularLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case stippledBresenhamLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case stippledSmoothLines: return VkPhysicalDeviceLineRasterizationFeatures.SType; - case pipelineCreationCacheControl: return VkPhysicalDevicePipelineCreationCacheControlFeatures.SType; - case robustImageAccess: return VkPhysicalDeviceImageRobustnessFeatures.SType; - case shaderTerminateInvocation: return VkPhysicalDeviceShaderTerminateInvocationFeatures.SType; - case synchronization2: return VkPhysicalDeviceSynchronization2Features.SType; - case shaderZeroInitializeWorkgroupMemory: return VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.SType; - case dynamicRendering: return VkPhysicalDeviceDynamicRenderingFeatures.SType; - case shaderIntegerDotProduct: return VkPhysicalDeviceShaderIntegerDotProductFeatures.SType; - case shaderSubgroupRotate: return VkPhysicalDeviceShaderSubgroupRotateFeatures.SType; - case shaderSubgroupRotateClustered: return VkPhysicalDeviceShaderSubgroupRotateFeatures.SType; - case shaderFloatControls2: return VkPhysicalDeviceShaderFloatControls2Features.SType; - case shaderExpectAssume: return VkPhysicalDeviceShaderExpectAssumeFeatures.SType; - case dynamicRenderingLocalRead: return VkPhysicalDeviceDynamicRenderingLocalReadFeatures.SType; - case pipelineProtectedAccess: return VkPhysicalDevicePipelineProtectedAccessFeatures.SType; - case pipelineRobustness: return VkPhysicalDevicePipelineRobustnessFeatures.SType; - case hostImageCopy: return VkPhysicalDeviceHostImageCopyFeatures.SType; - case deviceCoherentMemory: return VkPhysicalDeviceCoherentMemoryFeaturesAMD.SType; - case customBorderColors: return VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType; - case customBorderColorWithoutFormat: return VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType; - case borderColorSwizzle: return VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType; - case borderColorSwizzleFromImage: return VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType; - case extendedDynamicState: return VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.SType; - case extendedDynamicState2: return VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType; - case extendedDynamicState2LogicOp: return VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType; - case extendedDynamicState2PatchControlPoints: return VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType; - case extendedDynamicState3TessellationDomainOrigin: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3DepthClampEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3PolygonMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3RasterizationSamples: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3SampleMask: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3AlphaToCoverageEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3AlphaToOneEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3LogicOpEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ColorBlendEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ColorBlendEquation: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ColorWriteMask: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3RasterizationStream: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ConservativeRasterizationMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ExtraPrimitiveOverestimationSize: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3DepthClipEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3SampleLocationsEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ColorBlendAdvanced: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ProvokingVertexMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3LineRasterizationMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3LineStippleEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3DepthClipNegativeOneToOne: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ViewportWScalingEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ViewportSwizzle: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageToColorEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageToColorLocation: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageModulationMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageModulationTableEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageModulationTable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3CoverageReductionMode: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3RepresentativeFragmentTestEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case extendedDynamicState3ShadingRateImageEnable: return VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType; - case partitionedAccelerationStructure: return VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.SType; - case diagnosticsConfig: return VkPhysicalDeviceDiagnosticsConfigFeaturesNV.SType; - case shaderSubgroupUniformControlFlow: return VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.SType; - case robustBufferAccess2: return VkPhysicalDeviceRobustness2FeaturesKHR.SType; - case robustImageAccess2: return VkPhysicalDeviceRobustness2FeaturesKHR.SType; - case nullDescriptor: return VkPhysicalDeviceRobustness2FeaturesKHR.SType; - case workgroupMemoryExplicitLayout: return VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType; - case workgroupMemoryExplicitLayoutScalarBlockLayout: return VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType; - case workgroupMemoryExplicitLayout8BitAccess: return VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType; - case workgroupMemoryExplicitLayout16BitAccess: return VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType; - case constantAlphaColorBlendFactors: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case events: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case imageViewFormatReinterpretation: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case imageViewFormatSwizzle: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case imageView2DOn3DImage: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case multisampleArrayImage: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case mutableComparisonSamplers: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case pointPolygons: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case samplerMipLodBias: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case separateStencilMaskRef: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case shaderSampleRateInterpolationFunctions: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case tessellationIsolines: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case tessellationPointMode: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case triangleFans: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case vertexAttributeAccessBeyondStride: return VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType; - case formatA4R4G4B4: return VkPhysicalDevice4444FormatsFeaturesEXT.SType; - case formatA4B4G4R4: return VkPhysicalDevice4444FormatsFeaturesEXT.SType; - case subpassShading: return VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.SType; - case clustercullingShader: return VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.SType; - case multiviewClusterCullingShader: return VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.SType; - case clusterShadingRate: return VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.SType; - case shaderImageInt64Atomics: return VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType; - case sparseImageInt64Atomics: return VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType; - case pipelineFragmentShadingRate: return VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType; - case primitiveFragmentShadingRate: return VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType; - case attachmentFragmentShadingRate: return VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType; - case fragmentShadingRateEnums: return VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType; - case supersampleFragmentShadingRates: return VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType; - case noInvocationFragmentShadingRates: return VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType; - case image2DViewOf3D: return VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType; - case sampler2DViewOf3D: return VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType; - case imageSlicedViewOf3D: return VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.SType; - case attachmentFeedbackLoopDynamicState: return VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.SType; - case legacyVertexAttributes: return VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.SType; - case mutableDescriptorType: return VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.SType; - case depthClipControl: return VkPhysicalDeviceDepthClipControlFeaturesEXT.SType; - case zeroInitializeDeviceMemory: return VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.SType; - case customResolve: return VkPhysicalDeviceCustomResolveFeaturesEXT.SType; - case dynamicGeneratedPipelineLayout: return VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType; - case depthClampControl: return VkPhysicalDeviceDepthClampControlFeaturesEXT.SType; - case vertexInputDynamicState: return VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.SType; - case externalMemoryRDMA: return VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.SType; - case shaderRelaxedExtendedInstruction: return VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.SType; - case colorWriteEnable: return VkPhysicalDeviceColorWriteEnableFeaturesEXT.SType; - case unifiedImageLayouts: return VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType; - case unifiedImageLayoutsVideo: return VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType; - case primitivesGeneratedQuery: return VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType; - case primitivesGeneratedQueryWithRasterizerDiscard: return VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType; - case primitivesGeneratedQueryWithNonZeroStreams: return VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType; - case legacyDithering: return VkPhysicalDeviceLegacyDitheringFeaturesEXT.SType; - case multisampledRenderToSingleSampled: return VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.SType; - case videoMaintenance1: return VkPhysicalDeviceVideoMaintenance1FeaturesKHR.SType; - case videoMaintenance2: return VkPhysicalDeviceVideoMaintenance2FeaturesKHR.SType; - case videoDecodeVP9: return VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.SType; - case videoEncodeQuantizationMap: return VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.SType; - case videoEncodeAV1: return VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.SType; - case inheritedViewportScissor2D: return VkPhysicalDeviceInheritedViewportScissorFeaturesNV.SType; - case ycbcr2plane444Formats: return VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.SType; - case provokingVertexLast: return VkPhysicalDeviceProvokingVertexFeaturesEXT.SType; - case transformFeedbackPreservesProvokingVertex: return VkPhysicalDeviceProvokingVertexFeaturesEXT.SType; - case videoEncodeIntraRefresh: return VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.SType; - case descriptorBuffer: return VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType; - case descriptorBufferCaptureReplay: return VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType; - case descriptorBufferImageLayoutIgnored: return VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType; - case descriptorBufferPushDescriptors: return VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType; - case fragmentShaderBarycentric: return VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.SType; - case shaderFmaFloat16: return VkPhysicalDeviceShaderFmaFeaturesKHR.SType; - case shaderFmaFloat32: return VkPhysicalDeviceShaderFmaFeaturesKHR.SType; - case shaderFmaFloat64: return VkPhysicalDeviceShaderFmaFeaturesKHR.SType; - case rayTracingMotionBlur: return VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType; - case rayTracingMotionBlurPipelineTraceRaysIndirect: return VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType; - case rayTracingValidation: return VkPhysicalDeviceRayTracingValidationFeaturesNV.SType; - case spheres: return VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType; - case linearSweptSpheres: return VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType; - case formatRgba10x6WithoutYCbCrSampler: return VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.SType; - case minLod: return VkPhysicalDeviceImageViewMinLodFeaturesEXT.SType; - case rasterizationOrderColorAttachmentAccess: return VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType; - case rasterizationOrderDepthAttachmentAccess: return VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType; - case rasterizationOrderStencilAttachmentAccess: return VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType; - case linearColorAttachment: return VkPhysicalDeviceLinearColorAttachmentFeaturesNV.SType; - case graphicsPipelineLibrary: return VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.SType; - case pipelineBinaries: return VkPhysicalDevicePipelineBinaryFeaturesKHR.SType; - case descriptorSetHostMapping: return VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.SType; - case nestedCommandBuffer: return VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType; - case nestedCommandBufferRendering: return VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType; - case nestedCommandBufferSimultaneousUse: return VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType; - case shaderModuleIdentifier: return VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.SType; - case imageCompressionControl: return VkPhysicalDeviceImageCompressionControlFeaturesEXT.SType; - case imageCompressionControlSwapchain: return VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.SType; - case subpassMergeFeedback: return VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.SType; - case micromap: return VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType; - case micromapCaptureReplay: return VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType; - case micromapHostCommands: return VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType; - case displacementMicromap: return VkPhysicalDeviceDisplacementMicromapFeaturesNV.SType; - case pipelinePropertiesIdentifier: return VkPhysicalDevicePipelinePropertiesFeaturesEXT.SType; - case shaderEarlyAndLateFragmentTests: return VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.SType; - case nonSeamlessCubeMap: return VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.SType; - case textureSampleWeighted: return VkPhysicalDeviceImageProcessingFeaturesQCOM.SType; - case textureBoxFilter: return VkPhysicalDeviceImageProcessingFeaturesQCOM.SType; - case textureBlockMatch: return VkPhysicalDeviceImageProcessingFeaturesQCOM.SType; - case tileProperties: return VkPhysicalDeviceTilePropertiesFeaturesQCOM.SType; - case amigoProfiling: return VkPhysicalDeviceAmigoProfilingFeaturesSEC.SType; - case attachmentFeedbackLoopLayout: return VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.SType; - case reportAddressBinding: return VkPhysicalDeviceAddressBindingReportFeaturesEXT.SType; - case opticalFlow: return VkPhysicalDeviceOpticalFlowFeaturesNV.SType; - case deviceFault: return VkPhysicalDeviceFaultFeaturesEXT.SType; - case deviceFaultVendorBinary: return VkPhysicalDeviceFaultFeaturesEXT.SType; - case pipelineLibraryGroupHandles: return VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.SType; - case shaderCoreBuiltins: return VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.SType; - case frameBoundary: return VkPhysicalDeviceFrameBoundaryFeaturesEXT.SType; - case dynamicRenderingUnusedAttachments: return VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.SType; - case swapchainMaintenance1: return VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.SType; - case depthBiasControl: return VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType; - case leastRepresentableValueForceUnormRepresentation: return VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType; - case floatRepresentation: return VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType; - case depthBiasExact: return VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType; - case rayTracingInvocationReorder: return VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.SType; - case extendedSparseAddressSpace: return VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.SType; - case multiviewPerViewViewports: return VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.SType; - case rayTracingPositionFetch: return VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.SType; - case multiviewPerViewRenderAreas: return VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.SType; - case shaderObject: return VkPhysicalDeviceShaderObjectFeaturesEXT.SType; - case shaderTileImageColorReadAccess: return VkPhysicalDeviceShaderTileImageFeaturesEXT.SType; - case shaderTileImageDepthReadAccess: return VkPhysicalDeviceShaderTileImageFeaturesEXT.SType; - case shaderTileImageStencilReadAccess: return VkPhysicalDeviceShaderTileImageFeaturesEXT.SType; - case screenBufferImport: return VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.SType; - case shaderEnqueue: return VkPhysicalDeviceShaderEnqueueFeaturesAMDX.SType; - case shaderMeshEnqueue: return VkPhysicalDeviceShaderEnqueueFeaturesAMDX.SType; - case antiLag: return VkPhysicalDeviceAntiLagFeaturesAMD.SType; - case tileMemoryHeap: return VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.SType; - case cubicRangeClamp: return VkPhysicalDeviceCubicClampFeaturesQCOM.SType; - case ycbcrDegamma: return VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.SType; - case selectableCubicWeights: return VkPhysicalDeviceCubicWeightsFeaturesQCOM.SType; - case textureBlockMatch2: return VkPhysicalDeviceImageProcessing2FeaturesQCOM.SType; - case descriptorPoolOverallocation: return VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.SType; - case perStageDescriptorSet: return VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType; - case dynamicPipelineLayout: return VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType; - case externalFormatResolve: return VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.SType; - case cudaKernelLaunchFeatures: return VkPhysicalDeviceCudaKernelLaunchFeaturesNV.SType; - case schedulingControls: return VkPhysicalDeviceSchedulingControlsFeaturesARM.SType; - case relaxedLineRasterization: return VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.SType; - case renderPassStriped: return VkPhysicalDeviceRenderPassStripedFeaturesARM.SType; - case pipelineOpacityMicromap: return VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.SType; - case shaderMaximalReconvergence: return VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.SType; - case shaderQuadControl: return VkPhysicalDeviceShaderQuadControlFeaturesKHR.SType; - case shaderFloat16VectorAtomics: return VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.SType; - case memoryMapPlaced: return VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType; - case memoryMapRangePlaced: return VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType; - case memoryUnmapReserve: return VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType; - case shaderBFloat16Type: return VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType; - case shaderBFloat16DotProduct: return VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType; - case shaderBFloat16CooperativeMatrix: return VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType; - case shaderRawAccessChains: return VkPhysicalDeviceRawAccessChainsFeaturesNV.SType; - case commandBufferInheritance: return VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.SType; - case imageAlignmentControl: return VkPhysicalDeviceImageAlignmentControlFeaturesMESA.SType; - case shaderReplicatedComposites: return VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.SType; - case presentModeFifoLatestReady: return VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.SType; - case cooperativeMatrixWorkgroupScope: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixFlexibleDimensions: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixReductions: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixConversions: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixPerElementOperations: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixTensorAddressing: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case cooperativeMatrixBlockLoads: return VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType; - case hdrVivid: return VkPhysicalDeviceHdrVividFeaturesHUAWEI.SType; - case vertexAttributeRobustness: return VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.SType; - case denseGeometryFormat: return VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX.SType; - case depthClampZeroOne: return VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.SType; - case cooperativeVector: return VkPhysicalDeviceCooperativeVectorFeaturesNV.SType; - case cooperativeVectorTraining: return VkPhysicalDeviceCooperativeVectorFeaturesNV.SType; - case tileShading: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingFragmentStage: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingColorAttachments: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingDepthAttachments: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingStencilAttachments: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingInputAttachments: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingSampledAttachments: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingPerTileDraw: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingPerTileDispatch: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingDispatchTile: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingApron: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingAnisotropicApron: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingAtomicOps: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case tileShadingImageProcessing: return VkPhysicalDeviceTileShadingFeaturesQCOM.SType; - case fragmentDensityMapLayered: return VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.SType; - case presentMetering: return VkPhysicalDevicePresentMeteringFeaturesNV.SType; - case shaderUniformBufferUnsizedArray: return VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.SType; - case formatPack: return VkPhysicalDeviceFormatPackFeaturesARM.SType; - case tensorNonPacked: return VkPhysicalDeviceTensorFeaturesARM.SType; - case shaderTensorAccess: return VkPhysicalDeviceTensorFeaturesARM.SType; - case shaderStorageTensorArrayDynamicIndexing: return VkPhysicalDeviceTensorFeaturesARM.SType; - case shaderStorageTensorArrayNonUniformIndexing: return VkPhysicalDeviceTensorFeaturesARM.SType; - case descriptorBindingStorageTensorUpdateAfterBind: return VkPhysicalDeviceTensorFeaturesARM.SType; - case tensors: return VkPhysicalDeviceTensorFeaturesARM.SType; - case descriptorBufferTensorDescriptors: return VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.SType; - case shaderFloat8: return VkPhysicalDeviceShaderFloat8FeaturesEXT.SType; - case shaderFloat8CooperativeMatrix: return VkPhysicalDeviceShaderFloat8FeaturesEXT.SType; - case dataGraph: return VkPhysicalDeviceDataGraphFeaturesARM.SType; - case dataGraphUpdateAfterBind: return VkPhysicalDeviceDataGraphFeaturesARM.SType; - case dataGraphSpecializationConstants: return VkPhysicalDeviceDataGraphFeaturesARM.SType; - case dataGraphDescriptorBuffer: return VkPhysicalDeviceDataGraphFeaturesARM.SType; - case dataGraphShaderModule: return VkPhysicalDeviceDataGraphFeaturesARM.SType; - case pipelineCacheIncrementalMode: return VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.SType; - case dataGraphModel: return VkPhysicalDeviceDataGraphModelFeaturesQCOM.SType; - case shaderUntypedPointers: return VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.SType; - case videoEncodeRgbConversion: return VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.SType; - case shader64BitIndexing: return VkPhysicalDeviceShader64BitIndexingFeaturesEXT.SType; - case performanceCountersByRegion: return VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.SType; + case deviceGeneratedCommands: return .ForFeatureStruct(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType); + case deviceGeneratedCompute: return .ForFeatureStruct(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType); + case deviceGeneratedComputePipelines: return .ForFeatureStruct(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType); + case deviceGeneratedComputeCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.SType); + case privateData: return .ForFeatureStruct(VkPhysicalDevicePrivateDataFeatures.SType); + case clusterAccelerationStructure: return .ForFeatureStruct(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.SType); + case variablePointersStorageBuffer: return .ForFeatureStruct(VkPhysicalDeviceVariablePointersFeatures.SType); + case variablePointers: return .ForFeatureStruct(VkPhysicalDeviceVariablePointersFeatures.SType); + case multiview: return .ForFeatureStruct(VkPhysicalDeviceMultiviewFeatures.SType); + case multiviewGeometryShader: return .ForFeatureStruct(VkPhysicalDeviceMultiviewFeatures.SType); + case multiviewTessellationShader: return .ForFeatureStruct(VkPhysicalDeviceMultiviewFeatures.SType); + case presentId: return .ForFeatureStruct(VkPhysicalDevicePresentIdFeaturesKHR.SType); + case presentId2: return .ForFeatureStruct(VkPhysicalDevicePresentId2FeaturesKHR.SType); + case presentWait: return .ForFeatureStruct(VkPhysicalDevicePresentWaitFeaturesKHR.SType); + case presentWait2: return .ForFeatureStruct(VkPhysicalDevicePresentWait2FeaturesKHR.SType); + case presentTiming: return .ForFeatureStruct(VkPhysicalDevicePresentTimingFeaturesEXT.SType); + case presentAtAbsoluteTime: return .ForFeatureStruct(VkPhysicalDevicePresentTimingFeaturesEXT.SType); + case presentAtRelativeTime: return .ForFeatureStruct(VkPhysicalDevicePresentTimingFeaturesEXT.SType); + case storageBuffer16BitAccess: return .ForFeatureStruct(VkPhysicalDevice16BitStorageFeatures.SType); + case uniformAndStorageBuffer16BitAccess: return .ForFeatureStruct(VkPhysicalDevice16BitStorageFeatures.SType); + case storagePushConstant16: return .ForFeatureStruct(VkPhysicalDevice16BitStorageFeatures.SType); + case storageInputOutput16: return .ForFeatureStruct(VkPhysicalDevice16BitStorageFeatures.SType); + case shaderSubgroupExtendedTypes: return .ForFeatureStruct(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.SType); + case samplerYcbcrConversion: return .ForFeatureStruct(VkPhysicalDeviceSamplerYcbcrConversionFeatures.SType); + case protectedMemory: return .ForFeatureStruct(VkPhysicalDeviceProtectedMemoryFeatures.SType); + case advancedBlendCoherentOperations: return .ForFeatureStruct(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.SType); + case multiDraw: return .ForFeatureStruct(VkPhysicalDeviceMultiDrawFeaturesEXT.SType); + case inlineUniformBlock: return .ForFeatureStruct(VkPhysicalDeviceInlineUniformBlockFeatures.SType); + case descriptorBindingInlineUniformBlockUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceInlineUniformBlockFeatures.SType); + case maintenance4: return .ForFeatureStruct(VkPhysicalDeviceMaintenance4Features.SType); + case maintenance5: return .ForFeatureStruct(VkPhysicalDeviceMaintenance5Features.SType); + case maintenance6: return .ForFeatureStruct(VkPhysicalDeviceMaintenance6Features.SType); + case maintenance7: return .ForFeatureStruct(VkPhysicalDeviceMaintenance7FeaturesKHR.SType); + case maintenance8: return .ForFeatureStruct(VkPhysicalDeviceMaintenance8FeaturesKHR.SType); + case maintenance9: return .ForFeatureStruct(VkPhysicalDeviceMaintenance9FeaturesKHR.SType); + case maintenance10: return .ForFeatureStruct(VkPhysicalDeviceMaintenance10FeaturesKHR.SType); + case shaderDrawParameters: return .ForFeatureStruct(VkPhysicalDeviceShaderDrawParametersFeatures.SType); + case shaderFloat16: return .ForFeatureStruct(VkPhysicalDeviceShaderFloat16Int8Features.SType); + case shaderInt8: return .ForFeatureStruct(VkPhysicalDeviceShaderFloat16Int8Features.SType); + case hostQueryReset: return .ForFeatureStruct(VkPhysicalDeviceHostQueryResetFeatures.SType); + case globalPriorityQuery: return .ForFeatureStruct(VkPhysicalDeviceGlobalPriorityQueryFeatures.SType); + case deviceMemoryReport: return .ForFeatureStruct(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.SType); + case shaderInputAttachmentArrayDynamicIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderUniformTexelBufferArrayDynamicIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderStorageTexelBufferArrayDynamicIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderUniformBufferArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderSampledImageArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderStorageBufferArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderStorageImageArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderInputAttachmentArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderUniformTexelBufferArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case shaderStorageTexelBufferArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingUniformBufferUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingSampledImageUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingStorageImageUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingStorageBufferUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingUniformTexelBufferUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingStorageTexelBufferUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingUpdateUnusedWhilePending: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingPartiallyBound: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case descriptorBindingVariableDescriptorCount: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case runtimeDescriptorArray: return .ForFeatureStruct(VkPhysicalDeviceDescriptorIndexingFeatures.SType); + case timelineSemaphore: return .ForFeatureStruct(VkPhysicalDeviceTimelineSemaphoreFeatures.SType); + case storageBuffer8BitAccess: return .ForFeatureStruct(VkPhysicalDevice8BitStorageFeatures.SType); + case uniformAndStorageBuffer8BitAccess: return .ForFeatureStruct(VkPhysicalDevice8BitStorageFeatures.SType); + case storagePushConstant8: return .ForFeatureStruct(VkPhysicalDevice8BitStorageFeatures.SType); + case conditionalRendering: return .ForFeatureStruct(VkPhysicalDeviceConditionalRenderingFeaturesEXT.SType); + case inheritedConditionalRendering: return .ForFeatureStruct(VkPhysicalDeviceConditionalRenderingFeaturesEXT.SType); + case vulkanMemoryModel: return .ForFeatureStruct(VkPhysicalDeviceVulkanMemoryModelFeatures.SType); + case vulkanMemoryModelDeviceScope: return .ForFeatureStruct(VkPhysicalDeviceVulkanMemoryModelFeatures.SType); + case vulkanMemoryModelAvailabilityVisibilityChains: return .ForFeatureStruct(VkPhysicalDeviceVulkanMemoryModelFeatures.SType); + case shaderBufferInt64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicInt64Features.SType); + case shaderSharedInt64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicInt64Features.SType); + case shaderBufferFloat32Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderBufferFloat32AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderBufferFloat64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderBufferFloat64AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderSharedFloat32Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderSharedFloat32AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderSharedFloat64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderSharedFloat64AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderImageFloat32Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderImageFloat32AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case sparseImageFloat32Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case sparseImageFloat32AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.SType); + case shaderBufferFloat16Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderBufferFloat16AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderBufferFloat16AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderBufferFloat32AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderBufferFloat64AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderSharedFloat16Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderSharedFloat16AtomicAdd: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderSharedFloat16AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderSharedFloat32AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderSharedFloat64AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case shaderImageFloat32AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case sparseImageFloat32AtomicMinMax: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.SType); + case vertexAttributeInstanceRateDivisor: return .ForFeatureStruct(VkPhysicalDeviceVertexAttributeDivisorFeatures.SType); + case vertexAttributeInstanceRateZeroDivisor: return .ForFeatureStruct(VkPhysicalDeviceVertexAttributeDivisorFeatures.SType); + case decodeModeSharedExponent: return .ForFeatureStruct(VkPhysicalDeviceASTCDecodeFeaturesEXT.SType); + case transformFeedback: return .ForFeatureStruct(VkPhysicalDeviceTransformFeedbackFeaturesEXT.SType); + case geometryStreams: return .ForFeatureStruct(VkPhysicalDeviceTransformFeedbackFeaturesEXT.SType); + case representativeFragmentTest: return .ForFeatureStruct(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.SType); + case exclusiveScissor: return .ForFeatureStruct(VkPhysicalDeviceExclusiveScissorFeaturesNV.SType); + case cornerSampledImage: return .ForFeatureStruct(VkPhysicalDeviceCornerSampledImageFeaturesNV.SType); + case computeDerivativeGroupQuads: return .ForFeatureStruct(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType); + case computeDerivativeGroupLinear: return .ForFeatureStruct(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.SType); + case imageFootprint: return .ForFeatureStruct(VkPhysicalDeviceShaderImageFootprintFeaturesNV.SType); + case dedicatedAllocationImageAliasing: return .ForFeatureStruct(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.SType); + case indirectMemoryCopy: return .ForFeatureStruct(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType); + case indirectMemoryToImageCopy: return .ForFeatureStruct(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.SType); + case indirectCopy: return .ForFeatureStruct(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.SType); + case memoryDecompression: return .ForFeatureStruct(VkPhysicalDeviceMemoryDecompressionFeaturesEXT.SType); + case shadingRateImage: return .ForFeatureStruct(VkPhysicalDeviceShadingRateImageFeaturesNV.SType); + case shadingRateCoarseSampleOrder: return .ForFeatureStruct(VkPhysicalDeviceShadingRateImageFeaturesNV.SType); + case invocationMask: return .ForFeatureStruct(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.SType); + case taskShader: return .ForFeatureStruct(VkPhysicalDeviceMeshShaderFeaturesEXT.SType); + case meshShader: return .ForFeatureStruct(VkPhysicalDeviceMeshShaderFeaturesEXT.SType); + case multiviewMeshShader: return .ForFeatureStruct(VkPhysicalDeviceMeshShaderFeaturesEXT.SType); + case primitiveFragmentShadingRateMeshShader: return .ForFeatureStruct(VkPhysicalDeviceMeshShaderFeaturesEXT.SType); + case meshShaderQueries: return .ForFeatureStruct(VkPhysicalDeviceMeshShaderFeaturesEXT.SType); + case accelerationStructure: return .ForFeatureStruct(VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType); + case accelerationStructureCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType); + case accelerationStructureIndirectBuild: return .ForFeatureStruct(VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType); + case accelerationStructureHostCommands: return .ForFeatureStruct(VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType); + case descriptorBindingAccelerationStructureUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceAccelerationStructureFeaturesKHR.SType); + case rayTracingPipeline: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType); + case rayTracingPipelineShaderGroupHandleCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType); + case rayTracingPipelineShaderGroupHandleCaptureReplayMixed: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType); + case rayTracingPipelineTraceRaysIndirect: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType); + case rayTraversalPrimitiveCulling: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPipelineFeaturesKHR.SType); + case rayQuery: return .ForFeatureStruct(VkPhysicalDeviceRayQueryFeaturesKHR.SType); + case rayTracingMaintenance1: return .ForFeatureStruct(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType); + case rayTracingPipelineTraceRaysIndirect2: return .ForFeatureStruct(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.SType); + case fragmentDensityMap: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType); + case fragmentDensityMapDynamic: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType); + case fragmentDensityMapNonSubsampledImages: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMapFeaturesEXT.SType); + case fragmentDensityMapDeferred: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.SType); + case fragmentDensityMapOffset: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.SType); + case scalarBlockLayout: return .ForFeatureStruct(VkPhysicalDeviceScalarBlockLayoutFeatures.SType); + case uniformBufferStandardLayout: return .ForFeatureStruct(VkPhysicalDeviceUniformBufferStandardLayoutFeatures.SType); + case depthClipEnable: return .ForFeatureStruct(VkPhysicalDeviceDepthClipEnableFeaturesEXT.SType); + case memoryPriority: return .ForFeatureStruct(VkPhysicalDeviceMemoryPriorityFeaturesEXT.SType); + case pageableDeviceLocalMemory: return .ForFeatureStruct(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.SType); + case bufferDeviceAddress: return .ForFeatureStruct(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType); + case bufferDeviceAddressCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType); + case bufferDeviceAddressMultiDevice: return .ForFeatureStruct(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.SType); + case imagelessFramebuffer: return .ForFeatureStruct(VkPhysicalDeviceImagelessFramebufferFeatures.SType); + case textureCompressionASTC_HDR: return .ForFeatureStruct(VkPhysicalDeviceTextureCompressionASTCHDRFeatures.SType); + case cooperativeMatrix: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType); + case cooperativeMatrixRobustBufferAccess: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrixFeaturesKHR.SType); + case ycbcrImageArrays: return .ForFeatureStruct(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.SType); + case presentBarrier: return .ForFeatureStruct(VkPhysicalDevicePresentBarrierFeaturesNV.SType); + case performanceCounterQueryPools: return .ForFeatureStruct(VkPhysicalDevicePerformanceQueryFeaturesKHR.SType); + case performanceCounterMultipleQueryPools: return .ForFeatureStruct(VkPhysicalDevicePerformanceQueryFeaturesKHR.SType); + case coverageReductionMode: return .ForFeatureStruct(VkPhysicalDeviceCoverageReductionModeFeaturesNV.SType); + case shaderIntegerFunctions2: return .ForFeatureStruct(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.SType); + case shaderSubgroupClock: return .ForFeatureStruct(VkPhysicalDeviceShaderClockFeaturesKHR.SType); + case shaderDeviceClock: return .ForFeatureStruct(VkPhysicalDeviceShaderClockFeaturesKHR.SType); + case indexTypeUint8: return .ForFeatureStruct(VkPhysicalDeviceIndexTypeUint8Features.SType); + case shaderSMBuiltins: return .ForFeatureStruct(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.SType); + case fragmentShaderSampleInterlock: return .ForFeatureStruct(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType); + case fragmentShaderPixelInterlock: return .ForFeatureStruct(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType); + case fragmentShaderShadingRateInterlock: return .ForFeatureStruct(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.SType); + case separateDepthStencilLayouts: return .ForFeatureStruct(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.SType); + case primitiveTopologyListRestart: return .ForFeatureStruct(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType); + case primitiveTopologyPatchListRestart: return .ForFeatureStruct(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.SType); + case pipelineExecutableInfo: return .ForFeatureStruct(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.SType); + case shaderDemoteToHelperInvocation: return .ForFeatureStruct(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.SType); + case texelBufferAlignment: return .ForFeatureStruct(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.SType); + case subgroupSizeControl: return .ForFeatureStruct(VkPhysicalDeviceSubgroupSizeControlFeatures.SType); + case computeFullSubgroups: return .ForFeatureStruct(VkPhysicalDeviceSubgroupSizeControlFeatures.SType); + case rectangularLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case bresenhamLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case smoothLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case stippledRectangularLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case stippledBresenhamLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case stippledSmoothLines: return .ForFeatureStruct(VkPhysicalDeviceLineRasterizationFeatures.SType); + case pipelineCreationCacheControl: return .ForFeatureStruct(VkPhysicalDevicePipelineCreationCacheControlFeatures.SType); + case robustImageAccess: return .ForFeatureStruct(VkPhysicalDeviceImageRobustnessFeatures.SType); + case shaderTerminateInvocation: return .ForFeatureStruct(VkPhysicalDeviceShaderTerminateInvocationFeatures.SType); + case synchronization2: return .ForFeatureStruct(VkPhysicalDeviceSynchronization2Features.SType); + case shaderZeroInitializeWorkgroupMemory: return .ForFeatureStruct(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.SType); + case dynamicRendering: return .ForFeatureStruct(VkPhysicalDeviceDynamicRenderingFeatures.SType); + case shaderIntegerDotProduct: return .ForFeatureStruct(VkPhysicalDeviceShaderIntegerDotProductFeatures.SType); + case shaderSubgroupRotate: return .ForFeatureStruct(VkPhysicalDeviceShaderSubgroupRotateFeatures.SType); + case shaderSubgroupRotateClustered: return .ForFeatureStruct(VkPhysicalDeviceShaderSubgroupRotateFeatures.SType); + case shaderFloatControls2: return .ForFeatureStruct(VkPhysicalDeviceShaderFloatControls2Features.SType); + case shaderExpectAssume: return .ForFeatureStruct(VkPhysicalDeviceShaderExpectAssumeFeatures.SType); + case dynamicRenderingLocalRead: return .ForFeatureStruct(VkPhysicalDeviceDynamicRenderingLocalReadFeatures.SType); + case pipelineProtectedAccess: return .ForFeatureStruct(VkPhysicalDevicePipelineProtectedAccessFeatures.SType); + case pipelineRobustness: return .ForFeatureStruct(VkPhysicalDevicePipelineRobustnessFeatures.SType); + case hostImageCopy: return .ForFeatureStruct(VkPhysicalDeviceHostImageCopyFeatures.SType); + case deviceCoherentMemory: return .ForFeatureStruct(VkPhysicalDeviceCoherentMemoryFeaturesAMD.SType); + case customBorderColors: return .ForFeatureStruct(VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType); + case customBorderColorWithoutFormat: return .ForFeatureStruct(VkPhysicalDeviceCustomBorderColorFeaturesEXT.SType); + case borderColorSwizzle: return .ForFeatureStruct(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType); + case borderColorSwizzleFromImage: return .ForFeatureStruct(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.SType); + case extendedDynamicState: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.SType); + case extendedDynamicState2: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType); + case extendedDynamicState2LogicOp: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType); + case extendedDynamicState2PatchControlPoints: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.SType); + case extendedDynamicState3TessellationDomainOrigin: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3DepthClampEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3PolygonMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3RasterizationSamples: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3SampleMask: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3AlphaToCoverageEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3AlphaToOneEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3LogicOpEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ColorBlendEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ColorBlendEquation: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ColorWriteMask: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3RasterizationStream: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ConservativeRasterizationMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ExtraPrimitiveOverestimationSize: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3DepthClipEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3SampleLocationsEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ColorBlendAdvanced: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ProvokingVertexMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3LineRasterizationMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3LineStippleEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3DepthClipNegativeOneToOne: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ViewportWScalingEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ViewportSwizzle: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageToColorEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageToColorLocation: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageModulationMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageModulationTableEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageModulationTable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3CoverageReductionMode: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3RepresentativeFragmentTestEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case extendedDynamicState3ShadingRateImageEnable: return .ForFeatureStruct(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.SType); + case partitionedAccelerationStructure: return .ForFeatureStruct(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.SType); + case diagnosticsConfig: return .ForFeatureStruct(VkPhysicalDeviceDiagnosticsConfigFeaturesNV.SType); + case shaderSubgroupUniformControlFlow: return .ForFeatureStruct(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.SType); + case robustBufferAccess2: return .ForFeatureStruct(VkPhysicalDeviceRobustness2FeaturesKHR.SType); + case robustImageAccess2: return .ForFeatureStruct(VkPhysicalDeviceRobustness2FeaturesKHR.SType); + case nullDescriptor: return .ForFeatureStruct(VkPhysicalDeviceRobustness2FeaturesKHR.SType); + case workgroupMemoryExplicitLayout: return .ForFeatureStruct(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType); + case workgroupMemoryExplicitLayoutScalarBlockLayout: return .ForFeatureStruct(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType); + case workgroupMemoryExplicitLayout8BitAccess: return .ForFeatureStruct(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType); + case workgroupMemoryExplicitLayout16BitAccess: return .ForFeatureStruct(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.SType); + case constantAlphaColorBlendFactors: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case events: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case imageViewFormatReinterpretation: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case imageViewFormatSwizzle: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case imageView2DOn3DImage: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case multisampleArrayImage: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case mutableComparisonSamplers: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case pointPolygons: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case samplerMipLodBias: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case separateStencilMaskRef: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case shaderSampleRateInterpolationFunctions: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case tessellationIsolines: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case tessellationPointMode: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case triangleFans: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case vertexAttributeAccessBeyondStride: return .ForFeatureStruct(VkPhysicalDevicePortabilitySubsetFeaturesKHR.SType); + case formatA4R4G4B4: return .ForFeatureStruct(VkPhysicalDevice4444FormatsFeaturesEXT.SType); + case formatA4B4G4R4: return .ForFeatureStruct(VkPhysicalDevice4444FormatsFeaturesEXT.SType); + case subpassShading: return .ForFeatureStruct(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.SType); + case clustercullingShader: return .ForFeatureStruct(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.SType); + case multiviewClusterCullingShader: return .ForFeatureStruct(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.SType); + case clusterShadingRate: return .ForFeatureStruct(VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.SType); + case shaderImageInt64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType); + case sparseImageInt64Atomics: return .ForFeatureStruct(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.SType); + case pipelineFragmentShadingRate: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType); + case primitiveFragmentShadingRate: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType); + case attachmentFragmentShadingRate: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateFeaturesKHR.SType); + case fragmentShadingRateEnums: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType); + case supersampleFragmentShadingRates: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType); + case noInvocationFragmentShadingRates: return .ForFeatureStruct(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.SType); + case image2DViewOf3D: return .ForFeatureStruct(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType); + case sampler2DViewOf3D: return .ForFeatureStruct(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.SType); + case imageSlicedViewOf3D: return .ForFeatureStruct(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.SType); + case attachmentFeedbackLoopDynamicState: return .ForFeatureStruct(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.SType); + case legacyVertexAttributes: return .ForFeatureStruct(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.SType); + case mutableDescriptorType: return .ForFeatureStruct(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.SType); + case depthClipControl: return .ForFeatureStruct(VkPhysicalDeviceDepthClipControlFeaturesEXT.SType); + case zeroInitializeDeviceMemory: return .ForFeatureStruct(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.SType); + case customResolve: return .ForFeatureStruct(VkPhysicalDeviceCustomResolveFeaturesEXT.SType); + case dynamicGeneratedPipelineLayout: return .ForFeatureStruct(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.SType); + case depthClampControl: return .ForFeatureStruct(VkPhysicalDeviceDepthClampControlFeaturesEXT.SType); + case vertexInputDynamicState: return .ForFeatureStruct(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.SType); + case externalMemoryRDMA: return .ForFeatureStruct(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.SType); + case shaderRelaxedExtendedInstruction: return .ForFeatureStruct(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.SType); + case colorWriteEnable: return .ForFeatureStruct(VkPhysicalDeviceColorWriteEnableFeaturesEXT.SType); + case unifiedImageLayouts: return .ForFeatureStruct(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType); + case unifiedImageLayoutsVideo: return .ForFeatureStruct(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.SType); + case primitivesGeneratedQuery: return .ForFeatureStruct(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType); + case primitivesGeneratedQueryWithRasterizerDiscard: return .ForFeatureStruct(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType); + case primitivesGeneratedQueryWithNonZeroStreams: return .ForFeatureStruct(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.SType); + case legacyDithering: return .ForFeatureStruct(VkPhysicalDeviceLegacyDitheringFeaturesEXT.SType); + case multisampledRenderToSingleSampled: return .ForFeatureStruct(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.SType); + case videoMaintenance1: return .ForFeatureStruct(VkPhysicalDeviceVideoMaintenance1FeaturesKHR.SType); + case videoMaintenance2: return .ForFeatureStruct(VkPhysicalDeviceVideoMaintenance2FeaturesKHR.SType); + case videoDecodeVP9: return .ForFeatureStruct(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.SType); + case videoEncodeQuantizationMap: return .ForFeatureStruct(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.SType); + case videoEncodeAV1: return .ForFeatureStruct(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.SType); + case inheritedViewportScissor2D: return .ForFeatureStruct(VkPhysicalDeviceInheritedViewportScissorFeaturesNV.SType); + case ycbcr2plane444Formats: return .ForFeatureStruct(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.SType); + case provokingVertexLast: return .ForFeatureStruct(VkPhysicalDeviceProvokingVertexFeaturesEXT.SType); + case transformFeedbackPreservesProvokingVertex: return .ForFeatureStruct(VkPhysicalDeviceProvokingVertexFeaturesEXT.SType); + case videoEncodeIntraRefresh: return .ForFeatureStruct(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.SType); + case descriptorBuffer: return .ForFeatureStruct(VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType); + case descriptorBufferCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType); + case descriptorBufferImageLayoutIgnored: return .ForFeatureStruct(VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType); + case descriptorBufferPushDescriptors: return .ForFeatureStruct(VkPhysicalDeviceDescriptorBufferFeaturesEXT.SType); + case fragmentShaderBarycentric: return .ForFeatureStruct(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.SType); + case shaderFmaFloat16: return .ForFeatureStruct(VkPhysicalDeviceShaderFmaFeaturesKHR.SType); + case shaderFmaFloat32: return .ForFeatureStruct(VkPhysicalDeviceShaderFmaFeaturesKHR.SType); + case shaderFmaFloat64: return .ForFeatureStruct(VkPhysicalDeviceShaderFmaFeaturesKHR.SType); + case rayTracingMotionBlur: return .ForFeatureStruct(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType); + case rayTracingMotionBlurPipelineTraceRaysIndirect: return .ForFeatureStruct(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.SType); + case rayTracingValidation: return .ForFeatureStruct(VkPhysicalDeviceRayTracingValidationFeaturesNV.SType); + case spheres: return .ForFeatureStruct(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType); + case linearSweptSpheres: return .ForFeatureStruct(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.SType); + case formatRgba10x6WithoutYCbCrSampler: return .ForFeatureStruct(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.SType); + case minLod: return .ForFeatureStruct(VkPhysicalDeviceImageViewMinLodFeaturesEXT.SType); + case rasterizationOrderColorAttachmentAccess: return .ForFeatureStruct(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType); + case rasterizationOrderDepthAttachmentAccess: return .ForFeatureStruct(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType); + case rasterizationOrderStencilAttachmentAccess: return .ForFeatureStruct(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.SType); + case linearColorAttachment: return .ForFeatureStruct(VkPhysicalDeviceLinearColorAttachmentFeaturesNV.SType); + case graphicsPipelineLibrary: return .ForFeatureStruct(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.SType); + case pipelineBinaries: return .ForFeatureStruct(VkPhysicalDevicePipelineBinaryFeaturesKHR.SType); + case descriptorSetHostMapping: return .ForFeatureStruct(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.SType); + case nestedCommandBuffer: return .ForFeatureStruct(VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType); + case nestedCommandBufferRendering: return .ForFeatureStruct(VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType); + case nestedCommandBufferSimultaneousUse: return .ForFeatureStruct(VkPhysicalDeviceNestedCommandBufferFeaturesEXT.SType); + case shaderModuleIdentifier: return .ForFeatureStruct(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.SType); + case imageCompressionControl: return .ForFeatureStruct(VkPhysicalDeviceImageCompressionControlFeaturesEXT.SType); + case imageCompressionControlSwapchain: return .ForFeatureStruct(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.SType); + case subpassMergeFeedback: return .ForFeatureStruct(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.SType); + case micromap: return .ForFeatureStruct(VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType); + case micromapCaptureReplay: return .ForFeatureStruct(VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType); + case micromapHostCommands: return .ForFeatureStruct(VkPhysicalDeviceOpacityMicromapFeaturesEXT.SType); + case displacementMicromap: return .ForFeatureStruct(VkPhysicalDeviceDisplacementMicromapFeaturesNV.SType); + case pipelinePropertiesIdentifier: return .ForFeatureStruct(VkPhysicalDevicePipelinePropertiesFeaturesEXT.SType); + case shaderEarlyAndLateFragmentTests: return .ForFeatureStruct(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.SType); + case nonSeamlessCubeMap: return .ForFeatureStruct(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.SType); + case textureSampleWeighted: return .ForFeatureStruct(VkPhysicalDeviceImageProcessingFeaturesQCOM.SType); + case textureBoxFilter: return .ForFeatureStruct(VkPhysicalDeviceImageProcessingFeaturesQCOM.SType); + case textureBlockMatch: return .ForFeatureStruct(VkPhysicalDeviceImageProcessingFeaturesQCOM.SType); + case tileProperties: return .ForFeatureStruct(VkPhysicalDeviceTilePropertiesFeaturesQCOM.SType); + case amigoProfiling: return .ForFeatureStruct(VkPhysicalDeviceAmigoProfilingFeaturesSEC.SType); + case attachmentFeedbackLoopLayout: return .ForFeatureStruct(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.SType); + case reportAddressBinding: return .ForFeatureStruct(VkPhysicalDeviceAddressBindingReportFeaturesEXT.SType); + case opticalFlow: return .ForFeatureStruct(VkPhysicalDeviceOpticalFlowFeaturesNV.SType); + case deviceFault: return .ForFeatureStruct(VkPhysicalDeviceFaultFeaturesEXT.SType); + case deviceFaultVendorBinary: return .ForFeatureStruct(VkPhysicalDeviceFaultFeaturesEXT.SType); + case pipelineLibraryGroupHandles: return .ForFeatureStruct(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.SType); + case shaderCoreBuiltins: return .ForFeatureStruct(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.SType); + case frameBoundary: return .ForFeatureStruct(VkPhysicalDeviceFrameBoundaryFeaturesEXT.SType); + case dynamicRenderingUnusedAttachments: return .ForFeatureStruct(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.SType); + case swapchainMaintenance1: return .ForFeatureStruct(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.SType); + case depthBiasControl: return .ForFeatureStruct(VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType); + case leastRepresentableValueForceUnormRepresentation: return .ForFeatureStruct(VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType); + case floatRepresentation: return .ForFeatureStruct(VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType); + case depthBiasExact: return .ForFeatureStruct(VkPhysicalDeviceDepthBiasControlFeaturesEXT.SType); + case rayTracingInvocationReorder: return .ForFeatureStruct(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.SType); + case extendedSparseAddressSpace: return .ForFeatureStruct(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.SType); + case multiviewPerViewViewports: return .ForFeatureStruct(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.SType); + case rayTracingPositionFetch: return .ForFeatureStruct(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.SType); + case multiviewPerViewRenderAreas: return .ForFeatureStruct(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.SType); + case shaderObject: return .ForFeatureStruct(VkPhysicalDeviceShaderObjectFeaturesEXT.SType); + case shaderTileImageColorReadAccess: return .ForFeatureStruct(VkPhysicalDeviceShaderTileImageFeaturesEXT.SType); + case shaderTileImageDepthReadAccess: return .ForFeatureStruct(VkPhysicalDeviceShaderTileImageFeaturesEXT.SType); + case shaderTileImageStencilReadAccess: return .ForFeatureStruct(VkPhysicalDeviceShaderTileImageFeaturesEXT.SType); + case screenBufferImport: return .ForFeatureStruct(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.SType); + case shaderEnqueue: return .ForFeatureStruct(VkPhysicalDeviceShaderEnqueueFeaturesAMDX.SType); + case shaderMeshEnqueue: return .ForFeatureStruct(VkPhysicalDeviceShaderEnqueueFeaturesAMDX.SType); + case antiLag: return .ForFeatureStruct(VkPhysicalDeviceAntiLagFeaturesAMD.SType); + case tileMemoryHeap: return .ForFeatureStruct(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.SType); + case cubicRangeClamp: return .ForFeatureStruct(VkPhysicalDeviceCubicClampFeaturesQCOM.SType); + case ycbcrDegamma: return .ForFeatureStruct(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.SType); + case selectableCubicWeights: return .ForFeatureStruct(VkPhysicalDeviceCubicWeightsFeaturesQCOM.SType); + case textureBlockMatch2: return .ForFeatureStruct(VkPhysicalDeviceImageProcessing2FeaturesQCOM.SType); + case descriptorPoolOverallocation: return .ForFeatureStruct(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.SType); + case perStageDescriptorSet: return .ForFeatureStruct(VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType); + case dynamicPipelineLayout: return .ForFeatureStruct(VkPhysicalDevicePerStageDescriptorSetFeaturesNV.SType); + case externalFormatResolve: return .ForFeatureStruct(VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.SType); + case cudaKernelLaunchFeatures: return .ForFeatureStruct(VkPhysicalDeviceCudaKernelLaunchFeaturesNV.SType); + case schedulingControls: return .ForFeatureStruct(VkPhysicalDeviceSchedulingControlsFeaturesARM.SType); + case relaxedLineRasterization: return .ForFeatureStruct(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.SType); + case renderPassStriped: return .ForFeatureStruct(VkPhysicalDeviceRenderPassStripedFeaturesARM.SType); + case pipelineOpacityMicromap: return .ForFeatureStruct(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.SType); + case shaderMaximalReconvergence: return .ForFeatureStruct(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.SType); + case shaderQuadControl: return .ForFeatureStruct(VkPhysicalDeviceShaderQuadControlFeaturesKHR.SType); + case shaderFloat16VectorAtomics: return .ForFeatureStruct(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.SType); + case memoryMapPlaced: return .ForFeatureStruct(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType); + case memoryMapRangePlaced: return .ForFeatureStruct(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType); + case memoryUnmapReserve: return .ForFeatureStruct(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.SType); + case shaderBFloat16Type: return .ForFeatureStruct(VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType); + case shaderBFloat16DotProduct: return .ForFeatureStruct(VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType); + case shaderBFloat16CooperativeMatrix: return .ForFeatureStruct(VkPhysicalDeviceShaderBfloat16FeaturesKHR.SType); + case shaderRawAccessChains: return .ForFeatureStruct(VkPhysicalDeviceRawAccessChainsFeaturesNV.SType); + case commandBufferInheritance: return .ForFeatureStruct(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.SType); + case imageAlignmentControl: return .ForFeatureStruct(VkPhysicalDeviceImageAlignmentControlFeaturesMESA.SType); + case shaderReplicatedComposites: return .ForFeatureStruct(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.SType); + case presentModeFifoLatestReady: return .ForFeatureStruct(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.SType); + case cooperativeMatrixWorkgroupScope: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixFlexibleDimensions: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixReductions: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixConversions: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixPerElementOperations: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixTensorAddressing: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case cooperativeMatrixBlockLoads: return .ForFeatureStruct(VkPhysicalDeviceCooperativeMatrix2FeaturesNV.SType); + case hdrVivid: return .ForFeatureStruct(VkPhysicalDeviceHdrVividFeaturesHUAWEI.SType); + case vertexAttributeRobustness: return .ForFeatureStruct(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.SType); + case denseGeometryFormat: return .ForFeatureStruct(VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX.SType); + case depthClampZeroOne: return .ForFeatureStruct(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.SType); + case cooperativeVector: return .ForFeatureStruct(VkPhysicalDeviceCooperativeVectorFeaturesNV.SType); + case cooperativeVectorTraining: return .ForFeatureStruct(VkPhysicalDeviceCooperativeVectorFeaturesNV.SType); + case tileShading: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingFragmentStage: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingColorAttachments: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingDepthAttachments: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingStencilAttachments: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingInputAttachments: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingSampledAttachments: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingPerTileDraw: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingPerTileDispatch: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingDispatchTile: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingApron: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingAnisotropicApron: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingAtomicOps: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case tileShadingImageProcessing: return .ForFeatureStruct(VkPhysicalDeviceTileShadingFeaturesQCOM.SType); + case fragmentDensityMapLayered: return .ForFeatureStruct(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.SType); + case presentMetering: return .ForFeatureStruct(VkPhysicalDevicePresentMeteringFeaturesNV.SType); + case shaderUniformBufferUnsizedArray: return .ForFeatureStruct(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.SType); + case formatPack: return .ForFeatureStruct(VkPhysicalDeviceFormatPackFeaturesARM.SType); + case tensorNonPacked: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case shaderTensorAccess: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case shaderStorageTensorArrayDynamicIndexing: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case shaderStorageTensorArrayNonUniformIndexing: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case descriptorBindingStorageTensorUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case tensors: return .ForFeatureStruct(VkPhysicalDeviceTensorFeaturesARM.SType); + case descriptorBufferTensorDescriptors: return .ForFeatureStruct(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.SType); + case shaderFloat8: return .ForFeatureStruct(VkPhysicalDeviceShaderFloat8FeaturesEXT.SType); + case shaderFloat8CooperativeMatrix: return .ForFeatureStruct(VkPhysicalDeviceShaderFloat8FeaturesEXT.SType); + case dataGraph: return .ForFeatureStruct(VkPhysicalDeviceDataGraphFeaturesARM.SType); + case dataGraphUpdateAfterBind: return .ForFeatureStruct(VkPhysicalDeviceDataGraphFeaturesARM.SType); + case dataGraphSpecializationConstants: return .ForFeatureStruct(VkPhysicalDeviceDataGraphFeaturesARM.SType); + case dataGraphDescriptorBuffer: return .ForFeatureStruct(VkPhysicalDeviceDataGraphFeaturesARM.SType); + case dataGraphShaderModule: return .ForFeatureStruct(VkPhysicalDeviceDataGraphFeaturesARM.SType); + case pipelineCacheIncrementalMode: return .ForFeatureStruct(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.SType); + case dataGraphModel: return .ForFeatureStruct(VkPhysicalDeviceDataGraphModelFeaturesQCOM.SType); + case shaderUntypedPointers: return .ForFeatureStruct(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.SType); + case videoEncodeRgbConversion: return .ForFeatureStruct(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.SType); + case shader64BitIndexing: return .ForFeatureStruct(VkPhysicalDeviceShader64BitIndexingFeaturesEXT.SType); + case performanceCountersByRegion: return .ForFeatureStruct(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.SType); default: return default; } } @@ -5009,6 +8129,1151 @@ extension VkStructureType } } } + + [Optimize] public static Self ForType(Type val) + { + Self output = 0; + if (val == typeof(VkApplicationInfo)) output = VK_STRUCTURE_TYPE_APPLICATION_INFO; + if (val == typeof(VkDeviceQueueCreateInfo)) output = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + if (val == typeof(VkDeviceCreateInfo)) output = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + if (val == typeof(VkInstanceCreateInfo)) output = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + if (val == typeof(VkMemoryAllocateInfo)) output = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + if (val == typeof(VkMappedMemoryRange)) output = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; + if (val == typeof(VkWriteDescriptorSet)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + if (val == typeof(VkCopyDescriptorSet)) output = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; + if (val == typeof(VkBufferUsageFlags2CreateInfo)) output = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; + if (val == typeof(VkBufferCreateInfo)) output = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + if (val == typeof(VkBufferViewCreateInfo)) output = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; + if (val == typeof(VkMemoryBarrier)) output = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + if (val == typeof(VkBufferMemoryBarrier)) output = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + if (val == typeof(VkImageMemoryBarrier)) output = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + if (val == typeof(VkImageCreateInfo)) output = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + if (val == typeof(VkImageViewCreateInfo)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + if (val == typeof(VkBindSparseInfo)) output = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; + if (val == typeof(VkCopyMemoryIndirectInfoKHR)) output = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR; + if (val == typeof(VkCopyMemoryToImageIndirectInfoKHR)) output = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR; + if (val == typeof(VkShaderModuleCreateInfo)) output = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + if (val == typeof(VkDescriptorSetLayoutCreateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + if (val == typeof(VkDescriptorPoolCreateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + if (val == typeof(VkDescriptorSetAllocateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + if (val == typeof(VkPipelineShaderStageCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + if (val == typeof(VkComputePipelineCreateInfo)) output = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + if (val == typeof(VkComputePipelineIndirectBufferInfoNV)) output = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; + if (val == typeof(VkPipelineCreateFlags2CreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + if (val == typeof(VkPipelineVertexInputStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + if (val == typeof(VkPipelineInputAssemblyStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + if (val == typeof(VkPipelineTessellationStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; + if (val == typeof(VkPipelineViewportStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + if (val == typeof(VkPipelineRasterizationStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + if (val == typeof(VkPipelineMultisampleStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + if (val == typeof(VkPipelineColorBlendStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + if (val == typeof(VkPipelineDynamicStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + if (val == typeof(VkPipelineDepthStencilStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + if (val == typeof(VkGraphicsPipelineCreateInfo)) output = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + if (val == typeof(VkPipelineCacheCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; + if (val == typeof(VkPipelineBinaryCreateInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; + if (val == typeof(VkPipelineBinaryHandlesInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; + if (val == typeof(VkPipelineBinaryKeyKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; + if (val == typeof(VkPipelineBinaryInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + if (val == typeof(VkReleaseCapturedPipelineDataInfoKHR)) output = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; + if (val == typeof(VkPipelineBinaryDataInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; + if (val == typeof(VkPipelineCreateInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; + if (val == typeof(VkPipelineLayoutCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + if (val == typeof(VkSamplerCreateInfo)) output = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + if (val == typeof(VkCommandPoolCreateInfo)) output = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + if (val == typeof(VkCommandBufferAllocateInfo)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + if (val == typeof(VkCommandBufferInheritanceInfo)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; + if (val == typeof(VkCommandBufferBeginInfo)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + if (val == typeof(VkRenderPassBeginInfo)) output = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + if (val == typeof(VkRenderPassCreateInfo)) output = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + if (val == typeof(VkEventCreateInfo)) output = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; + if (val == typeof(VkFenceCreateInfo)) output = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + if (val == typeof(VkSemaphoreCreateInfo)) output = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + if (val == typeof(VkQueryPoolCreateInfo)) output = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; + if (val == typeof(VkFramebufferCreateInfo)) output = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + if (val == typeof(VkSubmitInfo)) output = VK_STRUCTURE_TYPE_SUBMIT_INFO; + if (val == typeof(VkDisplayModeCreateInfoKHR)) output = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; + if (val == typeof(VkDisplaySurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkDisplaySurfaceStereoCreateInfoNV)) output = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; + if (val == typeof(VkDisplayPresentInfoKHR)) output = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; + if (val == typeof(VkAndroidSurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkViSurfaceCreateInfoNN)) output = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; + if (val == typeof(VkWaylandSurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkWin32SurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkXlibSurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkXcbSurfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; + if (val == typeof(VkDirectFBSurfaceCreateInfoEXT)) output = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; + if (val == typeof(VkImagePipeSurfaceCreateInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; + if (val == typeof(VkStreamDescriptorSurfaceCreateInfoGGP)) output = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; + if (val == typeof(VkScreenSurfaceCreateInfoQNX)) output = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; + if (val == typeof(VkSwapchainCreateInfoKHR)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + if (val == typeof(VkPresentInfoKHR)) output = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + if (val == typeof(VkDebugReportCallbackCreateInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; + if (val == typeof(VkValidationFlagsEXT)) output = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; + if (val == typeof(VkValidationFeaturesEXT)) output = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; + if (val == typeof(VkLayerSettingsCreateInfoEXT)) output = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + if (val == typeof(VkPipelineRasterizationStateRasterizationOrderAMD)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; + if (val == typeof(VkDebugMarkerObjectNameInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; + if (val == typeof(VkDebugMarkerObjectTagInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; + if (val == typeof(VkDebugMarkerMarkerInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + if (val == typeof(VkDedicatedAllocationImageCreateInfoNV)) output = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; + if (val == typeof(VkDedicatedAllocationBufferCreateInfoNV)) output = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; + if (val == typeof(VkDedicatedAllocationMemoryAllocateInfoNV)) output = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; + if (val == typeof(VkExternalMemoryImageCreateInfoNV)) output = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; + if (val == typeof(VkExportMemoryAllocateInfoNV)) output = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; + if (val == typeof(VkImportMemoryWin32HandleInfoNV)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; + if (val == typeof(VkExportMemoryWin32HandleInfoNV)) output = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; + if (val == typeof(VkWin32KeyedMutexAcquireReleaseInfoNV)) output = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; + if (val == typeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + if (val == typeof(VkDevicePrivateDataCreateInfo)) output = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; + if (val == typeof(VkPrivateDataSlotCreateInfo)) output = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO; + if (val == typeof(VkPhysicalDevicePrivateDataFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + if (val == typeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceClusterAccelerationStructurePropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; + if (val == typeof(VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV)) output = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + if (val == typeof(VkClusterAccelerationStructureClustersBottomLevelInputNV)) output = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; + if (val == typeof(VkClusterAccelerationStructureTriangleClusterInputNV)) output = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; + if (val == typeof(VkClusterAccelerationStructureMoveObjectsInputNV)) output = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; + if (val == typeof(VkClusterAccelerationStructureInputInfoNV)) output = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; + if (val == typeof(VkClusterAccelerationStructureCommandsInfoNV)) output = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; + if (val == typeof(VkPhysicalDeviceMultiDrawPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; + if (val == typeof(VkGraphicsShaderGroupCreateInfoNV)) output = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; + if (val == typeof(VkGraphicsPipelineShaderGroupsCreateInfoNV)) output = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; + if (val == typeof(VkIndirectCommandsLayoutTokenNV)) output = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; + if (val == typeof(VkIndirectCommandsLayoutCreateInfoNV)) output = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; + if (val == typeof(VkGeneratedCommandsInfoNV)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV; + if (val == typeof(VkGeneratedCommandsMemoryRequirementsInfoNV)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; + if (val == typeof(VkPipelineIndirectDeviceAddressInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; + if (val == typeof(VkPhysicalDeviceFeatures2)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + if (val == typeof(VkPhysicalDeviceProperties2)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + if (val == typeof(VkFormatProperties2)) output = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; + if (val == typeof(VkImageFormatProperties2)) output = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; + if (val == typeof(VkPhysicalDeviceImageFormatInfo2)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; + if (val == typeof(VkQueueFamilyProperties2)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; + if (val == typeof(VkPhysicalDeviceMemoryProperties2)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; + if (val == typeof(VkSparseImageFormatProperties2)) output = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2; + if (val == typeof(VkPhysicalDeviceSparseImageFormatInfo2)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; + if (val == typeof(VkPhysicalDevicePushDescriptorProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + if (val == typeof(VkPhysicalDeviceDriverProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; + if (val == typeof(VkPresentRegionsKHR)) output = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; + if (val == typeof(VkPhysicalDeviceVariablePointersFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + if (val == typeof(VkPhysicalDeviceExternalImageFormatInfo)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + if (val == typeof(VkExternalImageFormatProperties)) output = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES; + if (val == typeof(VkPhysicalDeviceExternalBufferInfo)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; + if (val == typeof(VkExternalBufferProperties)) output = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES; + if (val == typeof(VkPhysicalDeviceIDProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; + if (val == typeof(VkExternalMemoryImageCreateInfo)) output = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + if (val == typeof(VkExternalMemoryBufferCreateInfo)) output = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + if (val == typeof(VkExportMemoryAllocateInfo)) output = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; + if (val == typeof(VkImportMemoryWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkExportMemoryWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkImportMemoryZirconHandleInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; + if (val == typeof(VkMemoryZirconHandlePropertiesFUCHSIA)) output = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; + if (val == typeof(VkMemoryGetZirconHandleInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + if (val == typeof(VkMemoryWin32HandlePropertiesKHR)) output = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; + if (val == typeof(VkMemoryGetWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkImportMemoryFdInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR; + if (val == typeof(VkMemoryFdPropertiesKHR)) output = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR; + if (val == typeof(VkMemoryGetFdInfoKHR)) output = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; + if (val == typeof(VkWin32KeyedMutexAcquireReleaseInfoKHR)) output = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; + if (val == typeof(VkImportMemoryMetalHandleInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; + if (val == typeof(VkMemoryMetalHandlePropertiesEXT)) output = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT; + if (val == typeof(VkMemoryGetMetalHandleInfoEXT)) output = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceExternalSemaphoreInfo)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; + if (val == typeof(VkExternalSemaphoreProperties)) output = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES; + if (val == typeof(VkExportSemaphoreCreateInfo)) output = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO; + if (val == typeof(VkImportSemaphoreWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkExportSemaphoreWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkD3D12FenceSubmitInfoKHR)) output = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; + if (val == typeof(VkSemaphoreGetWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkImportSemaphoreFdInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; + if (val == typeof(VkSemaphoreGetFdInfoKHR)) output = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; + if (val == typeof(VkImportSemaphoreZirconHandleInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; + if (val == typeof(VkSemaphoreGetZirconHandleInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + if (val == typeof(VkPhysicalDeviceExternalFenceInfo)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; + if (val == typeof(VkExternalFenceProperties)) output = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES; + if (val == typeof(VkExportFenceCreateInfo)) output = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO; + if (val == typeof(VkImportFenceWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkExportFenceWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkFenceGetWin32HandleInfoKHR)) output = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; + if (val == typeof(VkImportFenceFdInfoKHR)) output = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR; + if (val == typeof(VkFenceGetFdInfoKHR)) output = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR; + if (val == typeof(VkPhysicalDeviceMultiviewFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + if (val == typeof(VkPhysicalDeviceMultiviewProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + if (val == typeof(VkRenderPassMultiviewCreateInfo)) output = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; + if (val == typeof(VkSurfaceCapabilities2EXT)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; + if (val == typeof(VkDisplayPowerInfoEXT)) output = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; + if (val == typeof(VkDeviceEventInfoEXT)) output = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; + if (val == typeof(VkDisplayEventInfoEXT)) output = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; + if (val == typeof(VkSwapchainCounterCreateInfoEXT)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceGroupProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES; + if (val == typeof(VkMemoryAllocateFlagsInfo)) output = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; + if (val == typeof(VkBindBufferMemoryInfo)) output = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO; + if (val == typeof(VkBindBufferMemoryDeviceGroupInfo)) output = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; + if (val == typeof(VkBindImageMemoryInfo)) output = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; + if (val == typeof(VkBindImageMemoryDeviceGroupInfo)) output = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; + if (val == typeof(VkDeviceGroupRenderPassBeginInfo)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; + if (val == typeof(VkDeviceGroupCommandBufferBeginInfo)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; + if (val == typeof(VkDeviceGroupSubmitInfo)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO; + if (val == typeof(VkDeviceGroupBindSparseInfo)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO; + if (val == typeof(VkDeviceGroupPresentCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; + if (val == typeof(VkImageSwapchainCreateInfoKHR)) output = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; + if (val == typeof(VkBindImageMemorySwapchainInfoKHR)) output = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; + if (val == typeof(VkAcquireNextImageInfoKHR)) output = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR; + if (val == typeof(VkDeviceGroupPresentInfoKHR)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR; + if (val == typeof(VkDeviceGroupDeviceCreateInfo)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; + if (val == typeof(VkDeviceGroupSwapchainCreateInfoKHR)) output = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; + if (val == typeof(VkDescriptorUpdateTemplateCreateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; + if (val == typeof(VkPhysicalDevicePresentIdFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + if (val == typeof(VkPresentIdKHR)) output = VK_STRUCTURE_TYPE_PRESENT_ID_KHR; + if (val == typeof(VkPhysicalDevicePresentId2FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + if (val == typeof(VkPresentId2KHR)) output = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; + if (val == typeof(VkPresentWait2InfoKHR)) output = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; + if (val == typeof(VkPhysicalDevicePresentWaitFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + if (val == typeof(VkPhysicalDevicePresentWait2FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + if (val == typeof(VkPhysicalDevicePresentTimingFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + if (val == typeof(VkPresentTimingSurfaceCapabilitiesEXT)) output = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; + if (val == typeof(VkSwapchainTimingPropertiesEXT)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT; + if (val == typeof(VkSwapchainTimeDomainPropertiesEXT)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT; + if (val == typeof(VkPastPresentationTimingInfoEXT)) output = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; + if (val == typeof(VkPastPresentationTimingPropertiesEXT)) output = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; + if (val == typeof(VkPastPresentationTimingEXT)) output = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; + if (val == typeof(VkPresentTimingsInfoEXT)) output = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; + if (val == typeof(VkPresentTimingInfoEXT)) output = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT; + if (val == typeof(VkSwapchainCalibratedTimestampInfoEXT)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; + if (val == typeof(VkHdrMetadataEXT)) output = VK_STRUCTURE_TYPE_HDR_METADATA_EXT; + if (val == typeof(VkHdrVividDynamicMetadataHUAWEI)) output = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; + if (val == typeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD)) output = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; + if (val == typeof(VkSwapchainDisplayNativeHdrCreateInfoAMD)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; + if (val == typeof(VkPresentTimesInfoGOOGLE)) output = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; + if (val == typeof(VkIOSSurfaceCreateInfoMVK)) output = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; + if (val == typeof(VkMacOSSurfaceCreateInfoMVK)) output = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; + if (val == typeof(VkMetalSurfaceCreateInfoEXT)) output = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; + if (val == typeof(VkPipelineViewportWScalingStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + if (val == typeof(VkPipelineViewportSwizzleStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; + if (val == typeof(VkPipelineDiscardRectangleStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; + if (val == typeof(VkRenderPassInputAttachmentAspectCreateInfo)) output = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; + if (val == typeof(VkPhysicalDeviceSurfaceInfo2KHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; + if (val == typeof(VkSurfaceCapabilities2KHR)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; + if (val == typeof(VkSurfaceFormat2KHR)) output = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; + if (val == typeof(VkDisplayProperties2KHR)) output = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; + if (val == typeof(VkDisplayPlaneProperties2KHR)) output = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; + if (val == typeof(VkDisplayModeProperties2KHR)) output = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; + if (val == typeof(VkDisplayModeStereoPropertiesNV)) output = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; + if (val == typeof(VkDisplayPlaneInfo2KHR)) output = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; + if (val == typeof(VkDisplayPlaneCapabilities2KHR)) output = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; + if (val == typeof(VkSharedPresentSurfaceCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; + if (val == typeof(VkPhysicalDevice16BitStorageFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + if (val == typeof(VkPhysicalDeviceSubgroupProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; + if (val == typeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + if (val == typeof(VkBufferMemoryRequirementsInfo2)) output = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2; + if (val == typeof(VkDeviceBufferMemoryRequirements)) output = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; + if (val == typeof(VkImageMemoryRequirementsInfo2)) output = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; + if (val == typeof(VkImageSparseMemoryRequirementsInfo2)) output = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; + if (val == typeof(VkDeviceImageMemoryRequirements)) output = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; + if (val == typeof(VkMemoryRequirements2)) output = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; + if (val == typeof(VkSparseImageMemoryRequirements2)) output = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; + if (val == typeof(VkPhysicalDevicePointClippingProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + if (val == typeof(VkMemoryDedicatedRequirements)) output = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; + if (val == typeof(VkMemoryDedicatedAllocateInfo)) output = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; + if (val == typeof(VkImageViewUsageCreateInfo)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; + if (val == typeof(VkImageViewSlicedCreateInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; + if (val == typeof(VkPipelineTessellationDomainOriginStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; + if (val == typeof(VkSamplerYcbcrConversionInfo)) output = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; + if (val == typeof(VkSamplerYcbcrConversionCreateInfo)) output = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO; + if (val == typeof(VkBindImagePlaneMemoryInfo)) output = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO; + if (val == typeof(VkImagePlaneMemoryRequirementsInfo)) output = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + if (val == typeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + if (val == typeof(VkSamplerYcbcrConversionImageFormatProperties)) output = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + if (val == typeof(VkTextureLODGatherFormatPropertiesAMD)) output = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; + if (val == typeof(VkConditionalRenderingBeginInfoEXT)) output = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; + if (val == typeof(VkProtectedSubmitInfo)) output = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; + if (val == typeof(VkPhysicalDeviceProtectedMemoryFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + if (val == typeof(VkPhysicalDeviceProtectedMemoryProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + if (val == typeof(VkDeviceQueueInfo2)) output = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2; + if (val == typeof(VkPipelineCoverageToColorStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceSamplerFilterMinmaxProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + if (val == typeof(VkSampleLocationsInfoEXT)) output = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; + if (val == typeof(VkRenderPassSampleLocationsBeginInfoEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; + if (val == typeof(VkPipelineSampleLocationsStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceSampleLocationsPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; + if (val == typeof(VkMultisamplePropertiesEXT)) output = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT; + if (val == typeof(VkSamplerReductionModeCreateInfo)) output = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; + if (val == typeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceMultiDrawFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; + if (val == typeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceInlineUniformBlockFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + if (val == typeof(VkPhysicalDeviceInlineUniformBlockProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + if (val == typeof(VkWriteDescriptorSetInlineUniformBlock)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + if (val == typeof(VkDescriptorPoolInlineUniformBlockCreateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; + if (val == typeof(VkPipelineCoverageModulationStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; + if (val == typeof(VkImageFormatListCreateInfo)) output = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; + if (val == typeof(VkValidationCacheCreateInfoEXT)) output = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT; + if (val == typeof(VkShaderModuleValidationCacheCreateInfoEXT)) output = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceMaintenance3Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + if (val == typeof(VkPhysicalDeviceMaintenance4Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + if (val == typeof(VkPhysicalDeviceMaintenance4Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + if (val == typeof(VkPhysicalDeviceMaintenance5Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + if (val == typeof(VkPhysicalDeviceMaintenance5Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; + if (val == typeof(VkPhysicalDeviceMaintenance6Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + if (val == typeof(VkPhysicalDeviceMaintenance6Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; + if (val == typeof(VkPhysicalDeviceMaintenance7FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance7PropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceLayeredApiPropertiesListKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; + if (val == typeof(VkPhysicalDeviceLayeredApiPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceLayeredApiVulkanPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance8FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance9FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance9PropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance10PropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceMaintenance10FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; + if (val == typeof(VkQueueFamilyOwnershipTransferPropertiesKHR)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; + if (val == typeof(VkRenderingAreaInfo)) output = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; + if (val == typeof(VkDescriptorSetLayoutSupport)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; + if (val == typeof(VkPhysicalDeviceShaderDrawParametersFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderFloat16Int8Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + if (val == typeof(VkPhysicalDeviceFloatControlsProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; + if (val == typeof(VkPhysicalDeviceHostQueryResetFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + if (val == typeof(VkDeviceQueueGlobalPriorityCreateInfo)) output = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; + if (val == typeof(VkPhysicalDeviceGlobalPriorityQueryFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + if (val == typeof(VkQueueFamilyGlobalPriorityProperties)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; + if (val == typeof(VkDebugUtilsObjectNameInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; + if (val == typeof(VkDebugUtilsObjectTagInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT; + if (val == typeof(VkDebugUtilsLabelEXT)) output = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; + if (val == typeof(VkDebugUtilsMessengerCreateInfoEXT)) output = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + if (val == typeof(VkDebugUtilsMessengerCallbackDataEXT)) output = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; + if (val == typeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; + if (val == typeof(VkDeviceDeviceMemoryReportCreateInfoEXT)) output = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; + if (val == typeof(VkDeviceMemoryReportCallbackDataEXT)) output = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; + if (val == typeof(VkImportMemoryHostPointerInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; + if (val == typeof(VkMemoryHostPointerPropertiesEXT)) output = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + if (val == typeof(VkCalibratedTimestampInfoKHR)) output = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; + if (val == typeof(VkPhysicalDeviceShaderCorePropertiesAMD)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; + if (val == typeof(VkPhysicalDeviceShaderCoreProperties2AMD)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; + if (val == typeof(VkPipelineRasterizationConservativeStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDescriptorIndexingFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + if (val == typeof(VkPhysicalDeviceDescriptorIndexingProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + if (val == typeof(VkDescriptorSetLayoutBindingFlagsCreateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; + if (val == typeof(VkDescriptorSetVariableDescriptorCountAllocateInfo)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + if (val == typeof(VkDescriptorSetVariableDescriptorCountLayoutSupport)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; + if (val == typeof(VkAttachmentDescription2)) output = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; + if (val == typeof(VkAttachmentReference2)) output = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; + if (val == typeof(VkSubpassDescription2)) output = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; + if (val == typeof(VkSubpassDependency2)) output = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; + if (val == typeof(VkRenderPassCreateInfo2)) output = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; + if (val == typeof(VkSubpassBeginInfo)) output = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; + if (val == typeof(VkSubpassEndInfo)) output = VK_STRUCTURE_TYPE_SUBPASS_END_INFO; + if (val == typeof(VkPhysicalDeviceTimelineSemaphoreFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + if (val == typeof(VkPhysicalDeviceTimelineSemaphoreProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + if (val == typeof(VkSemaphoreTypeCreateInfo)) output = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; + if (val == typeof(VkTimelineSemaphoreSubmitInfo)) output = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; + if (val == typeof(VkSemaphoreWaitInfo)) output = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO; + if (val == typeof(VkSemaphoreSignalInfo)) output = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO; + if (val == typeof(VkPipelineVertexInputDivisorStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; + if (val == typeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceVertexAttributeDivisorProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + if (val == typeof(VkPhysicalDevicePCIBusInfoPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; + if (val == typeof(VkImportAndroidHardwareBufferInfoANDROID)) output = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + if (val == typeof(VkAndroidHardwareBufferUsageANDROID)) output = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; + if (val == typeof(VkAndroidHardwareBufferPropertiesANDROID)) output = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; + if (val == typeof(VkMemoryGetAndroidHardwareBufferInfoANDROID)) output = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + if (val == typeof(VkAndroidHardwareBufferFormatPropertiesANDROID)) output = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; + if (val == typeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; + if (val == typeof(VkExternalFormatANDROID)) output = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; + if (val == typeof(VkPhysicalDevice8BitStorageFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + if (val == typeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceVulkanMemoryModelFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderAtomicInt64Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceVertexAttributeDivisorFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + if (val == typeof(VkQueueFamilyCheckpointPropertiesNV)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; + if (val == typeof(VkCheckpointDataNV)) output = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; + if (val == typeof(VkPhysicalDeviceDepthStencilResolveProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + if (val == typeof(VkSubpassDescriptionDepthStencilResolve)) output = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; + if (val == typeof(VkImageViewASTCDecodeModeEXT)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; + if (val == typeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + if (val == typeof(VkPipelineRasterizationStateStreamCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + if (val == typeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceExclusiveScissorFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + if (val == typeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceCornerSampledImageFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceMemoryDecompressionFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceMemoryDecompressionPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT; + if (val == typeof(VkPipelineViewportShadingRateImageStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceShadingRateImageFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceShadingRateImagePropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + if (val == typeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceMeshShaderFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceMeshShaderPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceMeshShaderFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceMeshShaderPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; + if (val == typeof(VkRayTracingShaderGroupCreateInfoNV)) output = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; + if (val == typeof(VkRayTracingShaderGroupCreateInfoKHR)) output = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; + if (val == typeof(VkRayTracingPipelineCreateInfoNV)) output = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV; + if (val == typeof(VkRayTracingPipelineCreateInfoKHR)) output = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; + if (val == typeof(VkGeometryTrianglesNV)) output = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV; + if (val == typeof(VkGeometryAABBNV)) output = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV; + if (val == typeof(VkGeometryNV)) output = VK_STRUCTURE_TYPE_GEOMETRY_NV; + if (val == typeof(VkAccelerationStructureInfoNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV; + if (val == typeof(VkAccelerationStructureCreateInfoNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + if (val == typeof(VkBindAccelerationStructureMemoryInfoNV)) output = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; + if (val == typeof(VkWriteDescriptorSetAccelerationStructureKHR)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; + if (val == typeof(VkWriteDescriptorSetAccelerationStructureNV)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; + if (val == typeof(VkAccelerationStructureMemoryRequirementsInfoNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; + if (val == typeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRayQueryFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceRayTracingPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + if (val == typeof(VkDrmFormatModifierPropertiesListEXT)) output = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; + if (val == typeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; + if (val == typeof(VkImageDrmFormatModifierListCreateInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; + if (val == typeof(VkImageDrmFormatModifierExplicitCreateInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; + if (val == typeof(VkImageDrmFormatModifierPropertiesEXT)) output = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; + if (val == typeof(VkImageStencilUsageCreateInfo)) output = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; + if (val == typeof(VkDeviceMemoryOverallocationCreateInfoAMD)) output = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; + if (val == typeof(VkRenderPassFragmentDensityMapCreateInfoEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; + if (val == typeof(VkRenderPassFragmentDensityMapOffsetEndInfoEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; + if (val == typeof(VkPhysicalDeviceScalarBlockLayoutFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + if (val == typeof(VkSurfaceProtectedCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; + if (val == typeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + if (val == typeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + if (val == typeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + if (val == typeof(VkMemoryPriorityAllocateInfoEXT)) output = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; + if (val == typeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceBufferDeviceAddressFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + if (val == typeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + if (val == typeof(VkBufferDeviceAddressInfo)) output = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO; + if (val == typeof(VkBufferOpaqueCaptureAddressCreateInfo)) output = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + if (val == typeof(VkBufferDeviceAddressCreateInfoEXT)) output = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceImageViewImageFormatInfoEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; + if (val == typeof(VkFilterCubicImageViewImageFormatPropertiesEXT)) output = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceImagelessFramebufferFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + if (val == typeof(VkFramebufferAttachmentsCreateInfo)) output = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; + if (val == typeof(VkFramebufferAttachmentImageInfo)) output = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; + if (val == typeof(VkRenderPassAttachmentBeginInfo)) output = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; + if (val == typeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + if (val == typeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; + if (val == typeof(VkCooperativeMatrixPropertiesNV)) output = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + if (val == typeof(VkImageViewHandleInfoNVX)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; + if (val == typeof(VkImageViewAddressPropertiesNVX)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; + if (val == typeof(VkPresentFrameTokenGGP)) output = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; + if (val == typeof(VkPipelineCreationFeedbackCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + if (val == typeof(VkSurfaceFullScreenExclusiveInfoEXT)) output = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; + if (val == typeof(VkSurfaceFullScreenExclusiveWin32InfoEXT)) output = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; + if (val == typeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; + if (val == typeof(VkPhysicalDevicePresentBarrierFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + if (val == typeof(VkSurfaceCapabilitiesPresentBarrierNV)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; + if (val == typeof(VkSwapchainPresentBarrierCreateInfoNV)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + if (val == typeof(VkPhysicalDevicePerformanceQueryPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; + if (val == typeof(VkPerformanceCounterKHR)) output = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR; + if (val == typeof(VkPerformanceCounterDescriptionKHR)) output = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR; + if (val == typeof(VkQueryPoolPerformanceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; + if (val == typeof(VkAcquireProfilingLockInfoKHR)) output = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR; + if (val == typeof(VkPerformanceQuerySubmitInfoKHR)) output = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; + if (val == typeof(VkHeadlessSurfaceCreateInfoEXT)) output = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + if (val == typeof(VkPipelineCoverageReductionStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; + if (val == typeof(VkFramebufferMixedSamplesCombinationNV)) output = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; + if (val == typeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + if (val == typeof(VkInitializePerformanceApiInfoINTEL)) output = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; + if (val == typeof(VkQueryPoolPerformanceQueryCreateInfoINTEL)) output = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; + if (val == typeof(VkPerformanceMarkerInfoINTEL)) output = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL; + if (val == typeof(VkPerformanceStreamMarkerInfoINTEL)) output = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL; + if (val == typeof(VkPerformanceOverrideInfoINTEL)) output = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL; + if (val == typeof(VkPerformanceConfigurationAcquireInfoINTEL)) output = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; + if (val == typeof(VkPhysicalDeviceShaderClockFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceIndexTypeUint8Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + if (val == typeof(VkAttachmentReferenceStencilLayout)) output = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; + if (val == typeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + if (val == typeof(VkAttachmentDescriptionStencilLayout)) output = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; + if (val == typeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + if (val == typeof(VkPipelineInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR; + if (val == typeof(VkPipelineExecutablePropertiesKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR; + if (val == typeof(VkPipelineExecutableInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; + if (val == typeof(VkPipelineExecutableStatisticKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; + if (val == typeof(VkPipelineExecutableInternalRepresentationKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; + if (val == typeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + if (val == typeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceTexelBufferAlignmentProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + if (val == typeof(VkPhysicalDeviceSubgroupSizeControlFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + if (val == typeof(VkPhysicalDeviceSubgroupSizeControlProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + if (val == typeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + if (val == typeof(VkSubpassShadingPipelineCreateInfoHUAWEI)) output = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; + if (val == typeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; + if (val == typeof(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; + if (val == typeof(VkMemoryOpaqueCaptureAddressAllocateInfo)) output = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + if (val == typeof(VkDeviceMemoryOpaqueCaptureAddressInfo)) output = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; + if (val == typeof(VkPhysicalDeviceLineRasterizationFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + if (val == typeof(VkPhysicalDeviceLineRasterizationProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + if (val == typeof(VkPipelineRasterizationLineStateCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; + if (val == typeof(VkPhysicalDevicePipelineCreationCacheControlFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + if (val == typeof(VkPhysicalDeviceVulkan11Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + if (val == typeof(VkPhysicalDeviceVulkan11Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + if (val == typeof(VkPhysicalDeviceVulkan12Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + if (val == typeof(VkPhysicalDeviceVulkan12Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + if (val == typeof(VkPhysicalDeviceVulkan13Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + if (val == typeof(VkPhysicalDeviceVulkan13Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + if (val == typeof(VkPhysicalDeviceVulkan14Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + if (val == typeof(VkPhysicalDeviceVulkan14Properties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; + if (val == typeof(VkPipelineCompilerControlCreateInfoAMD)) output = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + if (val == typeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + if (val == typeof(VkPhysicalDeviceToolProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES; + if (val == typeof(VkSamplerCustomBorderColorCreateInfoEXT)) output = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + if (val == typeof(VkSamplerBorderColorComponentMappingCreateInfoEXT)) output = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + if (val == typeof(VkAccelerationStructureGeometryTrianglesDataKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; + if (val == typeof(VkAccelerationStructureGeometryAabbsDataKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; + if (val == typeof(VkAccelerationStructureGeometryInstancesDataKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; + if (val == typeof(VkAccelerationStructureGeometryLinearSweptSpheresDataNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; + if (val == typeof(VkAccelerationStructureGeometrySpheresDataNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; + if (val == typeof(VkAccelerationStructureGeometryKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR; + if (val == typeof(VkAccelerationStructureBuildGeometryInfoKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; + if (val == typeof(VkAccelerationStructureCreateInfoKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR; + if (val == typeof(VkAccelerationStructureDeviceAddressInfoKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; + if (val == typeof(VkAccelerationStructureVersionInfoKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR; + if (val == typeof(VkCopyAccelerationStructureInfoKHR)) output = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; + if (val == typeof(VkCopyAccelerationStructureToMemoryInfoKHR)) output = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; + if (val == typeof(VkCopyMemoryToAccelerationStructureInfoKHR)) output = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; + if (val == typeof(VkRayTracingPipelineInterfaceCreateInfoKHR)) output = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; + if (val == typeof(VkPipelineLibraryCreateInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; + if (val == typeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + if (val == typeof(VkRenderPassTransformBeginInfoQCOM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; + if (val == typeof(VkCopyCommandTransformInfoQCOM)) output = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM; + if (val == typeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; + if (val == typeof(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + if (val == typeof(VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; + if (val == typeof(VkPartitionedAccelerationStructureFlagsNV)) output = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; + if (val == typeof(VkWriteDescriptorSetPartitionedAccelerationStructureNV)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; + if (val == typeof(VkPartitionedAccelerationStructureInstancesInputNV)) output = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; + if (val == typeof(VkBuildPartitionedAccelerationStructureInfoNV)) output = VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; + if (val == typeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + if (val == typeof(VkDeviceDiagnosticsConfigCreateInfoNV)) output = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; + if (val == typeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRobustness2FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRobustness2PropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceImageRobustnessFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + if (val == typeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + if (val == typeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; + if (val == typeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDevice4444FormatsFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + if (val == typeof(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + if (val == typeof(VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI; + if (val == typeof(VkBufferCopy2)) output = VK_STRUCTURE_TYPE_BUFFER_COPY_2; + if (val == typeof(VkImageCopy2)) output = VK_STRUCTURE_TYPE_IMAGE_COPY_2; + if (val == typeof(VkImageBlit2)) output = VK_STRUCTURE_TYPE_IMAGE_BLIT_2; + if (val == typeof(VkBufferImageCopy2)) output = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2; + if (val == typeof(VkImageResolve2)) output = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2; + if (val == typeof(VkCopyBufferInfo2)) output = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2; + if (val == typeof(VkCopyImageInfo2)) output = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2; + if (val == typeof(VkBlitImageInfo2)) output = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2; + if (val == typeof(VkCopyBufferToImageInfo2)) output = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2; + if (val == typeof(VkCopyImageToBufferInfo2)) output = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2; + if (val == typeof(VkResolveImageInfo2)) output = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2; + if (val == typeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + if (val == typeof(VkFragmentShadingRateAttachmentInfoKHR)) output = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + if (val == typeof(VkPipelineFragmentShadingRateStateCreateInfoKHR)) output = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; + if (val == typeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceFragmentShadingRateKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; + if (val == typeof(VkPhysicalDeviceShaderTerminateInvocationFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + if (val == typeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; + if (val == typeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV)) output = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + if (val == typeof(VkAccelerationStructureBuildSizesInfoKHR)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; + if (val == typeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + if (val == typeof(VkMutableDescriptorTypeCreateInfoEXT)) output = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDepthClipControlFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + if (val == typeof(VkBeginCustomResolveInfoEXT)) output = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceCustomResolveFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; + if (val == typeof(VkCustomResolveCreateInfoEXT)) output = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + if (val == typeof(VkGeneratedCommandsPipelineInfoEXT)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; + if (val == typeof(VkGeneratedCommandsShaderInfoEXT)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; + if (val == typeof(VkGeneratedCommandsMemoryRequirementsInfoEXT)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; + if (val == typeof(VkIndirectExecutionSetPipelineInfoEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; + if (val == typeof(VkIndirectExecutionSetShaderLayoutInfoEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; + if (val == typeof(VkIndirectExecutionSetShaderInfoEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; + if (val == typeof(VkIndirectExecutionSetCreateInfoEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; + if (val == typeof(VkGeneratedCommandsInfoEXT)) output = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; + if (val == typeof(VkWriteIndirectExecutionSetPipelineEXT)) output = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; + if (val == typeof(VkWriteIndirectExecutionSetShaderEXT)) output = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; + if (val == typeof(VkIndirectCommandsLayoutCreateInfoEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; + if (val == typeof(VkIndirectCommandsLayoutTokenEXT)) output = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; + if (val == typeof(VkPipelineViewportDepthClipControlCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDepthClampControlFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + if (val == typeof(VkPipelineViewportDepthClampControlCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + if (val == typeof(VkVertexInputBindingDescription2EXT)) output = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; + if (val == typeof(VkVertexInputAttributeDescription2EXT)) output = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; + if (val == typeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + if (val == typeof(VkPipelineColorWriteCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; + if (val == typeof(VkMemoryBarrier2)) output = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2; + if (val == typeof(VkImageMemoryBarrier2)) output = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2; + if (val == typeof(VkBufferMemoryBarrier2)) output = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2; + if (val == typeof(VkMemoryBarrierAccessFlags3KHR)) output = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; + if (val == typeof(VkDependencyInfo)) output = VK_STRUCTURE_TYPE_DEPENDENCY_INFO; + if (val == typeof(VkSemaphoreSubmitInfo)) output = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO; + if (val == typeof(VkCommandBufferSubmitInfo)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO; + if (val == typeof(VkSubmitInfo2)) output = VK_STRUCTURE_TYPE_SUBMIT_INFO_2; + if (val == typeof(VkQueueFamilyCheckpointProperties2NV)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; + if (val == typeof(VkCheckpointData2NV)) output = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; + if (val == typeof(VkPhysicalDeviceSynchronization2Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + if (val == typeof(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceHostImageCopyFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + if (val == typeof(VkPhysicalDeviceHostImageCopyProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; + if (val == typeof(VkMemoryToImageCopy)) output = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; + if (val == typeof(VkImageToMemoryCopy)) output = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; + if (val == typeof(VkCopyMemoryToImageInfo)) output = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; + if (val == typeof(VkCopyImageToMemoryInfo)) output = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; + if (val == typeof(VkCopyImageToImageInfo)) output = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; + if (val == typeof(VkHostImageLayoutTransitionInfo)) output = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; + if (val == typeof(VkSubresourceHostMemcpySize)) output = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; + if (val == typeof(VkHostImageCopyDevicePerformanceQuery)) output = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; + if (val == typeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + if (val == typeof(VkSurfaceCapabilitiesPresentId2KHR)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; + if (val == typeof(VkSurfaceCapabilitiesPresentWait2KHR)) output = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; + if (val == typeof(VkSubpassResolvePerformanceQueryEXT)) output = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; + if (val == typeof(VkMultisampledRenderToSingleSampledInfoEXT)) output = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; + if (val == typeof(VkPhysicalDevicePipelineProtectedAccessFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + if (val == typeof(VkQueueFamilyVideoPropertiesKHR)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; + if (val == typeof(VkQueueFamilyQueryResultStatusPropertiesKHR)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; + if (val == typeof(VkVideoProfileListInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoFormatInfoKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; + if (val == typeof(VkVideoFormatPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; + if (val == typeof(VkVideoEncodeQuantizationMapCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeH264QuantizationMapCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeH265QuantizationMapCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeAV1QuantizationMapCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + if (val == typeof(VkVideoFormatQuantizationMapPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + if (val == typeof(VkVideoFormatH265QuantizationMapPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + if (val == typeof(VkVideoFormatAV1QuantizationMapPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + if (val == typeof(VkVideoProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; + if (val == typeof(VkVideoCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; + if (val == typeof(VkVideoSessionMemoryRequirementsKHR)) output = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; + if (val == typeof(VkBindVideoSessionMemoryInfoKHR)) output = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR; + if (val == typeof(VkVideoPictureResourceInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR; + if (val == typeof(VkVideoReferenceSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR; + if (val == typeof(VkVideoDecodeCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + if (val == typeof(VkVideoDecodeUsageInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + if (val == typeof(VkVideoDecodeInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoMaintenance1FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceVideoMaintenance2FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; + if (val == typeof(VkVideoInlineQueryInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; + if (val == typeof(VkVideoDecodeH264ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; + if (val == typeof(VkVideoDecodeH264CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; + if (val == typeof(VkVideoDecodeH264SessionParametersAddInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; + if (val == typeof(VkVideoDecodeH264SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoDecodeH264InlineSessionParametersInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; + if (val == typeof(VkVideoDecodeH264PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; + if (val == typeof(VkVideoDecodeH264DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; + if (val == typeof(VkVideoDecodeH265ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; + if (val == typeof(VkVideoDecodeH265CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; + if (val == typeof(VkVideoDecodeH265SessionParametersAddInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; + if (val == typeof(VkVideoDecodeH265SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoDecodeH265InlineSessionParametersInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; + if (val == typeof(VkVideoDecodeH265PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; + if (val == typeof(VkVideoDecodeH265DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + if (val == typeof(VkVideoDecodeVP9ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + if (val == typeof(VkVideoDecodeVP9CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + if (val == typeof(VkVideoDecodeVP9PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; + if (val == typeof(VkVideoDecodeAV1ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + if (val == typeof(VkVideoDecodeAV1CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + if (val == typeof(VkVideoDecodeAV1SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoDecodeAV1InlineSessionParametersInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; + if (val == typeof(VkVideoDecodeAV1PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; + if (val == typeof(VkVideoDecodeAV1DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; + if (val == typeof(VkVideoSessionCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; + if (val == typeof(VkVideoSessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoSessionParametersUpdateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; + if (val == typeof(VkVideoEncodeSessionParametersGetInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; + if (val == typeof(VkVideoEncodeSessionParametersFeedbackInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + if (val == typeof(VkVideoBeginCodingInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; + if (val == typeof(VkVideoEndCodingInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; + if (val == typeof(VkVideoCodingControlInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; + if (val == typeof(VkVideoEncodeUsageInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; + if (val == typeof(VkVideoEncodeInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; + if (val == typeof(VkVideoEncodeQuantizationMapInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; + if (val == typeof(VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + if (val == typeof(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR)) output = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeQualityLevelInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + if (val == typeof(VkVideoEncodeQualityLevelPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; + if (val == typeof(VkVideoEncodeRateControlInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; + if (val == typeof(VkVideoEncodeRateControlLayerInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; + if (val == typeof(VkVideoEncodeCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeH264CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeH264QualityLevelPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; + if (val == typeof(VkVideoEncodeH264SessionCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeH264SessionParametersAddInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; + if (val == typeof(VkVideoEncodeH264SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeH264SessionParametersGetInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR; + if (val == typeof(VkVideoEncodeH264SessionParametersFeedbackInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + if (val == typeof(VkVideoEncodeH264DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; + if (val == typeof(VkVideoEncodeH264PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR; + if (val == typeof(VkVideoEncodeH264ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; + if (val == typeof(VkVideoEncodeH264NaluSliceInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR; + if (val == typeof(VkVideoEncodeH264RateControlInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; + if (val == typeof(VkVideoEncodeH264GopRemainingFrameInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR; + if (val == typeof(VkVideoEncodeH264RateControlLayerInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; + if (val == typeof(VkVideoEncodeH265CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeH265QualityLevelPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR; + if (val == typeof(VkVideoEncodeH265SessionCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeH265SessionParametersAddInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; + if (val == typeof(VkVideoEncodeH265SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeH265SessionParametersGetInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR; + if (val == typeof(VkVideoEncodeH265SessionParametersFeedbackInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + if (val == typeof(VkVideoEncodeH265PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR; + if (val == typeof(VkVideoEncodeH265NaluSliceSegmentInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR; + if (val == typeof(VkVideoEncodeH265RateControlInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR; + if (val == typeof(VkVideoEncodeH265GopRemainingFrameInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR; + if (val == typeof(VkVideoEncodeH265RateControlLayerInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR; + if (val == typeof(VkVideoEncodeH265ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; + if (val == typeof(VkVideoEncodeH265DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1CapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeAV1QualityLevelPropertiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + if (val == typeof(VkVideoEncodeAV1SessionCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1SessionParametersCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1DpbSlotInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1PictureInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1ProfileInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1RateControlInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1GopRemainingFrameInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; + if (val == typeof(VkVideoEncodeAV1RateControlLayerInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; + if (val == typeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + if (val == typeof(VkCommandBufferInheritanceViewportScissorInfoNV)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; + if (val == typeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceProvokingVertexFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceProvokingVertexPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; + if (val == typeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; + if (val == typeof(VkVideoEncodeIntraRefreshCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + if (val == typeof(VkVideoEncodeSessionIntraRefreshCreateInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; + if (val == typeof(VkVideoEncodeIntraRefreshInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; + if (val == typeof(VkVideoReferenceIntraRefreshInfoKHR)) output = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; + if (val == typeof(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + if (val == typeof(VkCuModuleCreateInfoNVX)) output = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; + if (val == typeof(VkCuModuleTexturingModeCreateInfoNVX)) output = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; + if (val == typeof(VkCuFunctionCreateInfoNVX)) output = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; + if (val == typeof(VkCuLaunchInfoNVX)) output = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; + if (val == typeof(VkPhysicalDeviceDescriptorBufferFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceDescriptorBufferPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + if (val == typeof(VkDescriptorAddressInfoEXT)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT; + if (val == typeof(VkDescriptorBufferBindingInfoEXT)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT; + if (val == typeof(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; + if (val == typeof(VkDescriptorGetInfoEXT)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT; + if (val == typeof(VkBufferCaptureDescriptorDataInfoEXT)) output = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + if (val == typeof(VkImageCaptureDescriptorDataInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + if (val == typeof(VkImageViewCaptureDescriptorDataInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + if (val == typeof(VkSamplerCaptureDescriptorDataInfoEXT)) output = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + if (val == typeof(VkAccelerationStructureCaptureDescriptorDataInfoEXT)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + if (val == typeof(VkOpaqueCaptureDescriptorDataCreateInfoEXT)) output = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceShaderIntegerDotProductFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderIntegerDotProductProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; + if (val == typeof(VkPhysicalDeviceDrmPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceShaderFmaFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceRayTracingValidationFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; + if (val == typeof(VkAccelerationStructureGeometryMotionTrianglesDataNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; + if (val == typeof(VkAccelerationStructureMotionInfoNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV; + if (val == typeof(VkMemoryGetRemoteAddressInfoNV)) output = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV; + if (val == typeof(VkImportMemoryBufferCollectionFUCHSIA)) output = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; + if (val == typeof(VkBufferCollectionImageCreateInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; + if (val == typeof(VkBufferCollectionBufferCreateInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; + if (val == typeof(VkBufferCollectionCreateInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; + if (val == typeof(VkBufferCollectionPropertiesFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; + if (val == typeof(VkBufferConstraintsInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; + if (val == typeof(VkSysmemColorSpaceFUCHSIA)) output = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; + if (val == typeof(VkImageFormatConstraintsInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; + if (val == typeof(VkImageConstraintsInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; + if (val == typeof(VkBufferCollectionConstraintsInfoFUCHSIA)) output = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; + if (val == typeof(VkCudaModuleCreateInfoNV)) output = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; + if (val == typeof(VkCudaFunctionCreateInfoNV)) output = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; + if (val == typeof(VkCudaLaunchInfoNV)) output = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; + if (val == typeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + if (val == typeof(VkFormatProperties3)) output = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; + if (val == typeof(VkDrmFormatModifierPropertiesList2EXT)) output = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; + if (val == typeof(VkAndroidHardwareBufferFormatProperties2ANDROID)) output = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; + if (val == typeof(VkPipelineRenderingCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; + if (val == typeof(VkRenderingInfo)) output = VK_STRUCTURE_TYPE_RENDERING_INFO; + if (val == typeof(VkRenderingEndInfoKHR)) output = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR; + if (val == typeof(VkRenderingAttachmentInfo)) output = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO; + if (val == typeof(VkRenderingFragmentShadingRateAttachmentInfoKHR)) output = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + if (val == typeof(VkRenderingFragmentDensityMapAttachmentInfoEXT)) output = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDynamicRenderingFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + if (val == typeof(VkCommandBufferInheritanceRenderingInfo)) output = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; + if (val == typeof(VkAttachmentSampleCountInfoAMD)) output = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + if (val == typeof(VkMultiviewPerViewAttributesInfoNVX)) output = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; + if (val == typeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + if (val == typeof(VkImageViewMinLodCreateInfoEXT)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + if (val == typeof(VkPhysicalDevicePipelineBinaryFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + if (val == typeof(VkDevicePipelineBinaryInternalCacheControlKHR)) output = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + if (val == typeof(VkPhysicalDevicePipelineBinaryPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + if (val == typeof(VkGraphicsPipelineLibraryCreateInfoEXT)) output = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + if (val == typeof(VkDescriptorSetBindingReferenceVALVE)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; + if (val == typeof(VkDescriptorSetLayoutHostMappingInfoVALVE)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; + if (val == typeof(VkPhysicalDeviceNestedCommandBufferFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceNestedCommandBufferPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + if (val == typeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; + if (val == typeof(VkShaderModuleIdentifierEXT)) output = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT; + if (val == typeof(VkImageCompressionControlEXT)) output = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + if (val == typeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + if (val == typeof(VkImageCompressionPropertiesEXT)) output = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + if (val == typeof(VkImageSubresource2)) output = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; + if (val == typeof(VkSubresourceLayout2)) output = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; + if (val == typeof(VkRenderPassCreationControlEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT; + if (val == typeof(VkRenderPassCreationFeedbackCreateInfoEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; + if (val == typeof(VkRenderPassSubpassFeedbackCreateInfoEXT)) output = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + if (val == typeof(VkMicromapBuildInfoEXT)) output = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT; + if (val == typeof(VkMicromapCreateInfoEXT)) output = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT; + if (val == typeof(VkMicromapVersionInfoEXT)) output = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT; + if (val == typeof(VkCopyMicromapInfoEXT)) output = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT; + if (val == typeof(VkCopyMicromapToMemoryInfoEXT)) output = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT; + if (val == typeof(VkCopyMemoryToMicromapInfoEXT)) output = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT; + if (val == typeof(VkMicromapBuildSizesInfoEXT)) output = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT; + if (val == typeof(VkPhysicalDeviceOpacityMicromapFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceOpacityMicromapPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; + if (val == typeof(VkAccelerationStructureTrianglesOpacityMicromapEXT)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; + if (val == typeof(VkPhysicalDeviceDisplacementMicromapFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceDisplacementMicromapPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; + if (val == typeof(VkAccelerationStructureTrianglesDisplacementMicromapNV)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; + if (val == typeof(VkPipelinePropertiesIdentifierEXT)) output = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT; + if (val == typeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; + if (val == typeof(VkExternalMemoryAcquireUnmodifiedEXT)) output = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; + if (val == typeof(VkExportMetalObjectCreateInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; + if (val == typeof(VkExportMetalObjectsInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT; + if (val == typeof(VkExportMetalDeviceInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT; + if (val == typeof(VkExportMetalCommandQueueInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; + if (val == typeof(VkExportMetalBufferInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT; + if (val == typeof(VkImportMetalBufferInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT; + if (val == typeof(VkExportMetalTextureInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT; + if (val == typeof(VkImportMetalTextureInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT; + if (val == typeof(VkExportMetalIOSurfaceInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT; + if (val == typeof(VkImportMetalIOSurfaceInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT; + if (val == typeof(VkExportMetalSharedEventInfoEXT)) output = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT; + if (val == typeof(VkImportMetalSharedEventInfoEXT)) output = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT; + if (val == typeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + if (val == typeof(VkPhysicalDevicePipelineRobustnessFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + if (val == typeof(VkPipelineRobustnessCreateInfo)) output = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; + if (val == typeof(VkPhysicalDevicePipelineRobustnessProperties)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; + if (val == typeof(VkImageViewSampleWeightCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceImageProcessingFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceImageProcessingPropertiesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; + if (val == typeof(VkPhysicalDeviceTilePropertiesFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + if (val == typeof(VkTilePropertiesQCOM)) output = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM; + if (val == typeof(VkTileMemoryBindInfoQCOM)) output = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceAmigoProfilingFeaturesSEC)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; + if (val == typeof(VkAmigoProfilingSubmitInfoSEC)) output = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC; + if (val == typeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + if (val == typeof(VkAttachmentFeedbackLoopInfoEXT)) output = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; + if (val == typeof(VkPhysicalDeviceAddressBindingReportFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + if (val == typeof(VkRenderingAttachmentFlagsInfoKHR)) output = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR; + if (val == typeof(VkResolveImageModeInfoKHR)) output = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR; + if (val == typeof(VkDeviceAddressBindingCallbackDataEXT)) output = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; + if (val == typeof(VkPhysicalDeviceOpticalFlowFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceOpticalFlowPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; + if (val == typeof(VkOpticalFlowImageFormatInfoNV)) output = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; + if (val == typeof(VkOpticalFlowImageFormatPropertiesNV)) output = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; + if (val == typeof(VkOpticalFlowSessionCreateInfoNV)) output = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV; + if (val == typeof(VkOpticalFlowSessionCreatePrivateDataInfoNV)) output = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; + if (val == typeof(VkOpticalFlowExecuteInfoNV)) output = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; + if (val == typeof(VkPhysicalDeviceFaultFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + if (val == typeof(VkDeviceFaultCountsEXT)) output = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; + if (val == typeof(VkDeviceFaultInfoEXT)) output = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; + if (val == typeof(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + if (val == typeof(VkDepthBiasInfoEXT)) output = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT; + if (val == typeof(VkDepthBiasRepresentationInfoEXT)) output = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; + if (val == typeof(VkDecompressMemoryInfoEXT)) output = VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT; + if (val == typeof(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + if (val == typeof(VkFrameBoundaryEXT)) output = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; + if (val == typeof(VkPhysicalDeviceFrameBoundaryFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + if (val == typeof(VkSurfacePresentModeKHR)) output = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; + if (val == typeof(VkSurfacePresentScalingCapabilitiesKHR)) output = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; + if (val == typeof(VkSurfacePresentModeCompatibilityKHR)) output = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; + if (val == typeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + if (val == typeof(VkSwapchainPresentFenceInfoKHR)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR; + if (val == typeof(VkSwapchainPresentModesCreateInfoKHR)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; + if (val == typeof(VkSwapchainPresentModeInfoKHR)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR; + if (val == typeof(VkSwapchainPresentScalingCreateInfoKHR)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; + if (val == typeof(VkReleaseSwapchainImagesInfoKHR)) output = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR; + if (val == typeof(VkPhysicalDeviceDepthBiasControlFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT; + if (val == typeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; + if (val == typeof(VkDirectDriverLoadingInfoLUNARG)) output = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; + if (val == typeof(VkDirectDriverLoadingListLUNARG)) output = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; + if (val == typeof(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + if (val == typeof(VkDeviceImageSubresourceInfo)) output = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; + if (val == typeof(VkPhysicalDeviceShaderCorePropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + if (val == typeof(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM)) output = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; + if (val == typeof(VkQueryLowLatencySupportNV)) output = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; + if (val == typeof(VkMemoryMapInfo)) output = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; + if (val == typeof(VkMemoryUnmapInfo)) output = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; + if (val == typeof(VkPhysicalDeviceShaderObjectFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceShaderObjectPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; + if (val == typeof(VkShaderCreateInfoEXT)) output = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; + if (val == typeof(VkPhysicalDeviceShaderTileImageFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceShaderTileImagePropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; + if (val == typeof(VkImportScreenBufferInfoQNX)) output = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX; + if (val == typeof(VkScreenBufferPropertiesQNX)) output = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX; + if (val == typeof(VkScreenBufferFormatPropertiesQNX)) output = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; + if (val == typeof(VkExternalFormatQNX)) output = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX; + if (val == typeof(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; + if (val == typeof(VkPhysicalDeviceCooperativeMatrixFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + if (val == typeof(VkCooperativeMatrixPropertiesKHR)) output = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceCooperativeMatrixPropertiesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + if (val == typeof(VkPhysicalDeviceShaderEnqueuePropertiesAMDX)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; + if (val == typeof(VkPhysicalDeviceShaderEnqueueFeaturesAMDX)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; + if (val == typeof(VkExecutionGraphPipelineCreateInfoAMDX)) output = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; + if (val == typeof(VkPipelineShaderStageNodeCreateInfoAMDX)) output = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; + if (val == typeof(VkExecutionGraphPipelineScratchSizeAMDX)) output = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; + if (val == typeof(VkPhysicalDeviceAntiLagFeaturesAMD)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + if (val == typeof(VkAntiLagDataAMD)) output = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; + if (val == typeof(VkAntiLagPresentationInfoAMD)) output = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; + if (val == typeof(VkBindMemoryStatus)) output = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; + if (val == typeof(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceTileMemoryHeapPropertiesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; + if (val == typeof(VkTileMemorySizeInfoQCOM)) output = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + if (val == typeof(VkTileMemoryRequirementsQCOM)) output = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; + if (val == typeof(VkBindDescriptorSetsInfo)) output = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; + if (val == typeof(VkPushConstantsInfo)) output = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; + if (val == typeof(VkPushDescriptorSetInfo)) output = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; + if (val == typeof(VkPushDescriptorSetWithTemplateInfo)) output = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; + if (val == typeof(VkSetDescriptorBufferOffsetsInfoEXT)) output = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; + if (val == typeof(VkBindDescriptorBufferEmbeddedSamplersInfoEXT)) output = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; + if (val == typeof(VkPhysicalDeviceCubicClampFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + if (val == typeof(VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceCubicWeightsFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + if (val == typeof(VkSamplerCubicWeightsCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; + if (val == typeof(VkBlitImageCubicWeightsInfoQCOM)) output = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceImageProcessing2FeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceImageProcessing2PropertiesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; + if (val == typeof(VkSamplerBlockMatchWindowCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceLayeredDriverPropertiesMSFT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; + if (val == typeof(VkPhysicalDevicePerStageDescriptorSetFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceExternalFormatResolveFeaturesANDROID)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; + if (val == typeof(VkPhysicalDeviceExternalFormatResolvePropertiesANDROID)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; + if (val == typeof(VkAndroidHardwareBufferFormatResolvePropertiesANDROID)) output = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; + if (val == typeof(VkLatencySleepModeInfoNV)) output = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV; + if (val == typeof(VkLatencySleepInfoNV)) output = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV; + if (val == typeof(VkSetLatencyMarkerInfoNV)) output = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV; + if (val == typeof(VkGetLatencyMarkerInfoNV)) output = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV; + if (val == typeof(VkLatencyTimingsFrameReportNV)) output = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV; + if (val == typeof(VkOutOfBandQueueTypeInfoNV)) output = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV; + if (val == typeof(VkLatencySubmissionPresentIdNV)) output = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV; + if (val == typeof(VkSwapchainLatencyCreateInfoNV)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; + if (val == typeof(VkLatencySurfaceCapabilitiesNV)) output = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; + if (val == typeof(VkPhysicalDeviceCudaKernelLaunchFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCudaKernelLaunchPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; + if (val == typeof(VkDeviceQueueShaderCoreControlCreateInfoARM)) output = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + if (val == typeof(VkPhysicalDeviceSchedulingControlsFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + if (val == typeof(VkPhysicalDeviceSchedulingControlsPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + if (val == typeof(VkPhysicalDeviceRenderPassStripedFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + if (val == typeof(VkPhysicalDeviceRenderPassStripedPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + if (val == typeof(VkRenderPassStripeInfoARM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; + if (val == typeof(VkRenderPassStripeBeginInfoARM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; + if (val == typeof(VkRenderPassStripeSubmitInfoARM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; + if (val == typeof(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + if (val == typeof(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceShaderSubgroupRotateFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderExpectAssumeFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + if (val == typeof(VkPhysicalDeviceShaderFloatControls2Features)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + if (val == typeof(VkPhysicalDeviceDynamicRenderingLocalReadFeatures)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + if (val == typeof(VkRenderingAttachmentLocationInfo)) output = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; + if (val == typeof(VkRenderingInputAttachmentIndexInfo)) output = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; + if (val == typeof(VkPhysicalDeviceShaderQuadControlFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceMapMemoryPlacedPropertiesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; + if (val == typeof(VkMemoryMapPlacedInfoEXT)) output = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; + if (val == typeof(VkPhysicalDeviceShaderBfloat16FeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceRawAccessChainsFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceImageAlignmentControlFeaturesMESA)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + if (val == typeof(VkPhysicalDeviceImageAlignmentControlPropertiesMESA)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; + if (val == typeof(VkImageAlignmentControlCreateInfoMESA)) output = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; + if (val == typeof(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + if (val == typeof(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceCooperativeMatrix2FeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + if (val == typeof(VkPhysicalDeviceCooperativeMatrix2PropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + if (val == typeof(VkCooperativeMatrixFlexibleDimensionsPropertiesNV)) output = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceHdrVividFeaturesHUAWEI)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + if (val == typeof(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX; + if (val == typeof(VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX)) output = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX; + if (val == typeof(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + if (val == typeof(VkPhysicalDeviceCooperativeVectorFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + if (val == typeof(VkCooperativeVectorPropertiesNV)) output = VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceCooperativeVectorPropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; + if (val == typeof(VkConvertCooperativeVectorMatrixInfoNV)) output = VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; + if (val == typeof(VkPhysicalDeviceTileShadingFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceTileShadingPropertiesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; + if (val == typeof(VkRenderPassTileShadingCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + if (val == typeof(VkPerTileBeginInfoQCOM)) output = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; + if (val == typeof(VkPerTileEndInfoQCOM)) output = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; + if (val == typeof(VkDispatchTileInfoQCOM)) output = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + if (val == typeof(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + if (val == typeof(VkPipelineFragmentDensityMapLayeredCreateInfoVALVE)) output = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; + if (val == typeof(VkSetPresentConfigNV)) output = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; + if (val == typeof(VkPhysicalDevicePresentMeteringFeaturesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; + if (val == typeof(VkExternalComputeQueueDeviceCreateInfoNV)) output = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; + if (val == typeof(VkExternalComputeQueueCreateInfoNV)) output = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; + if (val == typeof(VkExternalComputeQueueDataParamsNV)) output = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; + if (val == typeof(VkPhysicalDeviceExternalComputeQueuePropertiesNV)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; + if (val == typeof(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT; + if (val == typeof(VkPhysicalDeviceFormatPackFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + if (val == typeof(VkTensorDescriptionARM)) output = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; + if (val == typeof(VkTensorCreateInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; + if (val == typeof(VkTensorViewCreateInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; + if (val == typeof(VkTensorMemoryRequirementsInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; + if (val == typeof(VkBindTensorMemoryInfoARM)) output = VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; + if (val == typeof(VkWriteDescriptorSetTensorARM)) output = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; + if (val == typeof(VkTensorFormatPropertiesARM)) output = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceTensorPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + if (val == typeof(VkTensorMemoryBarrierARM)) output = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; + if (val == typeof(VkTensorDependencyInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; + if (val == typeof(VkPhysicalDeviceTensorFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + if (val == typeof(VkDeviceTensorMemoryRequirementsARM)) output = VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; + if (val == typeof(VkCopyTensorInfoARM)) output = VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; + if (val == typeof(VkTensorCopyARM)) output = VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; + if (val == typeof(VkMemoryDedicatedAllocateInfoTensorARM)) output = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + if (val == typeof(VkPhysicalDeviceDescriptorBufferTensorPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + if (val == typeof(VkTensorCaptureDescriptorDataInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + if (val == typeof(VkTensorViewCaptureDescriptorDataInfoARM)) output = VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + if (val == typeof(VkDescriptorGetTensorInfoARM)) output = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; + if (val == typeof(VkFrameBoundaryTensorsARM)) output = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + if (val == typeof(VkPhysicalDeviceExternalTensorInfoARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; + if (val == typeof(VkExternalTensorPropertiesARM)) output = VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; + if (val == typeof(VkExternalMemoryTensorCreateInfoARM)) output = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; + if (val == typeof(VkPhysicalDeviceShaderFloat8FeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + if (val == typeof(VkSurfaceCreateInfoOHOS)) output = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; + if (val == typeof(VkPhysicalDeviceDataGraphFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + if (val == typeof(VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + if (val == typeof(VkDataGraphPipelineConstantARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM; + if (val == typeof(VkDataGraphPipelineResourceInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineCompilerControlCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineShaderModuleCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineSessionCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineSessionBindPointRequirementsInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM; + if (val == typeof(VkDataGraphPipelineSessionBindPointRequirementARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM; + if (val == typeof(VkDataGraphPipelineSessionMemoryRequirementsInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM; + if (val == typeof(VkBindDataGraphPipelineSessionMemoryInfoARM)) output = VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM; + if (val == typeof(VkDataGraphPipelineInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM; + if (val == typeof(VkDataGraphPipelinePropertyQueryResultARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM; + if (val == typeof(VkDataGraphPipelineIdentifierCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM; + if (val == typeof(VkDataGraphPipelineDispatchInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM; + if (val == typeof(VkQueueFamilyDataGraphPropertiesARM)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM; + if (val == typeof(VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM; + if (val == typeof(VkQueueFamilyDataGraphProcessingEnginePropertiesARM)) output = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM; + if (val == typeof(VkDataGraphProcessingEngineCreateInfoARM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + if (val == typeof(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + if (val == typeof(VkDataGraphPipelineBuiltinModelCreateInfoQCOM)) output = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM; + if (val == typeof(VkPhysicalDeviceDataGraphModelFeaturesQCOM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM; + if (val == typeof(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + if (val == typeof(VkNativeBufferOHOS)) output = VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS; + if (val == typeof(VkSwapchainImageCreateInfoOHOS)) output = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS; + if (val == typeof(VkPhysicalDevicePresentationPropertiesOHOS)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS; + if (val == typeof(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; + if (val == typeof(VkVideoEncodeRgbConversionCapabilitiesVALVE)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + if (val == typeof(VkVideoEncodeProfileRgbConversionInfoVALVE)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; + if (val == typeof(VkVideoEncodeSessionRgbConversionCreateInfoVALVE)) output = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; + if (val == typeof(VkPhysicalDeviceShader64BitIndexingFeaturesEXT)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT; + if (val == typeof(VkNativeBufferUsageOHOS)) output = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS; + if (val == typeof(VkNativeBufferPropertiesOHOS)) output = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS; + if (val == typeof(VkNativeBufferFormatPropertiesOHOS)) output = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; + if (val == typeof(VkImportNativeBufferInfoOHOS)) output = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS; + if (val == typeof(VkMemoryGetNativeBufferInfoOHOS)) output = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; + if (val == typeof(VkExternalFormatOHOS)) output = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS; + if (val == typeof(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM; + if (val == typeof(VkPhysicalDevicePerformanceCountersByRegionPropertiesARM)) output = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM; + if (val == typeof(VkPerformanceCounterARM)) output = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM; + if (val == typeof(VkPerformanceCounterDescriptionARM)) output = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM; + if (val == typeof(VkRenderPassPerformanceCountersByRegionBeginInfoARM)) output = VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM; + return output; + } } extension VkObjectType @@ -5080,5 +9345,2656 @@ extension VkObjectType } } } + + [Optimize] public static Self ForType(Type val) + { + Self output = 0; + if (val == typeof(VkInstance)) output = VK_OBJECT_TYPE_INSTANCE; + if (val == typeof(VkPhysicalDevice)) output = VK_OBJECT_TYPE_PHYSICAL_DEVICE; + if (val == typeof(VkDevice)) output = VK_OBJECT_TYPE_DEVICE; + if (val == typeof(VkQueue)) output = VK_OBJECT_TYPE_QUEUE; + if (val == typeof(VkCommandBuffer)) output = VK_OBJECT_TYPE_COMMAND_BUFFER; + if (val == typeof(VkDeviceMemory)) output = VK_OBJECT_TYPE_DEVICE_MEMORY; + if (val == typeof(VkCommandPool)) output = VK_OBJECT_TYPE_COMMAND_POOL; + if (val == typeof(VkBuffer)) output = VK_OBJECT_TYPE_BUFFER; + if (val == typeof(VkBufferView)) output = VK_OBJECT_TYPE_BUFFER_VIEW; + if (val == typeof(VkImage)) output = VK_OBJECT_TYPE_IMAGE; + if (val == typeof(VkImageView)) output = VK_OBJECT_TYPE_IMAGE_VIEW; + if (val == typeof(VkShaderModule)) output = VK_OBJECT_TYPE_SHADER_MODULE; + if (val == typeof(VkPipeline)) output = VK_OBJECT_TYPE_PIPELINE; + if (val == typeof(VkPipelineLayout)) output = VK_OBJECT_TYPE_PIPELINE_LAYOUT; + if (val == typeof(VkSampler)) output = VK_OBJECT_TYPE_SAMPLER; + if (val == typeof(VkDescriptorSet)) output = VK_OBJECT_TYPE_DESCRIPTOR_SET; + if (val == typeof(VkDescriptorSetLayout)) output = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; + if (val == typeof(VkDescriptorPool)) output = VK_OBJECT_TYPE_DESCRIPTOR_POOL; + if (val == typeof(VkFence)) output = VK_OBJECT_TYPE_FENCE; + if (val == typeof(VkSemaphore)) output = VK_OBJECT_TYPE_SEMAPHORE; + if (val == typeof(VkEvent)) output = VK_OBJECT_TYPE_EVENT; + if (val == typeof(VkQueryPool)) output = VK_OBJECT_TYPE_QUERY_POOL; + if (val == typeof(VkFramebuffer)) output = VK_OBJECT_TYPE_FRAMEBUFFER; + if (val == typeof(VkRenderPass)) output = VK_OBJECT_TYPE_RENDER_PASS; + if (val == typeof(VkPipelineCache)) output = VK_OBJECT_TYPE_PIPELINE_CACHE; + if (val == typeof(VkPipelineBinaryKHR)) output = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; + if (val == typeof(VkIndirectCommandsLayoutNV)) output = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; + if (val == typeof(VkIndirectCommandsLayoutEXT)) output = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; + if (val == typeof(VkIndirectExecutionSetEXT)) output = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; + if (val == typeof(VkDescriptorUpdateTemplate)) output = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE; + if (val == typeof(VkSamplerYcbcrConversion)) output = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION; + if (val == typeof(VkValidationCacheEXT)) output = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT; + if (val == typeof(VkAccelerationStructureKHR)) output = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; + if (val == typeof(VkAccelerationStructureNV)) output = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; + if (val == typeof(VkPerformanceConfigurationINTEL)) output = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; + if (val == typeof(VkBufferCollectionFUCHSIA)) output = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; + if (val == typeof(VkDeferredOperationKHR)) output = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; + if (val == typeof(VkPrivateDataSlot)) output = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT; + if (val == typeof(VkCuModuleNVX)) output = VK_OBJECT_TYPE_CU_MODULE_NVX; + if (val == typeof(VkCuFunctionNVX)) output = VK_OBJECT_TYPE_CU_FUNCTION_NVX; + if (val == typeof(VkOpticalFlowSessionNV)) output = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; + if (val == typeof(VkMicromapEXT)) output = VK_OBJECT_TYPE_MICROMAP_EXT; + if (val == typeof(VkShaderEXT)) output = VK_OBJECT_TYPE_SHADER_EXT; + if (val == typeof(VkTensorARM)) output = VK_OBJECT_TYPE_TENSOR_ARM; + if (val == typeof(VkTensorViewARM)) output = VK_OBJECT_TYPE_TENSOR_VIEW_ARM; + if (val == typeof(VkDataGraphPipelineSessionARM)) output = VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM; + if (val == typeof(VkDisplayKHR)) output = VK_OBJECT_TYPE_DISPLAY_KHR; + if (val == typeof(VkDisplayModeKHR)) output = VK_OBJECT_TYPE_DISPLAY_MODE_KHR; + if (val == typeof(VkSurfaceKHR)) output = VK_OBJECT_TYPE_SURFACE_KHR; + if (val == typeof(VkSwapchainKHR)) output = VK_OBJECT_TYPE_SWAPCHAIN_KHR; + if (val == typeof(VkDebugReportCallbackEXT)) output = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; + if (val == typeof(VkDebugUtilsMessengerEXT)) output = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; + if (val == typeof(VkVideoSessionKHR)) output = VK_OBJECT_TYPE_VIDEO_SESSION_KHR; + if (val == typeof(VkVideoSessionParametersKHR)) output = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; + if (val == typeof(VkCudaModuleNV)) output = VK_OBJECT_TYPE_CUDA_MODULE_NV; + if (val == typeof(VkCudaFunctionNV)) output = VK_OBJECT_TYPE_CUDA_FUNCTION_NV; + if (val == typeof(VkExternalComputeQueueNV)) output = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; + return output; + } +} + +extension VkFormat { extension Component { public enum NumericFormat +{ + case UNORM; + case SNORM; + case USCALED; + case SSCALED; + case UINT; + case SINT; + case SRGB; + case SFLOAT; + case UFLOAT; + case SFIXED5; + case BOOL; +} + +}}extension VkFormat +{ + public int? Size + { + get + { + switch (this) + { + case VK_FORMAT_R4G4_UNORM_PACK8: return 8; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return 16; + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return 16; + case VK_FORMAT_R5G6B5_UNORM_PACK16: return 16; + case VK_FORMAT_B5G6R5_UNORM_PACK16: return 16; + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return 16; + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return 16; + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return 16; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: return 16; + case VK_FORMAT_R8_UNORM: return 8; + case VK_FORMAT_R8_SNORM: return 8; + case VK_FORMAT_R8_USCALED: return 8; + case VK_FORMAT_R8_SSCALED: return 8; + case VK_FORMAT_R8_UINT: return 8; + case VK_FORMAT_R8_SINT: return 8; + case VK_FORMAT_R8_SRGB: return 8; + case VK_FORMAT_R8G8_UNORM: return 16; + case VK_FORMAT_R8G8_SNORM: return 16; + case VK_FORMAT_R8G8_USCALED: return 16; + case VK_FORMAT_R8G8_SSCALED: return 16; + case VK_FORMAT_R8G8_UINT: return 16; + case VK_FORMAT_R8G8_SINT: return 16; + case VK_FORMAT_R8G8_SRGB: return 16; + case VK_FORMAT_R8G8B8_UNORM: return 24; + case VK_FORMAT_R8G8B8_SNORM: return 24; + case VK_FORMAT_R8G8B8_USCALED: return 24; + case VK_FORMAT_R8G8B8_SSCALED: return 24; + case VK_FORMAT_R8G8B8_UINT: return 24; + case VK_FORMAT_R8G8B8_SINT: return 24; + case VK_FORMAT_R8G8B8_SRGB: return 24; + case VK_FORMAT_B8G8R8_UNORM: return 24; + case VK_FORMAT_B8G8R8_SNORM: return 24; + case VK_FORMAT_B8G8R8_USCALED: return 24; + case VK_FORMAT_B8G8R8_SSCALED: return 24; + case VK_FORMAT_B8G8R8_UINT: return 24; + case VK_FORMAT_B8G8R8_SINT: return 24; + case VK_FORMAT_B8G8R8_SRGB: return 24; + case VK_FORMAT_R8G8B8A8_UNORM: return 32; + case VK_FORMAT_R8G8B8A8_SNORM: return 32; + case VK_FORMAT_R8G8B8A8_USCALED: return 32; + case VK_FORMAT_R8G8B8A8_SSCALED: return 32; + case VK_FORMAT_R8G8B8A8_UINT: return 32; + case VK_FORMAT_R8G8B8A8_SINT: return 32; + case VK_FORMAT_R8G8B8A8_SRGB: return 32; + case VK_FORMAT_B8G8R8A8_UNORM: return 32; + case VK_FORMAT_B8G8R8A8_SNORM: return 32; + case VK_FORMAT_B8G8R8A8_USCALED: return 32; + case VK_FORMAT_B8G8R8A8_SSCALED: return 32; + case VK_FORMAT_B8G8R8A8_UINT: return 32; + case VK_FORMAT_B8G8R8A8_SINT: return 32; + case VK_FORMAT_B8G8R8A8_SRGB: return 32; + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_UINT_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_SINT_PACK32: return 32; + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_UINT_PACK32: return 32; + case VK_FORMAT_A2R10G10B10_SINT_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_UINT_PACK32: return 32; + case VK_FORMAT_A2B10G10R10_SINT_PACK32: return 32; + case VK_FORMAT_R16_UNORM: return 16; + case VK_FORMAT_R16_SNORM: return 16; + case VK_FORMAT_R16_USCALED: return 16; + case VK_FORMAT_R16_SSCALED: return 16; + case VK_FORMAT_R16_UINT: return 16; + case VK_FORMAT_R16_SINT: return 16; + case VK_FORMAT_R16_SFLOAT: return 16; + case VK_FORMAT_R16G16_UNORM: return 32; + case VK_FORMAT_R16G16_SNORM: return 32; + case VK_FORMAT_R16G16_USCALED: return 32; + case VK_FORMAT_R16G16_SSCALED: return 32; + case VK_FORMAT_R16G16_UINT: return 32; + case VK_FORMAT_R16G16_SINT: return 32; + case VK_FORMAT_R16G16_SFLOAT: return 32; + case VK_FORMAT_R16G16B16_UNORM: return 48; + case VK_FORMAT_R16G16B16_SNORM: return 48; + case VK_FORMAT_R16G16B16_USCALED: return 48; + case VK_FORMAT_R16G16B16_SSCALED: return 48; + case VK_FORMAT_R16G16B16_UINT: return 48; + case VK_FORMAT_R16G16B16_SINT: return 48; + case VK_FORMAT_R16G16B16_SFLOAT: return 48; + case VK_FORMAT_R16G16B16A16_UNORM: return 64; + case VK_FORMAT_R16G16B16A16_SNORM: return 64; + case VK_FORMAT_R16G16B16A16_USCALED: return 64; + case VK_FORMAT_R16G16B16A16_SSCALED: return 64; + case VK_FORMAT_R16G16B16A16_UINT: return 64; + case VK_FORMAT_R16G16B16A16_SINT: return 64; + case VK_FORMAT_R16G16B16A16_SFLOAT: return 64; + case VK_FORMAT_R32_UINT: return 32; + case VK_FORMAT_R32_SINT: return 32; + case VK_FORMAT_R32_SFLOAT: return 32; + case VK_FORMAT_R32G32_UINT: return 64; + case VK_FORMAT_R32G32_SINT: return 64; + case VK_FORMAT_R32G32_SFLOAT: return 64; + case VK_FORMAT_R32G32B32_UINT: return 96; + case VK_FORMAT_R32G32B32_SINT: return 96; + case VK_FORMAT_R32G32B32_SFLOAT: return 96; + case VK_FORMAT_R32G32B32A32_UINT: return 128; + case VK_FORMAT_R32G32B32A32_SINT: return 128; + case VK_FORMAT_R32G32B32A32_SFLOAT: return 128; + case VK_FORMAT_R64_UINT: return 64; + case VK_FORMAT_R64_SINT: return 64; + case VK_FORMAT_R64_SFLOAT: return 64; + case VK_FORMAT_R64G64_UINT: return 128; + case VK_FORMAT_R64G64_SINT: return 128; + case VK_FORMAT_R64G64_SFLOAT: return 128; + case VK_FORMAT_R64G64B64_UINT: return 192; + case VK_FORMAT_R64G64B64_SINT: return 192; + case VK_FORMAT_R64G64B64_SFLOAT: return 192; + case VK_FORMAT_R64G64B64A64_UINT: return 256; + case VK_FORMAT_R64G64B64A64_SINT: return 256; + case VK_FORMAT_R64G64B64A64_SFLOAT: return 256; + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return 32; + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return 32; + case VK_FORMAT_R10X6_UNORM_PACK16: return 16; + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: return 32; + case VK_FORMAT_R12X4_UNORM_PACK16: return 16; + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: return 32; + case VK_FORMAT_A4R4G4B4_UNORM_PACK16: return 16; + case VK_FORMAT_A4B4G4R4_UNORM_PACK16: return 16; + case VK_FORMAT_R16G16_SFIXED5_NV: return 32; + case VK_FORMAT_R10X6_UINT_PACK16_ARM: return 16; + case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: return 32; + case VK_FORMAT_R12X4_UINT_PACK16_ARM: return 16; + case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: return 32; + case VK_FORMAT_R14X2_UINT_PACK16_ARM: return 16; + case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: return 32; + case VK_FORMAT_R14X2_UNORM_PACK16_ARM: return 16; + case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: return 32; + case VK_FORMAT_R8_BOOL_ARM: return 8; + default: return default; + } + } + } + + public int ComponentCount + { + get + { + switch (this) + { + case VK_FORMAT_R4G4_UNORM_PACK8: return 2; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return 4; + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return 4; + case VK_FORMAT_R5G6B5_UNORM_PACK16: return 3; + case VK_FORMAT_B5G6R5_UNORM_PACK16: return 3; + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return 4; + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return 4; + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return 4; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: return 4; + case VK_FORMAT_A8_UNORM: return 1; + case VK_FORMAT_R8_UNORM: return 1; + case VK_FORMAT_R8_SNORM: return 1; + case VK_FORMAT_R8_USCALED: return 1; + case VK_FORMAT_R8_SSCALED: return 1; + case VK_FORMAT_R8_UINT: return 1; + case VK_FORMAT_R8_SINT: return 1; + case VK_FORMAT_R8_SRGB: return 1; + case VK_FORMAT_R8G8_UNORM: return 2; + case VK_FORMAT_R8G8_SNORM: return 2; + case VK_FORMAT_R8G8_USCALED: return 2; + case VK_FORMAT_R8G8_SSCALED: return 2; + case VK_FORMAT_R8G8_UINT: return 2; + case VK_FORMAT_R8G8_SINT: return 2; + case VK_FORMAT_R8G8_SRGB: return 2; + case VK_FORMAT_R8G8B8_UNORM: return 3; + case VK_FORMAT_R8G8B8_SNORM: return 3; + case VK_FORMAT_R8G8B8_USCALED: return 3; + case VK_FORMAT_R8G8B8_SSCALED: return 3; + case VK_FORMAT_R8G8B8_UINT: return 3; + case VK_FORMAT_R8G8B8_SINT: return 3; + case VK_FORMAT_R8G8B8_SRGB: return 3; + case VK_FORMAT_B8G8R8_UNORM: return 3; + case VK_FORMAT_B8G8R8_SNORM: return 3; + case VK_FORMAT_B8G8R8_USCALED: return 3; + case VK_FORMAT_B8G8R8_SSCALED: return 3; + case VK_FORMAT_B8G8R8_UINT: return 3; + case VK_FORMAT_B8G8R8_SINT: return 3; + case VK_FORMAT_B8G8R8_SRGB: return 3; + case VK_FORMAT_R8G8B8A8_UNORM: return 4; + case VK_FORMAT_R8G8B8A8_SNORM: return 4; + case VK_FORMAT_R8G8B8A8_USCALED: return 4; + case VK_FORMAT_R8G8B8A8_SSCALED: return 4; + case VK_FORMAT_R8G8B8A8_UINT: return 4; + case VK_FORMAT_R8G8B8A8_SINT: return 4; + case VK_FORMAT_R8G8B8A8_SRGB: return 4; + case VK_FORMAT_B8G8R8A8_UNORM: return 4; + case VK_FORMAT_B8G8R8A8_SNORM: return 4; + case VK_FORMAT_B8G8R8A8_USCALED: return 4; + case VK_FORMAT_B8G8R8A8_SSCALED: return 4; + case VK_FORMAT_B8G8R8A8_UINT: return 4; + case VK_FORMAT_B8G8R8A8_SINT: return 4; + case VK_FORMAT_B8G8R8A8_SRGB: return 4; + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_UINT_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_SINT_PACK32: return 4; + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_UINT_PACK32: return 4; + case VK_FORMAT_A2R10G10B10_SINT_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_UINT_PACK32: return 4; + case VK_FORMAT_A2B10G10R10_SINT_PACK32: return 4; + case VK_FORMAT_R16_UNORM: return 1; + case VK_FORMAT_R16_SNORM: return 1; + case VK_FORMAT_R16_USCALED: return 1; + case VK_FORMAT_R16_SSCALED: return 1; + case VK_FORMAT_R16_UINT: return 1; + case VK_FORMAT_R16_SINT: return 1; + case VK_FORMAT_R16_SFLOAT: return 1; + case VK_FORMAT_R16G16_UNORM: return 2; + case VK_FORMAT_R16G16_SNORM: return 2; + case VK_FORMAT_R16G16_USCALED: return 2; + case VK_FORMAT_R16G16_SSCALED: return 2; + case VK_FORMAT_R16G16_UINT: return 2; + case VK_FORMAT_R16G16_SINT: return 2; + case VK_FORMAT_R16G16_SFLOAT: return 2; + case VK_FORMAT_R16G16B16_UNORM: return 3; + case VK_FORMAT_R16G16B16_SNORM: return 3; + case VK_FORMAT_R16G16B16_USCALED: return 3; + case VK_FORMAT_R16G16B16_SSCALED: return 3; + case VK_FORMAT_R16G16B16_UINT: return 3; + case VK_FORMAT_R16G16B16_SINT: return 3; + case VK_FORMAT_R16G16B16_SFLOAT: return 3; + case VK_FORMAT_R16G16B16A16_UNORM: return 4; + case VK_FORMAT_R16G16B16A16_SNORM: return 4; + case VK_FORMAT_R16G16B16A16_USCALED: return 4; + case VK_FORMAT_R16G16B16A16_SSCALED: return 4; + case VK_FORMAT_R16G16B16A16_UINT: return 4; + case VK_FORMAT_R16G16B16A16_SINT: return 4; + case VK_FORMAT_R16G16B16A16_SFLOAT: return 4; + case VK_FORMAT_R32_UINT: return 1; + case VK_FORMAT_R32_SINT: return 1; + case VK_FORMAT_R32_SFLOAT: return 1; + case VK_FORMAT_R32G32_UINT: return 2; + case VK_FORMAT_R32G32_SINT: return 2; + case VK_FORMAT_R32G32_SFLOAT: return 2; + case VK_FORMAT_R32G32B32_UINT: return 3; + case VK_FORMAT_R32G32B32_SINT: return 3; + case VK_FORMAT_R32G32B32_SFLOAT: return 3; + case VK_FORMAT_R32G32B32A32_UINT: return 4; + case VK_FORMAT_R32G32B32A32_SINT: return 4; + case VK_FORMAT_R32G32B32A32_SFLOAT: return 4; + case VK_FORMAT_R64_UINT: return 1; + case VK_FORMAT_R64_SINT: return 1; + case VK_FORMAT_R64_SFLOAT: return 1; + case VK_FORMAT_R64G64_UINT: return 2; + case VK_FORMAT_R64G64_SINT: return 2; + case VK_FORMAT_R64G64_SFLOAT: return 2; + case VK_FORMAT_R64G64B64_UINT: return 3; + case VK_FORMAT_R64G64B64_SINT: return 3; + case VK_FORMAT_R64G64B64_SFLOAT: return 3; + case VK_FORMAT_R64G64B64A64_UINT: return 4; + case VK_FORMAT_R64G64B64A64_SINT: return 4; + case VK_FORMAT_R64G64B64A64_SFLOAT: return 4; + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return 3; + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return 3; + case VK_FORMAT_D16_UNORM: return 1; + case VK_FORMAT_X8_D24_UNORM_PACK32: return 1; + case VK_FORMAT_D32_SFLOAT: return 1; + case VK_FORMAT_S8_UINT: return 1; + case VK_FORMAT_D16_UNORM_S8_UINT: return 2; + case VK_FORMAT_D24_UNORM_S8_UINT: return 2; + case VK_FORMAT_D32_SFLOAT_S8_UINT: return 2; + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return 3; + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return 3; + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return 4; + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return 4; + case VK_FORMAT_BC2_UNORM_BLOCK: return 4; + case VK_FORMAT_BC2_SRGB_BLOCK: return 4; + case VK_FORMAT_BC3_UNORM_BLOCK: return 4; + case VK_FORMAT_BC3_SRGB_BLOCK: return 4; + case VK_FORMAT_BC4_UNORM_BLOCK: return 1; + case VK_FORMAT_BC4_SNORM_BLOCK: return 1; + case VK_FORMAT_BC5_UNORM_BLOCK: return 2; + case VK_FORMAT_BC5_SNORM_BLOCK: return 2; + case VK_FORMAT_BC6H_UFLOAT_BLOCK: return 3; + case VK_FORMAT_BC6H_SFLOAT_BLOCK: return 3; + case VK_FORMAT_BC7_UNORM_BLOCK: return 4; + case VK_FORMAT_BC7_SRGB_BLOCK: return 4; + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return 3; + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return 3; + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return 4; + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return 4; + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return 4; + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return 4; + case VK_FORMAT_EAC_R11_UNORM_BLOCK: return 1; + case VK_FORMAT_EAC_R11_SNORM_BLOCK: return 1; + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return 2; + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return 2; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return 4; + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return 4; + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return 4; + case VK_FORMAT_G8B8G8R8_422_UNORM: return 4; + case VK_FORMAT_B8G8R8G8_422_UNORM: return 4; + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: return 3; + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: return 3; + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: return 3; + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: return 3; + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: return 3; + case VK_FORMAT_R10X6_UNORM_PACK16: return 1; + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: return 2; + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: return 4; + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: return 4; + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: return 4; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: return 3; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: return 3; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: return 3; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: return 3; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: return 3; + case VK_FORMAT_R12X4_UNORM_PACK16: return 1; + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: return 2; + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: return 4; + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: return 4; + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: return 4; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: return 3; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: return 3; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: return 3; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: return 3; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: return 3; + case VK_FORMAT_G16B16G16R16_422_UNORM: return 4; + case VK_FORMAT_B16G16R16G16_422_UNORM: return 4; + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: return 3; + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: return 3; + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: return 3; + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: return 3; + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: return 3; + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: return 4; + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: return 4; + case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: return 4; + case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: return 4; + case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: return 3; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: return 3; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: return 3; + case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: return 3; + case VK_FORMAT_A4R4G4B4_UNORM_PACK16: return 4; + case VK_FORMAT_A4B4G4R4_UNORM_PACK16: return 4; + case VK_FORMAT_R16G16_SFIXED5_NV: return 2; + case VK_FORMAT_R10X6_UINT_PACK16_ARM: return 1; + case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: return 2; + case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: return 4; + case VK_FORMAT_R12X4_UINT_PACK16_ARM: return 1; + case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: return 2; + case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: return 4; + case VK_FORMAT_R14X2_UINT_PACK16_ARM: return 1; + case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: return 2; + case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: return 4; + case VK_FORMAT_R14X2_UNORM_PACK16_ARM: return 1; + case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: return 2; + case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: return 4; + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: return 3; + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: return 3; + case VK_FORMAT_R8_BOOL_ARM: return 1; + default: return default; + } + } + } + + public Component GetComponent(int idx) + { + switch (this) + { + case VK_FORMAT_R4G4_UNORM_PACK8: + switch (idx) + { + case 0: return .(.R, 4, .UNORM); + case 1: return .(.G, 4, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + switch (idx) + { + case 0: return .(.R, 4, .UNORM); + case 1: return .(.G, 4, .UNORM); + case 2: return .(.B, 4, .UNORM); + case 3: return .(.A, 4, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + switch (idx) + { + case 0: return .(.B, 4, .UNORM); + case 1: return .(.G, 4, .UNORM); + case 2: return .(.R, 4, .UNORM); + case 3: return .(.A, 4, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R5G6B5_UNORM_PACK16: + switch (idx) + { + case 0: return .(.R, 5, .UNORM); + case 1: return .(.G, 6, .UNORM); + case 2: return .(.B, 5, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B5G6R5_UNORM_PACK16: + switch (idx) + { + case 0: return .(.B, 5, .UNORM); + case 1: return .(.G, 6, .UNORM); + case 2: return .(.R, 5, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + switch (idx) + { + case 0: return .(.R, 5, .UNORM); + case 1: return .(.G, 5, .UNORM); + case 2: return .(.B, 5, .UNORM); + case 3: return .(.A, 1, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + switch (idx) + { + case 0: return .(.B, 5, .UNORM); + case 1: return .(.G, 5, .UNORM); + case 2: return .(.R, 5, .UNORM); + case 3: return .(.A, 1, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + switch (idx) + { + case 0: return .(.A, 1, .UNORM); + case 1: return .(.R, 5, .UNORM); + case 2: return .(.G, 5, .UNORM); + case 3: return .(.B, 5, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: + switch (idx) + { + case 0: return .(.A, 1, .UNORM); + case 1: return .(.B, 5, .UNORM); + case 2: return .(.G, 5, .UNORM); + case 3: return .(.R, 5, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8_UNORM: + switch (idx) + { + case 0: return .(.A, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_UNORM: + switch (idx) + { + case 0: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_SNORM: + switch (idx) + { + case 0: return .(.R, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_USCALED: + switch (idx) + { + case 0: return .(.R, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_SSCALED: + switch (idx) + { + case 0: return .(.R, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_UINT: + switch (idx) + { + case 0: return .(.R, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_SINT: + switch (idx) + { + case 0: return .(.R, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_SRGB: + switch (idx) + { + case 0: return .(.R, 8, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_UNORM: + switch (idx) + { + case 0: return .(.R, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_SNORM: + switch (idx) + { + case 0: return .(.R, 8, .SNORM); + case 1: return .(.G, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_USCALED: + switch (idx) + { + case 0: return .(.R, 8, .USCALED); + case 1: return .(.G, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_SSCALED: + switch (idx) + { + case 0: return .(.R, 8, .SSCALED); + case 1: return .(.G, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_UINT: + switch (idx) + { + case 0: return .(.R, 8, .UINT); + case 1: return .(.G, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_SINT: + switch (idx) + { + case 0: return .(.R, 8, .SINT); + case 1: return .(.G, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8_SRGB: + switch (idx) + { + case 0: return .(.R, 8, .SRGB); + case 1: return .(.G, 8, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_UNORM: + switch (idx) + { + case 0: return .(.R, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + case 2: return .(.B, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_SNORM: + switch (idx) + { + case 0: return .(.R, 8, .SNORM); + case 1: return .(.G, 8, .SNORM); + case 2: return .(.B, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_USCALED: + switch (idx) + { + case 0: return .(.R, 8, .USCALED); + case 1: return .(.G, 8, .USCALED); + case 2: return .(.B, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_SSCALED: + switch (idx) + { + case 0: return .(.R, 8, .SSCALED); + case 1: return .(.G, 8, .SSCALED); + case 2: return .(.B, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_UINT: + switch (idx) + { + case 0: return .(.R, 8, .UINT); + case 1: return .(.G, 8, .UINT); + case 2: return .(.B, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_SINT: + switch (idx) + { + case 0: return .(.R, 8, .SINT); + case 1: return .(.G, 8, .SINT); + case 2: return .(.B, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8_SRGB: + switch (idx) + { + case 0: return .(.R, 8, .SRGB); + case 1: return .(.G, 8, .SRGB); + case 2: return .(.B, 8, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_UNORM: + switch (idx) + { + case 0: return .(.B, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_SNORM: + switch (idx) + { + case 0: return .(.B, 8, .SNORM); + case 1: return .(.G, 8, .SNORM); + case 2: return .(.R, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_USCALED: + switch (idx) + { + case 0: return .(.B, 8, .USCALED); + case 1: return .(.G, 8, .USCALED); + case 2: return .(.R, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_SSCALED: + switch (idx) + { + case 0: return .(.B, 8, .SSCALED); + case 1: return .(.G, 8, .SSCALED); + case 2: return .(.R, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_UINT: + switch (idx) + { + case 0: return .(.B, 8, .UINT); + case 1: return .(.G, 8, .UINT); + case 2: return .(.R, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_SINT: + switch (idx) + { + case 0: return .(.B, 8, .SINT); + case 1: return .(.G, 8, .SINT); + case 2: return .(.R, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8_SRGB: + switch (idx) + { + case 0: return .(.B, 8, .SRGB); + case 1: return .(.G, 8, .SRGB); + case 2: return .(.R, 8, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_UNORM: + switch (idx) + { + case 0: return .(.R, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + case 2: return .(.B, 8, .UNORM); + case 3: return .(.A, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_SNORM: + switch (idx) + { + case 0: return .(.R, 8, .SNORM); + case 1: return .(.G, 8, .SNORM); + case 2: return .(.B, 8, .SNORM); + case 3: return .(.A, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_USCALED: + switch (idx) + { + case 0: return .(.R, 8, .USCALED); + case 1: return .(.G, 8, .USCALED); + case 2: return .(.B, 8, .USCALED); + case 3: return .(.A, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_SSCALED: + switch (idx) + { + case 0: return .(.R, 8, .SSCALED); + case 1: return .(.G, 8, .SSCALED); + case 2: return .(.B, 8, .SSCALED); + case 3: return .(.A, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_UINT: + switch (idx) + { + case 0: return .(.R, 8, .UINT); + case 1: return .(.G, 8, .UINT); + case 2: return .(.B, 8, .UINT); + case 3: return .(.A, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_SINT: + switch (idx) + { + case 0: return .(.R, 8, .SINT); + case 1: return .(.G, 8, .SINT); + case 2: return .(.B, 8, .SINT); + case 3: return .(.A, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8G8B8A8_SRGB: + switch (idx) + { + case 0: return .(.R, 8, .SRGB); + case 1: return .(.G, 8, .SRGB); + case 2: return .(.B, 8, .SRGB); + case 3: return .(.A, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_UNORM: + switch (idx) + { + case 0: return .(.B, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + case 3: return .(.A, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_SNORM: + switch (idx) + { + case 0: return .(.B, 8, .SNORM); + case 1: return .(.G, 8, .SNORM); + case 2: return .(.R, 8, .SNORM); + case 3: return .(.A, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_USCALED: + switch (idx) + { + case 0: return .(.B, 8, .USCALED); + case 1: return .(.G, 8, .USCALED); + case 2: return .(.R, 8, .USCALED); + case 3: return .(.A, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_SSCALED: + switch (idx) + { + case 0: return .(.B, 8, .SSCALED); + case 1: return .(.G, 8, .SSCALED); + case 2: return .(.R, 8, .SSCALED); + case 3: return .(.A, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_UINT: + switch (idx) + { + case 0: return .(.B, 8, .UINT); + case 1: return .(.G, 8, .UINT); + case 2: return .(.R, 8, .UINT); + case 3: return .(.A, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_SINT: + switch (idx) + { + case 0: return .(.B, 8, .SINT); + case 1: return .(.G, 8, .SINT); + case 2: return .(.R, 8, .SINT); + case 3: return .(.A, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8A8_SRGB: + switch (idx) + { + case 0: return .(.B, 8, .SRGB); + case 1: return .(.G, 8, .SRGB); + case 2: return .(.R, 8, .SRGB); + case 3: return .(.A, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.G, 8, .UNORM); + case 3: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .SNORM); + case 1: return .(.B, 8, .SNORM); + case 2: return .(.G, 8, .SNORM); + case 3: return .(.R, 8, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .USCALED); + case 1: return .(.B, 8, .USCALED); + case 2: return .(.G, 8, .USCALED); + case 3: return .(.R, 8, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .SSCALED); + case 1: return .(.B, 8, .SSCALED); + case 2: return .(.G, 8, .SSCALED); + case 3: return .(.R, 8, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .UINT); + case 1: return .(.B, 8, .UINT); + case 2: return .(.G, 8, .UINT); + case 3: return .(.R, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .SINT); + case 1: return .(.B, 8, .SINT); + case 2: return .(.G, 8, .SINT); + case 3: return .(.R, 8, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + switch (idx) + { + case 0: return .(.A, 8, .UNORM); + case 1: return .(.B, 8, .SRGB); + case 2: return .(.G, 8, .SRGB); + case 3: return .(.R, 8, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .UNORM); + case 1: return .(.R, 10, .UNORM); + case 2: return .(.G, 10, .UNORM); + case 3: return .(.B, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SNORM); + case 1: return .(.R, 10, .SNORM); + case 2: return .(.G, 10, .SNORM); + case 3: return .(.B, 10, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .USCALED); + case 1: return .(.R, 10, .USCALED); + case 2: return .(.G, 10, .USCALED); + case 3: return .(.B, 10, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SSCALED); + case 1: return .(.R, 10, .SSCALED); + case 2: return .(.G, 10, .SSCALED); + case 3: return .(.B, 10, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .UINT); + case 1: return .(.R, 10, .UINT); + case 2: return .(.G, 10, .UINT); + case 3: return .(.B, 10, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SINT); + case 1: return .(.R, 10, .SINT); + case 2: return .(.G, 10, .SINT); + case 3: return .(.B, 10, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.G, 10, .UNORM); + case 3: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SNORM); + case 1: return .(.B, 10, .SNORM); + case 2: return .(.G, 10, .SNORM); + case 3: return .(.R, 10, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .USCALED); + case 1: return .(.B, 10, .USCALED); + case 2: return .(.G, 10, .USCALED); + case 3: return .(.R, 10, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SSCALED); + case 1: return .(.B, 10, .SSCALED); + case 2: return .(.G, 10, .SSCALED); + case 3: return .(.R, 10, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .UINT); + case 1: return .(.B, 10, .UINT); + case 2: return .(.G, 10, .UINT); + case 3: return .(.R, 10, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + switch (idx) + { + case 0: return .(.A, 2, .SINT); + case 1: return .(.B, 10, .SINT); + case 2: return .(.G, 10, .SINT); + case 3: return .(.R, 10, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_UNORM: + switch (idx) + { + case 0: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_SNORM: + switch (idx) + { + case 0: return .(.R, 16, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_USCALED: + switch (idx) + { + case 0: return .(.R, 16, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_SSCALED: + switch (idx) + { + case 0: return .(.R, 16, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_UINT: + switch (idx) + { + case 0: return .(.R, 16, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_SINT: + switch (idx) + { + case 0: return .(.R, 16, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16_SFLOAT: + switch (idx) + { + case 0: return .(.R, 16, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_UNORM: + switch (idx) + { + case 0: return .(.R, 16, .UNORM); + case 1: return .(.G, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_SNORM: + switch (idx) + { + case 0: return .(.R, 16, .SNORM); + case 1: return .(.G, 16, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_USCALED: + switch (idx) + { + case 0: return .(.R, 16, .USCALED); + case 1: return .(.G, 16, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_SSCALED: + switch (idx) + { + case 0: return .(.R, 16, .SSCALED); + case 1: return .(.G, 16, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_UINT: + switch (idx) + { + case 0: return .(.R, 16, .UINT); + case 1: return .(.G, 16, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_SINT: + switch (idx) + { + case 0: return .(.R, 16, .SINT); + case 1: return .(.G, 16, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_SFLOAT: + switch (idx) + { + case 0: return .(.R, 16, .SFLOAT); + case 1: return .(.G, 16, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_UNORM: + switch (idx) + { + case 0: return .(.R, 16, .UNORM); + case 1: return .(.G, 16, .UNORM); + case 2: return .(.B, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_SNORM: + switch (idx) + { + case 0: return .(.R, 16, .SNORM); + case 1: return .(.G, 16, .SNORM); + case 2: return .(.B, 16, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_USCALED: + switch (idx) + { + case 0: return .(.R, 16, .USCALED); + case 1: return .(.G, 16, .USCALED); + case 2: return .(.B, 16, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_SSCALED: + switch (idx) + { + case 0: return .(.R, 16, .SSCALED); + case 1: return .(.G, 16, .SSCALED); + case 2: return .(.B, 16, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_UINT: + switch (idx) + { + case 0: return .(.R, 16, .UINT); + case 1: return .(.G, 16, .UINT); + case 2: return .(.B, 16, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_SINT: + switch (idx) + { + case 0: return .(.R, 16, .SINT); + case 1: return .(.G, 16, .SINT); + case 2: return .(.B, 16, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16_SFLOAT: + switch (idx) + { + case 0: return .(.R, 16, .SFLOAT); + case 1: return .(.G, 16, .SFLOAT); + case 2: return .(.B, 16, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_UNORM: + switch (idx) + { + case 0: return .(.R, 16, .UNORM); + case 1: return .(.G, 16, .UNORM); + case 2: return .(.B, 16, .UNORM); + case 3: return .(.A, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_SNORM: + switch (idx) + { + case 0: return .(.R, 16, .SNORM); + case 1: return .(.G, 16, .SNORM); + case 2: return .(.B, 16, .SNORM); + case 3: return .(.A, 16, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_USCALED: + switch (idx) + { + case 0: return .(.R, 16, .USCALED); + case 1: return .(.G, 16, .USCALED); + case 2: return .(.B, 16, .USCALED); + case 3: return .(.A, 16, .USCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_SSCALED: + switch (idx) + { + case 0: return .(.R, 16, .SSCALED); + case 1: return .(.G, 16, .SSCALED); + case 2: return .(.B, 16, .SSCALED); + case 3: return .(.A, 16, .SSCALED); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_UINT: + switch (idx) + { + case 0: return .(.R, 16, .UINT); + case 1: return .(.G, 16, .UINT); + case 2: return .(.B, 16, .UINT); + case 3: return .(.A, 16, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_SINT: + switch (idx) + { + case 0: return .(.R, 16, .SINT); + case 1: return .(.G, 16, .SINT); + case 2: return .(.B, 16, .SINT); + case 3: return .(.A, 16, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16B16A16_SFLOAT: + switch (idx) + { + case 0: return .(.R, 16, .SFLOAT); + case 1: return .(.G, 16, .SFLOAT); + case 2: return .(.B, 16, .SFLOAT); + case 3: return .(.A, 16, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32_UINT: + switch (idx) + { + case 0: return .(.R, 32, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32_SINT: + switch (idx) + { + case 0: return .(.R, 32, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32_SFLOAT: + switch (idx) + { + case 0: return .(.R, 32, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32_UINT: + switch (idx) + { + case 0: return .(.R, 32, .UINT); + case 1: return .(.G, 32, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32_SINT: + switch (idx) + { + case 0: return .(.R, 32, .SINT); + case 1: return .(.G, 32, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32_SFLOAT: + switch (idx) + { + case 0: return .(.R, 32, .SFLOAT); + case 1: return .(.G, 32, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32_UINT: + switch (idx) + { + case 0: return .(.R, 32, .UINT); + case 1: return .(.G, 32, .UINT); + case 2: return .(.B, 32, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32_SINT: + switch (idx) + { + case 0: return .(.R, 32, .SINT); + case 1: return .(.G, 32, .SINT); + case 2: return .(.B, 32, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32_SFLOAT: + switch (idx) + { + case 0: return .(.R, 32, .SFLOAT); + case 1: return .(.G, 32, .SFLOAT); + case 2: return .(.B, 32, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32A32_UINT: + switch (idx) + { + case 0: return .(.R, 32, .UINT); + case 1: return .(.G, 32, .UINT); + case 2: return .(.B, 32, .UINT); + case 3: return .(.A, 32, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32A32_SINT: + switch (idx) + { + case 0: return .(.R, 32, .SINT); + case 1: return .(.G, 32, .SINT); + case 2: return .(.B, 32, .SINT); + case 3: return .(.A, 32, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R32G32B32A32_SFLOAT: + switch (idx) + { + case 0: return .(.R, 32, .SFLOAT); + case 1: return .(.G, 32, .SFLOAT); + case 2: return .(.B, 32, .SFLOAT); + case 3: return .(.A, 32, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64_UINT: + switch (idx) + { + case 0: return .(.R, 64, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64_SINT: + switch (idx) + { + case 0: return .(.R, 64, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64_SFLOAT: + switch (idx) + { + case 0: return .(.R, 64, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64_UINT: + switch (idx) + { + case 0: return .(.R, 64, .UINT); + case 1: return .(.G, 64, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64_SINT: + switch (idx) + { + case 0: return .(.R, 64, .SINT); + case 1: return .(.G, 64, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64_SFLOAT: + switch (idx) + { + case 0: return .(.R, 64, .SFLOAT); + case 1: return .(.G, 64, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64_UINT: + switch (idx) + { + case 0: return .(.R, 64, .UINT); + case 1: return .(.G, 64, .UINT); + case 2: return .(.B, 64, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64_SINT: + switch (idx) + { + case 0: return .(.R, 64, .SINT); + case 1: return .(.G, 64, .SINT); + case 2: return .(.B, 64, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64_SFLOAT: + switch (idx) + { + case 0: return .(.R, 64, .SFLOAT); + case 1: return .(.G, 64, .SFLOAT); + case 2: return .(.B, 64, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64A64_UINT: + switch (idx) + { + case 0: return .(.R, 64, .UINT); + case 1: return .(.G, 64, .UINT); + case 2: return .(.B, 64, .UINT); + case 3: return .(.A, 64, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64A64_SINT: + switch (idx) + { + case 0: return .(.R, 64, .SINT); + case 1: return .(.G, 64, .SINT); + case 2: return .(.B, 64, .SINT); + case 3: return .(.A, 64, .SINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R64G64B64A64_SFLOAT: + switch (idx) + { + case 0: return .(.R, 64, .SFLOAT); + case 1: return .(.G, 64, .SFLOAT); + case 2: return .(.B, 64, .SFLOAT); + case 3: return .(.A, 64, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + switch (idx) + { + case 0: return .(.B, 10, .UFLOAT); + case 1: return .(.G, 11, .UFLOAT); + case 2: return .(.R, 11, .UFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + switch (idx) + { + case 0: return .(.B, 9, .UFLOAT); + case 1: return .(.G, 9, .UFLOAT); + case 2: return .(.R, 9, .UFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_D16_UNORM: + switch (idx) + { + case 0: return .(.D, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_X8_D24_UNORM_PACK32: + switch (idx) + { + case 0: return .(.D, 24, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_D32_SFLOAT: + switch (idx) + { + case 0: return .(.D, 32, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_S8_UINT: + switch (idx) + { + case 0: return .(.S, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_D16_UNORM_S8_UINT: + switch (idx) + { + case 0: return .(.D, 16, .UNORM); + case 1: return .(.S, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_D24_UNORM_S8_UINT: + switch (idx) + { + case 0: return .(.D, 24, .UNORM); + case 1: return .(.S, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_D32_SFLOAT_S8_UINT: + switch (idx) + { + case 0: return .(.D, 32, .SFLOAT); + case 1: return .(.S, 8, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC2_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC2_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC3_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC3_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC4_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC4_SNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC5_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC5_SNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SNORM); + case 1: return .(.G, null, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UFLOAT); + case 1: return .(.G, null, .UFLOAT); + case 2: return .(.B, null, .UFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC7_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_BC7_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, 11, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, 11, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, 11, .UNORM); + case 1: return .(.G, 11, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, 11, .SNORM); + case 1: return .(.G, 11, .SNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8B8G8R8_422_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.G, 8, .UNORM); + case 3: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B8G8R8G8_422_UNORM: + switch (idx) + { + case 0: return .(.B, 8, .UNORM); + case 1: return .(.G, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + case 3: return .(.G, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6_UNORM_PACK16: + switch (idx) + { + case 0: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + switch (idx) + { + case 0: return .(.R, 10, .UNORM); + case 1: return .(.G, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.R, 10, .UNORM); + case 1: return .(.G, 10, .UNORM); + case 2: return .(.B, 10, .UNORM); + case 3: return .(.A, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.G, 10, .UNORM); + case 3: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.B, 10, .UNORM); + case 1: return .(.G, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + case 3: return .(.G, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4_UNORM_PACK16: + switch (idx) + { + case 0: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: + switch (idx) + { + case 0: return .(.R, 12, .UNORM); + case 1: return .(.G, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.R, 12, .UNORM); + case 1: return .(.G, 12, .UNORM); + case 2: return .(.B, 12, .UNORM); + case 3: return .(.A, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.G, 12, .UNORM); + case 3: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + switch (idx) + { + case 0: return .(.B, 12, .UNORM); + case 1: return .(.G, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + case 3: return .(.G, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16B16G16R16_422_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.G, 16, .UNORM); + case 3: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_B16G16R16G16_422_UNORM: + switch (idx) + { + case 0: return .(.B, 16, .UNORM); + case 1: return .(.G, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + case 3: return .(.G, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .UNORM); + case 1: return .(.G, null, .UNORM); + case 2: return .(.B, null, .UNORM); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: + switch (idx) + { + case 0: return .(.R, null, .SRGB); + case 1: return .(.G, null, .SRGB); + case 2: return .(.B, null, .SRGB); + case 3: return .(.A, null, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: + switch (idx) + { + case 0: return .(.R, null, .SFLOAT); + case 1: return .(.G, null, .SFLOAT); + case 2: return .(.B, null, .SFLOAT); + case 3: return .(.A, null, .SFLOAT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: + switch (idx) + { + case 0: return .(.G, 8, .UNORM); + case 1: return .(.B, 8, .UNORM); + case 2: return .(.R, 8, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 10, .UNORM); + case 1: return .(.B, 10, .UNORM); + case 2: return .(.R, 10, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: + switch (idx) + { + case 0: return .(.G, 12, .UNORM); + case 1: return .(.B, 12, .UNORM); + case 2: return .(.R, 12, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: + switch (idx) + { + case 0: return .(.G, 16, .UNORM); + case 1: return .(.B, 16, .UNORM); + case 2: return .(.R, 16, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A4R4G4B4_UNORM_PACK16: + switch (idx) + { + case 0: return .(.A, 4, .UNORM); + case 1: return .(.R, 4, .UNORM); + case 2: return .(.G, 4, .UNORM); + case 3: return .(.B, 4, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_A4B4G4R4_UNORM_PACK16: + switch (idx) + { + case 0: return .(.A, 4, .UNORM); + case 1: return .(.B, 4, .UNORM); + case 2: return .(.G, 4, .UNORM); + case 3: return .(.R, 4, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R16G16_SFIXED5_NV: + switch (idx) + { + case 0: return .(.R, 16, .SFIXED5); + case 1: return .(.G, 16, .SFIXED5); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6_UINT_PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 10, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 10, .UINT); + case 1: return .(.G, 10, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 10, .UINT); + case 1: return .(.G, 10, .UINT); + case 2: return .(.B, 10, .UINT); + case 3: return .(.A, 10, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4_UINT_PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 12, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 12, .UINT); + case 1: return .(.G, 12, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 12, .UINT); + case 1: return .(.G, 12, .UINT); + case 2: return .(.B, 12, .UINT); + case 3: return .(.A, 12, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2_UINT_PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UINT); + case 1: return .(.G, 14, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UINT); + case 1: return .(.G, 14, .UINT); + case 2: return .(.B, 14, .UINT); + case 3: return .(.A, 14, .UINT); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2_UNORM_PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UNORM); + case 1: return .(.G, 14, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: + switch (idx) + { + case 0: return .(.R, 14, .UNORM); + case 1: return .(.G, 14, .UNORM); + case 2: return .(.B, 14, .UNORM); + case 3: return .(.A, 14, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: + switch (idx) + { + case 0: return .(.G, 14, .UNORM); + case 1: return .(.B, 14, .UNORM); + case 2: return .(.R, 14, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: + switch (idx) + { + case 0: return .(.G, 14, .UNORM); + case 1: return .(.B, 14, .UNORM); + case 2: return .(.R, 14, .UNORM); + default: Runtime.FatalError("Index out of range"); + } + case VK_FORMAT_R8_BOOL_ARM: + switch (idx) + { + case 0: return .(.R, 8, .BOOL); + default: Runtime.FatalError("Index out of range"); + } + default: + Runtime.FatalError("Index out of range"); + } + } }