diff --git a/Setup/BeefProj.toml b/Setup/BeefProj.toml index 900efc5..0c2257e 100644 --- a/Setup/BeefProj.toml +++ b/Setup/BeefProj.toml @@ -1,6 +1,9 @@ FileVersion = 1 -Dependencies = {corlib = "*", Expat = "*"} [Project] Name = "Vulkan.Setup" StartupObject = "Vulkan.Setup.Program" + +[Dependencies] +corlib = "*" +"Expat.git" = {Git = "https://git.unicon-gmbh.de/BeefBindings/Expat.git"} diff --git a/Setup/BeefSpace.toml b/Setup/BeefSpace.toml index cc776f1..7731e5e 100644 --- a/Setup/BeefSpace.toml +++ b/Setup/BeefSpace.toml @@ -1,5 +1,8 @@ FileVersion = 1 -Projects = {"Vulkan.Setup" = {Path = "."}, Expat = {Path = "../../../RandomStuff/Cpp2Beef/Bindings/Expat"}} [Workspace] StartupProject = "Vulkan.Setup" + +[Projects] +"Vulkan.Setup" = {Path = "."} +"Expat.git" = {Git = "https://git.unicon-gmbh.de/BeefBindings/Expat.git"} diff --git a/Setup/BeefSpace_Lock.toml b/Setup/BeefSpace_Lock.toml new file mode 100644 index 0000000..62012cd --- /dev/null +++ b/Setup/BeefSpace_Lock.toml @@ -0,0 +1,6 @@ +FileVersion = 1 + +[Locks."Expat.git".Git] +URL = "https://git.unicon-gmbh.de/BeefBindings/Expat.git" +Tag = "" +Hash = "97c80cd88dd68f4a70922c7b0bad0b27f86aa3c6" diff --git a/Setup/src/Program.bf b/Setup/src/Program.bf index 9167bec..b83ac5b 100644 --- a/Setup/src/Program.bf +++ b/Setup/src/Program.bf @@ -99,12 +99,13 @@ static class Metadata if (kv.value.predicate != null && *kv.value.predicate != .AlreadyWritten) continue; let val = kv.value.underlying.[Friend]mVal[@sig.Index]; - if (val == null) continue; + if (val == null && sig.mode != .Cases) continue; strBuffer.Append(indent, "case ", kv.key); switch (sig.mode) { case .Cases: - strBuffer.Append(" = "); + if (val != null) + strBuffer.Append(" = "); case .Method, .Property: strBuffer.Append(": return "); } @@ -135,10 +136,12 @@ static class Metadata } } - public enum PureEnum { Cases } - public static append EnumMetadata apiVersion; + public enum ApiVersion { Cases, FeatureStruct } + public static append EnumMetadata apiVersion; public enum Extensions { Cases, Name, Tag, Kind, MinVersion, PromotedTo, Dependencies } public static append EnumMetadata extensions; + public enum Features { Cases, ApiVersion, ExtensionStruct } + public static append EnumMetadata features; public enum TypeEnum { Type } public static append EnumMetadata vkStructureType; public static append EnumMetadata vkObjectType; @@ -441,7 +444,7 @@ class RegistryParser : XmlParser public append String type; public append String length; public append String call; - public enum { None = 0, Optional = 1, Const = 2, OutParam = 4, OutArrayLen = 8, OutArrayPtr = 16 } flags; + public enum { None = 0, Optional = 1, Const = 2, OutParam = 4, OutArrayLen = 8, OutArrayPtr = 16, SpanLen = 32, SpanPtr = 64 } flags; public void Clear() { @@ -562,8 +565,8 @@ class RegistryParser : XmlParser case "define": strBuf.Clear(); eStack.Add(.Type_Define); - case (.)default: - /*if (atts.TryGetValue("requires", let requires) && requires != "stdint" && requires != "vk_platform" && !requires.StartsWith("vk_video/")) + /*case (.)default: + if (atts.TryGetValue("requires", let requires) && requires != "stdint" && requires != "vk_platform" && !requires.StartsWith("vk_video/")) { PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; InitTypeFeature(feature); @@ -580,8 +583,8 @@ class RegistryParser : XmlParser } feature.content = new:alloc .(strBuf); vkOutput.Add(feature); - }*/ - fallthrough; + } + fallthrough;*/ default: eStack.Add(.Ignore); } @@ -732,7 +735,15 @@ class RegistryParser : XmlParser case "name": eStack.Add(.Name); case "extensions": eStack.Add(.Extensions); - case "feature": eStack.Add(.Feature); FeatureComment(); + case "feature": + switch (eStack.Back) + { + case .Registry: + eStack.Add(.Feature); + FeatureComment(); + default: + eStack.Add(.Ignore); + } case "extension": eStack.Add(.Extension); FeatureComment(); @@ -957,6 +968,39 @@ class RegistryParser : XmlParser PregeneratedFeature feature = new:alloc .() { kind = .HasBody }; InitTypeFeature(feature); + if (type_name.StartsWith("VkPhysicalDevice") && type_name.Contains("Features") && type_name != "VkPhysicalDeviceFeatures2") + { + Metadata.Features mode; + strBuf.Clear(); + if (type_name == "VkPhysicalDeviceFeatures") + { + mode = .ApiVersion; + strBuf.Append(".VK_VERSION_1_0"); + } + else if (type_name.StartsWith("VkPhysicalDeviceVulkan1")) + { + mode = .ApiVersion; + strBuf.Append(".VK_VERSION_1_"); + for (let c in type_name["VkPhysicalDeviceVulkan1".Length...]) + { + if (!c.IsDigit) continue; + strBuf.Append(c); + } + } + else + { + mode = .ExtensionStruct; + strBuf.Append(type_name); + strBuf.Append(".SType"); + } + String outputStr = new:alloc .(strBuf); + for (let field in fields) + { + if (field.type != "VkBool32") continue; + Metadata.features.For(field.name, &feature.kind).At(mode) = outputStr; + } + } + { Dictionary dict = scope .((.)fields.Count); for (let field in fields) @@ -964,6 +1008,8 @@ class RegistryParser : XmlParser if (field.flags.HasFlag(.CommentOnly)) continue; dict.Add(field.name, (0, field, null)); if (field.length.IsEmpty) continue; + if (field.length.EndsWith(",null-terminated")) + field.length.Length -= (",null-terminated".Length); if (!dict.TryGetRef(field.length, ?, let value)) continue; value.lens++; value.lenField = field; @@ -1049,7 +1095,10 @@ class RegistryParser : XmlParser continue; } - strBuf.Append("\tpublic ", field.type, " ", field.name); + strBuf.Append("\tpublic "); + if (@field.Count == 3 && @field.Index == 2 && type_name.EndsWith('2') && !handles.ContainsKey(field.type)) + strBuf.Append("using public "); + strBuf.Append(field.type, " ", field.name); if (field.values.IsEmpty) strBuf.Append(" = ", DefaultValueForType(field.type)); else @@ -1167,14 +1216,25 @@ class RegistryParser : XmlParser } else strBuf.Replace("#define", "static { public const let "); - if (feature.name.StartsWith("VK_API_VERSION_") && feature.name[^1].IsDigit) - Metadata.apiVersion.For(scope String(feature.name)..Replace("_API_", "_")).At(.Cases) = feature.name; feature.content = new:alloc .(strBuf); + if (feature.name.StartsWith("VK_API_VERSION_") && feature.name[^1].IsDigit) + { + let value = Metadata.apiVersion.For(scope String(feature.name)..Replace("_API_", "_")); + value.At(.Cases) = feature.name; + strBuf.Set("VkPhysicalDeviceVulkan"); + for (let c in feature.name["VK_API_VERSION_".Length...]) + if (c != '_') + strBuf.Append(c); + strBuf.Append("Features.SType"); + if (strBuf == "VkPhysicalDeviceVulkan10Features.SType") + strBuf.Set("VkPhysicalDeviceFeatures2.SType"); + value.At(.FeatureStruct) = new:alloc .(strBuf); + } vkTypes.Add(feature.name, feature); case .Type_FuncPtr: PregeneratedFeature feature = new:alloc .() { kind = .HasBody }; InitTypeFeature(feature); - strBuf.Replace("const ", ""); + strBuf.Replace("const ", "/***/ "); strBuf.Replace("(VKAPI_PTR *", ""); strBuf.Replace(")(", "("); strBuf.Remove(0, "typedef".Length); @@ -1193,19 +1253,37 @@ class RegistryParser : XmlParser { defer { lastParam = param; } param.call.Set(param.name); - if (param.flags.HasFlag(.Const) || !param.type.EndsWith('*')) continue; - if (lastParam?.name == param.length && lastParam?.flags.HasFlag(.OutParam) == true) + if (!param.type.EndsWith('*')) continue; + if (lastParam != null) { - lastParam.flags |= .OutArrayLen; - param.flags |= .OutArrayPtr; - hasOutArray = true; - continue; - } - if (lastParam?.flags.HasFlag(.OutArrayPtr) == true) - { - param.flags |= .OutArrayPtr; - continue; + if (lastParam.name == param.length) + { + if (lastParam.flags.HasFlag(.OutParam)) + { + lastParam.flags |= .OutArrayLen; + param.flags |= .OutArrayPtr; + hasOutArray = true; + } + else + { + lastParam.flags |= .SpanLen; + param.flags |= .SpanPtr; + } + continue; + } + if (lastParam.flags.HasFlag(.OutArrayPtr)) + { + param.flags |= .OutArrayPtr; + continue; + } + if (lastParam.flags.HasFlag(.SpanPtr)) + { + parameters[@param.Index - 2].flags &= ~.SpanLen; + lastParam.flags &= ~.SpanPtr; + } } + + if (param.flags.HasFlag(.Const)) continue; param.type.Length--; param.type.Insert(0, "out "); param.call.Insert(0, "out "); @@ -1227,6 +1305,23 @@ class RegistryParser : XmlParser strBuf.Append(");"); feature.content = new:alloc .(strBuf); + for (let param in parameters) + { + if (param.flags.HasFlag(.SpanLen)) + { + param.call.Set("(.)"); + param.call.Append(parameters[@param.Index + 1].name); + param.call.Append(".Length"); + } + if (param.flags.HasFlag(.SpanPtr)) + { + param.call.Append(".Ptr"); + param.type.Length--; + param.type.Insert(0, "Span<"); + param.type.Append('>'); + } + } + int handleIndex = -1; handle: do { @@ -1266,7 +1361,7 @@ class RegistryParser : XmlParser for (let param in parameters) { int idx = @param.Index; - if (idx == handleIndex) continue; + if (idx == handleIndex || param.flags.HasFlag(.SpanLen)) continue; if (handleIndex != -1 || idx != 0) strBuf.Append(", "); strBuf.Append(param.type, " ", param.name); @@ -1303,7 +1398,7 @@ class RegistryParser : XmlParser { int idx = @param.Index; if (idx == handleIndex) continue; - if (param.flags.HasFlag(.OutArrayLen)) continue; + if (param.flags.HasFlag(.OutArrayLen) || param.flags.HasFlag(.SpanLen)) continue; if (writeComma) strBuf.Append(", "); writeComma = true; @@ -1652,7 +1747,8 @@ class Program """); String strBuffer = scope .(1024); Metadata.apiVersion.WriteToStream(strBuffer, writer, "enum VulkanApiVersion", - (null, .Cases)); + (null, .Cases), + ("public VkStructureType FeatureStruct", .Property)); Metadata.extensions.WriteToStream(strBuffer, writer, "enum VulkanExtension", (null, .Cases), ("public String Name", .Property), @@ -1661,6 +1757,10 @@ class Program ("public VulkanApiVersion MinVersion", .Property), ("public VulkanApiVersion PromotedTo", .Property), ("public Span Dependencies", .Property)); + Metadata.features.WriteToStream(strBuffer, writer, "enum VulkanFeature", + (null, .Cases), + ("public VulkanApiVersion ApiVersion", .Property), + ("public VkStructureType ExtensionStruct", .Property)); writer.Write(""" namespace Vulkan; diff --git a/src/Library.bf b/src/Library.bf index 9eba61b..39c6d20 100644 --- a/src/Library.bf +++ b/src/Library.bf @@ -23,6 +23,12 @@ static public const let VK_NULL_HANDLE = 0; } +extension VkResult +{ + [NoShow(false), SkipCall, Warn("VkResult discarded")] + public void ReturnValueDiscarded(); +} + namespace Vulkan.Metadata; extension VulkanExtension diff --git a/src/Loader.bf b/src/Loader.bf index f5bda82..fa8e2cb 100644 --- a/src/Loader.bf +++ b/src/Loader.bf @@ -2375,15 +2375,15 @@ static [Inline] public static VkResult EnumerateDeviceLayerProperties(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkLayerProperties* pProperties = null) => VulkanLoadedFunctions.current.vkEnumerateDeviceLayerProperties(physicalDevice, out pPropertyCount, pProperties); [Inline] public static VkResult EnumerateDeviceExtensionProperties(this VkPhysicalDevice physicalDevice, char8* pLayerName, out uint32 pPropertyCount, VkExtensionProperties* pProperties = null) => VulkanLoadedFunctions.current.vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, out pPropertyCount, pProperties); [Inline] public static void GetQueue(this VkDevice device, uint32 queueFamilyIndex, uint32 queueIndex, out VkQueue pQueue) => VulkanLoadedFunctions.current.vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, out pQueue); - [Inline] public static VkResult Submit(this VkQueue queue, uint32 submitCount, VkSubmitInfo* pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit(queue, submitCount, pSubmits, fence); + [Inline] public static VkResult Submit(this VkQueue queue, Span pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit(queue, (.)pSubmits.Length, pSubmits.Ptr, fence); [Inline] public static VkResult WaitIdle(this VkQueue queue) => VulkanLoadedFunctions.current.vkQueueWaitIdle(queue); [Inline] public static VkResult WaitIdle(this VkDevice device) => VulkanLoadedFunctions.current.vkDeviceWaitIdle(device); [Inline] public static VkResult AllocateMemory(this VkDevice device, VkMemoryAllocateInfo* pAllocateInfo, VkAllocationCallbacks* pAllocator, out VkDeviceMemory pMemory) => VulkanLoadedFunctions.current.vkAllocateMemory(device, pAllocateInfo, pAllocator, out pMemory); [Inline] public static void FreeMemory(this VkDeviceMemory memory, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkFreeMemory(device, memory, pAllocator); [Inline] public static VkResult MapMemory(this VkDeviceMemory memory, VkDevice device, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, out void* ppData) => VulkanLoadedFunctions.current.vkMapMemory(device, memory, offset, size, flags, out ppData); [Inline] public static void UnmapMemory(this VkDeviceMemory memory, VkDevice device) => VulkanLoadedFunctions.current.vkUnmapMemory(device, memory); - [Inline] public static VkResult FlushMappedMemoryRanges(this VkDevice device, uint32 memoryRangeCount, VkMappedMemoryRange* pMemoryRanges) => VulkanLoadedFunctions.current.vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); - [Inline] public static VkResult InvalidateMappedMemoryRanges(this VkDevice device, uint32 memoryRangeCount, VkMappedMemoryRange* pMemoryRanges) => VulkanLoadedFunctions.current.vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + [Inline] public static VkResult FlushMappedMemoryRanges(this VkDevice device, Span pMemoryRanges) => VulkanLoadedFunctions.current.vkFlushMappedMemoryRanges(device, (.)pMemoryRanges.Length, pMemoryRanges.Ptr); + [Inline] public static VkResult InvalidateMappedMemoryRanges(this VkDevice device, Span pMemoryRanges) => VulkanLoadedFunctions.current.vkInvalidateMappedMemoryRanges(device, (.)pMemoryRanges.Length, pMemoryRanges.Ptr); [Inline] public static void GetCommitment(this VkDeviceMemory memory, VkDevice device, out VkDeviceSize pCommittedMemoryInBytes) => VulkanLoadedFunctions.current.vkGetDeviceMemoryCommitment(device, memory, out pCommittedMemoryInBytes); [Inline] public static void GetMemoryRequirements(this VkBuffer buffer, VkDevice device, out VkMemoryRequirements pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetBufferMemoryRequirements(device, buffer, out pMemoryRequirements); [Inline] public static VkResult BindMemory(this VkBuffer buffer, VkDevice device, VkDeviceMemory memory, VkDeviceSize memoryOffset) => VulkanLoadedFunctions.current.vkBindBufferMemory(device, buffer, memory, memoryOffset); @@ -2391,12 +2391,12 @@ static [Inline] public static VkResult BindMemory(this VkImage image, VkDevice device, VkDeviceMemory memory, VkDeviceSize memoryOffset) => VulkanLoadedFunctions.current.vkBindImageMemory(device, image, memory, memoryOffset); [Inline] public static void GetSparseMemoryRequirements(this VkImage image, VkDevice device, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetImageSparseMemoryRequirements(device, image, out pSparseMemoryRequirementCount, pSparseMemoryRequirements); [Inline] public static void GetSparseImageFormatProperties(this VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out uint32 pPropertyCount, VkSparseImageFormatProperties* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, out pPropertyCount, pProperties); - [Inline] public static VkResult BindSparse(this VkQueue queue, uint32 bindInfoCount, VkBindSparseInfo* pBindInfo, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + [Inline] public static VkResult BindSparse(this VkQueue queue, Span pBindInfo, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueBindSparse(queue, (.)pBindInfo.Length, pBindInfo.Ptr, fence); [Inline] public static VkResult CreateFence(this VkDevice device, VkFenceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence) => VulkanLoadedFunctions.current.vkCreateFence(device, pCreateInfo, pAllocator, out pFence); [Inline] public static void Destroy(this VkFence fence, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyFence(device, fence, pAllocator); - [Inline] public static VkResult ResetFences(this VkDevice device, uint32 fenceCount, VkFence* pFences) => VulkanLoadedFunctions.current.vkResetFences(device, fenceCount, pFences); + [Inline] public static VkResult ResetFences(this VkDevice device, Span pFences) => VulkanLoadedFunctions.current.vkResetFences(device, (.)pFences.Length, pFences.Ptr); [Inline] public static VkResult GetStatus(this VkFence fence, VkDevice device) => VulkanLoadedFunctions.current.vkGetFenceStatus(device, fence); - [Inline] public static VkResult WaitForFences(this VkDevice device, uint32 fenceCount, VkFence* pFences, VkBool32 waitAll, uint64 timeout) => VulkanLoadedFunctions.current.vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); + [Inline] public static VkResult WaitForFences(this VkDevice device, Span pFences, VkBool32 waitAll, uint64 timeout) => VulkanLoadedFunctions.current.vkWaitForFences(device, (.)pFences.Length, pFences.Ptr, waitAll, timeout); [Inline] public static VkResult CreateSemaphore(this VkDevice device, VkSemaphoreCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSemaphore pSemaphore) => VulkanLoadedFunctions.current.vkCreateSemaphore(device, pCreateInfo, pAllocator, out pSemaphore); [Inline] public static void Destroy(this VkSemaphore semaphore, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySemaphore(device, semaphore, pAllocator); [Inline] public static VkResult CreateEvent(this VkDevice device, VkEventCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkEvent pEvent) => VulkanLoadedFunctions.current.vkCreateEvent(device, pCreateInfo, pAllocator, out pEvent); @@ -2406,7 +2406,7 @@ static [Inline] public static VkResult Reset(this VkEvent event, VkDevice device) => VulkanLoadedFunctions.current.vkResetEvent(device, event); [Inline] public static VkResult CreateQueryPool(this VkDevice device, VkQueryPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkQueryPool pQueryPool) => VulkanLoadedFunctions.current.vkCreateQueryPool(device, pCreateInfo, pAllocator, out pQueryPool); [Inline] public static void Destroy(this VkQueryPool queryPool, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyQueryPool(device, queryPool, pAllocator); - [Inline] public static VkResult GetResults(this VkQueryPool queryPool, VkDevice device, uint32 firstQuery, uint32 queryCount, c_size dataSize, out void pData, VkDeviceSize stride, VkQueryResultFlags flags = default) => VulkanLoadedFunctions.current.vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, out pData, stride, flags); + [Inline] public static VkResult GetResults(this VkQueryPool queryPool, VkDevice device, uint32 firstQuery, uint32 queryCount, Span pData, VkDeviceSize stride, VkQueryResultFlags flags = default) => VulkanLoadedFunctions.current.vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, (.)pData.Length, pData.Ptr, stride, flags); [Inline] public static void Reset(this VkQueryPool queryPool, VkDevice device, uint32 firstQuery, uint32 queryCount) => VulkanLoadedFunctions.current.vkResetQueryPool(device, queryPool, firstQuery, queryCount); [Inline] public static void ResetEXT(this VkQueryPool queryPool, VkDevice device, uint32 firstQuery, uint32 queryCount) => VulkanLoadedFunctions.current.vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); [Inline] public static VkResult CreateBuffer(this VkDevice device, VkBufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBuffer pBuffer) => VulkanLoadedFunctions.current.vkCreateBuffer(device, pCreateInfo, pAllocator, out pBuffer); @@ -2423,7 +2423,7 @@ static [Inline] public static VkResult CreatePipelineCache(this VkDevice device, VkPipelineCacheCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineCache pPipelineCache) => VulkanLoadedFunctions.current.vkCreatePipelineCache(device, pCreateInfo, pAllocator, out pPipelineCache); [Inline] public static void Destroy(this VkPipelineCache pipelineCache, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPipelineCache(device, pipelineCache, pAllocator); [Inline] public static VkResult GetData(this VkPipelineCache pipelineCache, VkDevice device, out c_size pDataSize, void* pData = null) => VulkanLoadedFunctions.current.vkGetPipelineCacheData(device, pipelineCache, out pDataSize, pData); - [Inline] public static VkResult Merges(this VkPipelineCache dstCache, VkDevice device, uint32 srcCacheCount, VkPipelineCache* pSrcCaches) => VulkanLoadedFunctions.current.vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + [Inline] public static VkResult Merges(this VkPipelineCache dstCache, VkDevice device, Span pSrcCaches) => VulkanLoadedFunctions.current.vkMergePipelineCaches(device, dstCache, (.)pSrcCaches.Length, pSrcCaches.Ptr); [Inline] public static VkResult CreatePipelineBinariesKHR(this VkDevice device, VkPipelineBinaryCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineBinaryHandlesInfoKHR pBinaries) => VulkanLoadedFunctions.current.vkCreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, out pBinaries); [Inline] public static void DestroyKHR(this VkPipelineBinaryKHR pipelineBinary, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); [Inline] public static VkResult GetPipelineKeyKHR(this VkDevice device, VkPipelineCreateInfoKHR* pPipelineCreateInfo, out VkPipelineBinaryKeyKHR pPipelineKey) => VulkanLoadedFunctions.current.vkGetPipelineKeyKHR(device, pPipelineCreateInfo, out pPipelineKey); @@ -2443,8 +2443,8 @@ static [Inline] public static void Destroy(this VkDescriptorPool descriptorPool, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDescriptorPool(device, descriptorPool, pAllocator); [Inline] public static VkResult Reset(this VkDescriptorPool descriptorPool, VkDevice device, VkDescriptorPoolResetFlags flags = default) => VulkanLoadedFunctions.current.vkResetDescriptorPool(device, descriptorPool, flags); [Inline] public static VkResult AllocateDescriptorSets(this VkDevice device, VkDescriptorSetAllocateInfo* pAllocateInfo, out VkDescriptorSet pDescriptorSets) => VulkanLoadedFunctions.current.vkAllocateDescriptorSets(device, pAllocateInfo, out pDescriptorSets); - [Inline] public static VkResult FreeDescriptorSets(this VkDescriptorPool descriptorPool, VkDevice device, uint32 descriptorSetCount, VkDescriptorSet* pDescriptorSets) => VulkanLoadedFunctions.current.vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); - [Inline] public static void UpdateDescriptorSets(this VkDevice device, uint32 descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites, uint32 descriptorCopyCount, VkCopyDescriptorSet* pDescriptorCopies) => VulkanLoadedFunctions.current.vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + [Inline] public static VkResult FreeDescriptorSets(this VkDescriptorPool descriptorPool, VkDevice device, Span pDescriptorSets) => VulkanLoadedFunctions.current.vkFreeDescriptorSets(device, descriptorPool, (.)pDescriptorSets.Length, pDescriptorSets.Ptr); + [Inline] public static void UpdateDescriptorSets(this VkDevice device, Span pDescriptorWrites, Span pDescriptorCopies) => VulkanLoadedFunctions.current.vkUpdateDescriptorSets(device, (.)pDescriptorWrites.Length, pDescriptorWrites.Ptr, (.)pDescriptorCopies.Length, pDescriptorCopies.Ptr); [Inline] public static VkResult CreateFramebuffer(this VkDevice device, VkFramebufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkFramebuffer pFramebuffer) => VulkanLoadedFunctions.current.vkCreateFramebuffer(device, pCreateInfo, pAllocator, out pFramebuffer); [Inline] public static void Destroy(this VkFramebuffer framebuffer, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyFramebuffer(device, framebuffer, pAllocator); [Inline] public static VkResult CreateRenderPass(this VkDevice device, VkRenderPassCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkRenderPass pRenderPass) => VulkanLoadedFunctions.current.vkCreateRenderPass(device, pCreateInfo, pAllocator, out pRenderPass); @@ -2456,14 +2456,14 @@ static [Inline] public static void Destroy(this VkCommandPool commandPool, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyCommandPool(device, commandPool, pAllocator); [Inline] public static VkResult Reset(this VkCommandPool commandPool, VkDevice device, VkCommandPoolResetFlags flags = default) => VulkanLoadedFunctions.current.vkResetCommandPool(device, commandPool, flags); [Inline] public static VkResult AllocateCommandBuffers(this VkDevice device, VkCommandBufferAllocateInfo* pAllocateInfo, out VkCommandBuffer pCommandBuffers) => VulkanLoadedFunctions.current.vkAllocateCommandBuffers(device, pAllocateInfo, out pCommandBuffers); - [Inline] public static void FreeCommandBuffers(this VkCommandPool commandPool, VkDevice device, uint32 commandBufferCount, VkCommandBuffer* pCommandBuffers) => VulkanLoadedFunctions.current.vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + [Inline] public static void FreeCommandBuffers(this VkCommandPool commandPool, VkDevice device, Span pCommandBuffers) => VulkanLoadedFunctions.current.vkFreeCommandBuffers(device, commandPool, (.)pCommandBuffers.Length, pCommandBuffers.Ptr); [Inline] public static VkResult Begin(this VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo* pBeginInfo) => VulkanLoadedFunctions.current.vkBeginCommandBuffer(commandBuffer, pBeginInfo); [Inline] public static VkResult End(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkEndCommandBuffer(commandBuffer); [Inline] public static VkResult Reset(this VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags = default) => VulkanLoadedFunctions.current.vkResetCommandBuffer(commandBuffer, flags); [Inline] public static void BindPipeline(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) => VulkanLoadedFunctions.current.vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); [Inline] public static void SetAttachmentFeedbackLoopEnableEXT(this VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask = default) => VulkanLoadedFunctions.current.vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); - [Inline] public static void SetViewport(this VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewport* pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); - [Inline] public static void SetScissor(this VkCommandBuffer commandBuffer, uint32 firstScissor, uint32 scissorCount, VkRect2D* pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); + [Inline] public static void SetViewport(this VkCommandBuffer commandBuffer, uint32 firstViewport, Span pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewport(commandBuffer, firstViewport, (.)pViewports.Length, pViewports.Ptr); + [Inline] public static void SetScissor(this VkCommandBuffer commandBuffer, uint32 firstScissor, Span pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissor(commandBuffer, firstScissor, (.)pScissors.Length, pScissors.Ptr); [Inline] public static void SetLineWidth(this VkCommandBuffer commandBuffer, float lineWidth) => VulkanLoadedFunctions.current.vkCmdSetLineWidth(commandBuffer, lineWidth); [Inline] public static void SetDepthBias(this VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) => VulkanLoadedFunctions.current.vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); [Inline] public static void SetBlendConstants(this VkCommandBuffer commandBuffer, float[4] blendConstants) => VulkanLoadedFunctions.current.vkCmdSetBlendConstants(commandBuffer, blendConstants); @@ -2471,13 +2471,13 @@ static [Inline] public static void SetStencilCompareMask(this VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 compareMask) => VulkanLoadedFunctions.current.vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); [Inline] public static void SetStencilWriteMask(this VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 writeMask) => VulkanLoadedFunctions.current.vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); [Inline] public static void SetStencilReference(this VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 reference) => VulkanLoadedFunctions.current.vkCmdSetStencilReference(commandBuffer, faceMask, reference); - [Inline] public static void BindDescriptorSets(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 firstSet, uint32 descriptorSetCount, VkDescriptorSet* pDescriptorSets, uint32 dynamicOffsetCount, uint32* pDynamicOffsets) => VulkanLoadedFunctions.current.vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + [Inline] public static void BindDescriptorSets(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 firstSet, Span pDescriptorSets, Span pDynamicOffsets) => VulkanLoadedFunctions.current.vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, (.)pDescriptorSets.Length, pDescriptorSets.Ptr, (.)pDynamicOffsets.Length, pDynamicOffsets.Ptr); [Inline] public static void BindIndexBuffer(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) => VulkanLoadedFunctions.current.vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); [Inline] public static void BindVertexBuffers(this VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets) => VulkanLoadedFunctions.current.vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); [Inline] public static void Draw(this VkCommandBuffer commandBuffer, uint32 vertexCount, uint32 instanceCount, uint32 firstVertex, uint32 firstInstance) => VulkanLoadedFunctions.current.vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); [Inline] public static void DrawIndexed(this VkCommandBuffer commandBuffer, uint32 indexCount, uint32 instanceCount, uint32 firstIndex, int32 vertexOffset, uint32 firstInstance) => VulkanLoadedFunctions.current.vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - [Inline] public static void DrawMultiEXT(this VkCommandBuffer commandBuffer, uint32 drawCount, VkMultiDrawInfoEXT* pVertexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); - [Inline] public static void DrawMultiIndexedEXT(this VkCommandBuffer commandBuffer, uint32 drawCount, VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride, int32* pVertexOffset = null) => VulkanLoadedFunctions.current.vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); + [Inline] public static void DrawMultiEXT(this VkCommandBuffer commandBuffer, Span pVertexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMultiEXT(commandBuffer, (.)pVertexInfo.Length, pVertexInfo.Ptr, instanceCount, firstInstance, stride); + [Inline] public static void DrawMultiIndexedEXT(this VkCommandBuffer commandBuffer, Span pIndexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride, int32* pVertexOffset = null) => VulkanLoadedFunctions.current.vkCmdDrawMultiIndexedEXT(commandBuffer, (.)pIndexInfo.Length, pIndexInfo.Ptr, instanceCount, firstInstance, stride, pVertexOffset); [Inline] public static void DrawIndirect(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); [Inline] public static void DrawIndexedIndirect(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); [Inline] public static void Dispatch(this VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) => VulkanLoadedFunctions.current.vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); @@ -2486,25 +2486,25 @@ static [Inline] public static void DrawClusterHUAWEI(this VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) => VulkanLoadedFunctions.current.vkCmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); [Inline] public static void DrawClusterIndirectHUAWEI(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) => VulkanLoadedFunctions.current.vkCmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); [Inline] public static void UpdatePipelineIndirectBufferNV(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) => VulkanLoadedFunctions.current.vkCmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); - [Inline] public static void CopyBuffer(this VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32 regionCount, VkBufferCopy* pRegions) => VulkanLoadedFunctions.current.vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - [Inline] public static void CopyImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageCopy* pRegions) => VulkanLoadedFunctions.current.vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - [Inline] public static void BlitImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageBlit* pRegions, VkFilter filter) => VulkanLoadedFunctions.current.vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); - [Inline] public static void CopyBufferToImage(this VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkBufferImageCopy* pRegions) => VulkanLoadedFunctions.current.vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); - [Inline] public static void CopyImageToBuffer(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32 regionCount, VkBufferImageCopy* pRegions) => VulkanLoadedFunctions.current.vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + [Inline] public static void CopyBuffer(this VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, Span pRegions) => VulkanLoadedFunctions.current.vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, (.)pRegions.Length, pRegions.Ptr); + [Inline] public static void CopyImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span pRegions) => VulkanLoadedFunctions.current.vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, (.)pRegions.Length, pRegions.Ptr); + [Inline] public static void BlitImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span pRegions, VkFilter filter) => VulkanLoadedFunctions.current.vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, (.)pRegions.Length, pRegions.Ptr, filter); + [Inline] public static void CopyBufferToImage(this VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, Span pRegions) => VulkanLoadedFunctions.current.vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, (.)pRegions.Length, pRegions.Ptr); + [Inline] public static void CopyImageToBuffer(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, Span pRegions) => VulkanLoadedFunctions.current.vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, (.)pRegions.Length, pRegions.Ptr); [Inline] public static void CopyMemoryIndirectNV(this VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32 copyCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); [Inline] public static void CopyMemoryIndirectKHR(this VkCommandBuffer commandBuffer, VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) => VulkanLoadedFunctions.current.vkCmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo); [Inline] public static void CopyMemoryToImageIndirectNV(this VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32 copyCount, uint32 stride, VkImage dstImage, VkImageLayout dstImageLayout, VkImageSubresourceLayers* pImageSubresources) => VulkanLoadedFunctions.current.vkCmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); [Inline] public static void CopyMemoryToImageIndirectKHR(this VkCommandBuffer commandBuffer, VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) => VulkanLoadedFunctions.current.vkCmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo); - [Inline] public static void UpdateBuffer(this VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void* pData) => VulkanLoadedFunctions.current.vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); + [Inline] public static void UpdateBuffer(this VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, Span pData) => VulkanLoadedFunctions.current.vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, (.)pData.Length, pData.Ptr); [Inline] public static void FillBuffer(this VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32 data) => VulkanLoadedFunctions.current.vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); - [Inline] public static void ClearColorImage(this VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, uint32 rangeCount, VkImageSubresourceRange* pRanges) => VulkanLoadedFunctions.current.vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); - [Inline] public static void ClearDepthStencilImage(this VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, uint32 rangeCount, VkImageSubresourceRange* pRanges) => VulkanLoadedFunctions.current.vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); - [Inline] public static void ClearAttachments(this VkCommandBuffer commandBuffer, uint32 attachmentCount, VkClearAttachment* pAttachments, uint32 rectCount, VkClearRect* pRects) => VulkanLoadedFunctions.current.vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); - [Inline] public static void ResolveImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageResolve* pRegions) => VulkanLoadedFunctions.current.vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + [Inline] public static void ClearColorImage(this VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, Span pRanges) => VulkanLoadedFunctions.current.vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, (.)pRanges.Length, pRanges.Ptr); + [Inline] public static void ClearDepthStencilImage(this VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, Span pRanges) => VulkanLoadedFunctions.current.vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, (.)pRanges.Length, pRanges.Ptr); + [Inline] public static void ClearAttachments(this VkCommandBuffer commandBuffer, Span pAttachments, Span pRects) => VulkanLoadedFunctions.current.vkCmdClearAttachments(commandBuffer, (.)pAttachments.Length, pAttachments.Ptr, (.)pRects.Length, pRects.Ptr); + [Inline] public static void ResolveImage(this VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span pRegions) => VulkanLoadedFunctions.current.vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, (.)pRegions.Length, pRegions.Ptr); [Inline] public static void SetEvent(this VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask = default) => VulkanLoadedFunctions.current.vkCmdSetEvent(commandBuffer, event, stageMask); [Inline] public static void ResetEvent(this VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask = default) => VulkanLoadedFunctions.current.vkCmdResetEvent(commandBuffer, event, stageMask); - [Inline] public static void WaitEvents(this VkCommandBuffer commandBuffer, uint32 eventCount, VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32 memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32 bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32 imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers) => VulkanLoadedFunctions.current.vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - [Inline] public static void PipelineBarrier(this VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32 memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32 bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32 imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers) => VulkanLoadedFunctions.current.vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + [Inline] public static void WaitEvents(this VkCommandBuffer commandBuffer, Span pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, Span pMemoryBarriers, Span pBufferMemoryBarriers, Span pImageMemoryBarriers) => VulkanLoadedFunctions.current.vkCmdWaitEvents(commandBuffer, (.)pEvents.Length, pEvents.Ptr, srcStageMask, dstStageMask, (.)pMemoryBarriers.Length, pMemoryBarriers.Ptr, (.)pBufferMemoryBarriers.Length, pBufferMemoryBarriers.Ptr, (.)pImageMemoryBarriers.Length, pImageMemoryBarriers.Ptr); + [Inline] public static void PipelineBarrier(this VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, Span pMemoryBarriers, Span pBufferMemoryBarriers, Span pImageMemoryBarriers) => VulkanLoadedFunctions.current.vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, (.)pMemoryBarriers.Length, pMemoryBarriers.Ptr, (.)pBufferMemoryBarriers.Length, pBufferMemoryBarriers.Ptr, (.)pImageMemoryBarriers.Length, pImageMemoryBarriers.Ptr); [Inline] public static void BeginQuery(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, VkQueryControlFlags flags = default) => VulkanLoadedFunctions.current.vkCmdBeginQuery(commandBuffer, queryPool, query, flags); [Inline] public static void EndQuery(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query) => VulkanLoadedFunctions.current.vkCmdEndQuery(commandBuffer, queryPool, query); [Inline] public static void BeginConditionalRenderingEXT(this VkCommandBuffer commandBuffer, VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) => VulkanLoadedFunctions.current.vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); @@ -2513,11 +2513,11 @@ static [Inline] public static void ResetQueryPool(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount) => VulkanLoadedFunctions.current.vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); [Inline] public static void WriteTimestamp(this VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32 query) => VulkanLoadedFunctions.current.vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); [Inline] public static void CopyQueryPoolResults(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags = default) => VulkanLoadedFunctions.current.vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); - [Inline] public static void PushConstants(this VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32 offset, uint32 size, void* pValues) => VulkanLoadedFunctions.current.vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); + [Inline] public static void PushConstants(this VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32 offset, Span pValues) => VulkanLoadedFunctions.current.vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, (.)pValues.Length, pValues.Ptr); [Inline] public static void BeginRenderPass(this VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) => VulkanLoadedFunctions.current.vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); [Inline] public static void NextSubpass(this VkCommandBuffer commandBuffer, VkSubpassContents contents) => VulkanLoadedFunctions.current.vkCmdNextSubpass(commandBuffer, contents); [Inline] public static void EndRenderPass(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdEndRenderPass(commandBuffer); - [Inline] public static void ExecuteCommands(this VkCommandBuffer commandBuffer, uint32 commandBufferCount, VkCommandBuffer* pCommandBuffers) => VulkanLoadedFunctions.current.vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); + [Inline] public static void ExecuteCommands(this VkCommandBuffer commandBuffer, Span pCommandBuffers) => VulkanLoadedFunctions.current.vkCmdExecuteCommands(commandBuffer, (.)pCommandBuffers.Length, pCommandBuffers.Ptr); [Inline] public static VkResult CreateAndroidSurfaceKHR(this VkInstance instance, VkAndroidSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); [Inline] public static VkResult CreateSurfaceOHOS(this VkInstance instance, VkSurfaceCreateInfoOHOS* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateSurfaceOHOS(instance, pCreateInfo, pAllocator, out pSurface); [Inline] public static VkResult GetDisplayPropertiesKHR(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPropertiesKHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, out pPropertyCount, pProperties); @@ -2576,8 +2576,8 @@ static [Inline] public static void DestroyEXT(this VkIndirectCommandsLayoutEXT indirectCommandsLayout, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); [Inline] public static VkResult CreateIndirectExecutionSetEXT(this VkDevice device, VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectExecutionSetEXT pIndirectExecutionSet) => VulkanLoadedFunctions.current.vkCreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, out pIndirectExecutionSet); [Inline] public static void DestroyEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); - [Inline] public static void UpdatePipelineEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, uint32 executionSetWriteCount, VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) => VulkanLoadedFunctions.current.vkUpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); - [Inline] public static void UpdateShaderEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, uint32 executionSetWriteCount, VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) => VulkanLoadedFunctions.current.vkUpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); + [Inline] public static void UpdatePipelineEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, Span pExecutionSetWrites) => VulkanLoadedFunctions.current.vkUpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, (.)pExecutionSetWrites.Length, pExecutionSetWrites.Ptr); + [Inline] public static void UpdateShaderEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, Span pExecutionSetWrites) => VulkanLoadedFunctions.current.vkUpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, (.)pExecutionSetWrites.Length, pExecutionSetWrites.Ptr); [Inline] public static void GetFeatures2(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceFeatures2 pFeatures) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFeatures2(physicalDevice, out pFeatures); [Inline] public static void GetFeatures2KHR(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceFeatures2 pFeatures) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFeatures2KHR(physicalDevice, out pFeatures); [Inline] public static void GetProperties2(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceProperties2 pProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceProperties2(physicalDevice, out pProperties); @@ -2592,8 +2592,8 @@ static [Inline] public static void GetMemoryProperties2KHR(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceMemoryProperties2 pMemoryProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, out pMemoryProperties); [Inline] public static void GetSparseImageFormatProperties2(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out uint32 pPropertyCount, VkSparseImageFormatProperties2* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, out pPropertyCount, pProperties); [Inline] public static void GetSparseImageFormatProperties2KHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out uint32 pPropertyCount, VkSparseImageFormatProperties2* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, out pPropertyCount, pProperties); - [Inline] public static void PushDescriptorSet(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set, uint32 descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - [Inline] public static void PushDescriptorSetKHR(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set, uint32 descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + [Inline] public static void PushDescriptorSet(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set, Span pDescriptorWrites) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, (.)pDescriptorWrites.Length, pDescriptorWrites.Ptr); + [Inline] public static void PushDescriptorSetKHR(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set, Span pDescriptorWrites) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, (.)pDescriptorWrites.Length, pDescriptorWrites.Ptr); [Inline] public static void Trim(this VkCommandPool commandPool, VkDevice device, VkCommandPoolTrimFlags flags = default) => VulkanLoadedFunctions.current.vkTrimCommandPool(device, commandPool, flags); [Inline] public static void TrimKHR(this VkCommandPool commandPool, VkDevice device, VkCommandPoolTrimFlags flags = default) => VulkanLoadedFunctions.current.vkTrimCommandPoolKHR(device, commandPool, flags); [Inline] public static void GetExternalBufferProperties(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, out VkExternalBufferProperties pExternalBufferProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, out pExternalBufferProperties); @@ -2633,10 +2633,10 @@ static [Inline] public static VkResult EnumeratePhysicalDeviceGroupsKHR(this VkInstance instance, out uint32 pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDeviceGroupsKHR(instance, out pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); [Inline] public static void GetGroupPeerMemoryFeatures(this VkDevice device, uint32 heapIndex, uint32 localDeviceIndex, uint32 remoteDeviceIndex, out VkPeerMemoryFeatureFlags pPeerMemoryFeatures) => VulkanLoadedFunctions.current.vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, out pPeerMemoryFeatures); [Inline] public static void GetGroupPeerMemoryFeaturesKHR(this VkDevice device, uint32 heapIndex, uint32 localDeviceIndex, uint32 remoteDeviceIndex, out VkPeerMemoryFeatureFlags pPeerMemoryFeatures) => VulkanLoadedFunctions.current.vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, out pPeerMemoryFeatures); - [Inline] public static VkResult BindBufferMemory2(this VkDevice device, uint32 bindInfoCount, VkBindBufferMemoryInfo* pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2(device, bindInfoCount, pBindInfos); - [Inline] public static VkResult BindBufferMemory2KHR(this VkDevice device, uint32 bindInfoCount, VkBindBufferMemoryInfo* pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); - [Inline] public static VkResult BindImageMemory2(this VkDevice device, uint32 bindInfoCount, VkBindImageMemoryInfo* pBindInfos) => VulkanLoadedFunctions.current.vkBindImageMemory2(device, bindInfoCount, pBindInfos); - [Inline] public static VkResult BindImageMemory2KHR(this VkDevice device, uint32 bindInfoCount, VkBindImageMemoryInfo* pBindInfos) => VulkanLoadedFunctions.current.vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos); + [Inline] public static VkResult BindBufferMemory2(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2(device, (.)pBindInfos.Length, pBindInfos.Ptr); + [Inline] public static VkResult BindBufferMemory2KHR(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2KHR(device, (.)pBindInfos.Length, pBindInfos.Ptr); + [Inline] public static VkResult BindImageMemory2(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindImageMemory2(device, (.)pBindInfos.Length, pBindInfos.Ptr); + [Inline] public static VkResult BindImageMemory2KHR(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindImageMemory2KHR(device, (.)pBindInfos.Length, pBindInfos.Ptr); [Inline] public static void SetDeviceMask(this VkCommandBuffer commandBuffer, uint32 deviceMask) => VulkanLoadedFunctions.current.vkCmdSetDeviceMask(commandBuffer, deviceMask); [Inline] public static void SetDeviceMaskKHR(this VkCommandBuffer commandBuffer, uint32 deviceMask) => VulkanLoadedFunctions.current.vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); [Inline] public static VkResult GetGroupPresentCapabilitiesKHR(this VkDevice device, out VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities) => VulkanLoadedFunctions.current.vkGetDeviceGroupPresentCapabilitiesKHR(device, out pDeviceGroupPresentCapabilities); @@ -2660,8 +2660,8 @@ static [Inline] public static VkResult CreateIOSSurfaceMVK(this VkInstance instance, VkIOSSurfaceCreateInfoMVK* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, out pSurface); [Inline] public static VkResult CreateMacOSSurfaceMVK(this VkInstance instance, VkMacOSSurfaceCreateInfoMVK* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, out pSurface); [Inline] public static VkResult CreateMetalSurfaceEXT(this VkInstance instance, VkMetalSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, out pSurface); - [Inline] public static void SetViewportWScalingNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewportWScalingNV* pViewportWScalings) => VulkanLoadedFunctions.current.vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); - [Inline] public static void SetDiscardRectangleEXT(this VkCommandBuffer commandBuffer, uint32 firstDiscardRectangle, uint32 discardRectangleCount, VkRect2D* pDiscardRectangles) => VulkanLoadedFunctions.current.vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + [Inline] public static void SetViewportWScalingNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, Span pViewportWScalings) => VulkanLoadedFunctions.current.vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, (.)pViewportWScalings.Length, pViewportWScalings.Ptr); + [Inline] public static void SetDiscardRectangleEXT(this VkCommandBuffer commandBuffer, uint32 firstDiscardRectangle, Span pDiscardRectangles) => VulkanLoadedFunctions.current.vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, (.)pDiscardRectangles.Length, pDiscardRectangles.Ptr); [Inline] public static void SetDiscardRectangleEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) => VulkanLoadedFunctions.current.vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); [Inline] public static void SetDiscardRectangleModeEXT(this VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) => VulkanLoadedFunctions.current.vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); [Inline] public static void SetSampleLocationsEXT(this VkCommandBuffer commandBuffer, VkSampleLocationsInfoEXT* pSampleLocationsInfo) => VulkanLoadedFunctions.current.vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); @@ -2692,7 +2692,7 @@ static [Inline] public static VkResult CreateValidationCacheEXT(this VkDevice device, VkValidationCacheCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkValidationCacheEXT pValidationCache) => VulkanLoadedFunctions.current.vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, out pValidationCache); [Inline] public static void DestroyEXT(this VkValidationCacheEXT validationCache, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyValidationCacheEXT(device, validationCache, pAllocator); [Inline] public static VkResult GetDataEXT(this VkValidationCacheEXT validationCache, VkDevice device, out c_size pDataSize, void* pData = null) => VulkanLoadedFunctions.current.vkGetValidationCacheDataEXT(device, validationCache, out pDataSize, pData); - [Inline] public static VkResult MergesEXT(this VkValidationCacheEXT dstCache, VkDevice device, uint32 srcCacheCount, VkValidationCacheEXT* pSrcCaches) => VulkanLoadedFunctions.current.vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); + [Inline] public static VkResult MergesEXT(this VkValidationCacheEXT dstCache, VkDevice device, Span pSrcCaches) => VulkanLoadedFunctions.current.vkMergeValidationCachesEXT(device, dstCache, (.)pSrcCaches.Length, pSrcCaches.Ptr); [Inline] public static void GetDescriptorSetLayoutSupport(this VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, out VkDescriptorSetLayoutSupport pSupport) => VulkanLoadedFunctions.current.vkGetDescriptorSetLayoutSupport(device, pCreateInfo, out pSupport); [Inline] public static void GetDescriptorSetLayoutSupportKHR(this VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, out VkDescriptorSetLayoutSupport pSupport) => VulkanLoadedFunctions.current.vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, out pSupport); [Inline] public static VkResult GetShaderInfoAMD(this VkPipeline pipeline, VkDevice device, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out c_size pInfoSize, void* pInfo = null) => VulkanLoadedFunctions.current.vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, out pInfoSize, pInfo); @@ -2744,11 +2744,11 @@ static [Inline] public static void BeginQueryIndexedEXT(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, VkQueryControlFlags flags, uint32 index) => VulkanLoadedFunctions.current.vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); [Inline] public static void EndQueryIndexedEXT(this VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, uint32 index) => VulkanLoadedFunctions.current.vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); [Inline] public static void DrawIndirectByteCountEXT(this VkCommandBuffer commandBuffer, uint32 instanceCount, uint32 firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32 counterOffset, uint32 vertexStride) => VulkanLoadedFunctions.current.vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); - [Inline] public static void SetExclusiveScissorNV(this VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, uint32 exclusiveScissorCount, VkRect2D* pExclusiveScissors) => VulkanLoadedFunctions.current.vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); - [Inline] public static void SetExclusiveScissorEnableNV(this VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, uint32 exclusiveScissorCount, VkBool32* pExclusiveScissorEnables) => VulkanLoadedFunctions.current.vkCmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); + [Inline] public static void SetExclusiveScissorNV(this VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, Span pExclusiveScissors) => VulkanLoadedFunctions.current.vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, (.)pExclusiveScissors.Length, pExclusiveScissors.Ptr); + [Inline] public static void SetExclusiveScissorEnableNV(this VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, Span pExclusiveScissorEnables) => VulkanLoadedFunctions.current.vkCmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, (.)pExclusiveScissorEnables.Length, pExclusiveScissorEnables.Ptr); [Inline] public static void BindShadingRateImageNV(this VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) => VulkanLoadedFunctions.current.vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); - [Inline] public static void SetViewportShadingRatePaletteNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkShadingRatePaletteNV* pShadingRatePalettes) => VulkanLoadedFunctions.current.vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); - [Inline] public static void SetCoarseSampleOrderNV(this VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32 customSampleOrderCount, VkCoarseSampleOrderCustomNV* pCustomSampleOrders) => VulkanLoadedFunctions.current.vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + [Inline] public static void SetViewportShadingRatePaletteNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, Span pShadingRatePalettes) => VulkanLoadedFunctions.current.vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, (.)pShadingRatePalettes.Length, pShadingRatePalettes.Ptr); + [Inline] public static void SetCoarseSampleOrderNV(this VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, Span pCustomSampleOrders) => VulkanLoadedFunctions.current.vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, (.)pCustomSampleOrders.Length, pCustomSampleOrders.Ptr); [Inline] public static void DrawMeshTasksNV(this VkCommandBuffer commandBuffer, uint32 taskCount, uint32 firstTask) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); [Inline] public static void DrawMeshTasksIndirectNV(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); [Inline] public static void DrawMeshTasksIndirectCountNV(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); @@ -2761,7 +2761,7 @@ static [Inline] public static void DestroyKHR(this VkAccelerationStructureKHR accelerationStructure, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); [Inline] public static void DestroyNV(this VkAccelerationStructureNV accelerationStructure, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); [Inline] public static void GetAccelerationStructureMemoryRequirementsNV(this VkDevice device, VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, out VkMemoryRequirements2KHR pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, out pMemoryRequirements); - [Inline] public static VkResult BindAccelerationStructureMemoryNV(this VkDevice device, uint32 bindInfoCount, VkBindAccelerationStructureMemoryInfoNV* pBindInfos) => VulkanLoadedFunctions.current.vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); + [Inline] public static VkResult BindAccelerationStructureMemoryNV(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindAccelerationStructureMemoryNV(device, (.)pBindInfos.Length, pBindInfos.Ptr); [Inline] public static void CopyAccelerationStructureNV(this VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) => VulkanLoadedFunctions.current.vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); [Inline] public static void CopyAccelerationStructureKHR(this VkCommandBuffer commandBuffer, VkCopyAccelerationStructureInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo); [Inline] public static VkResult CopyAccelerationStructureKHR(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyAccelerationStructureInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo); @@ -2769,16 +2769,16 @@ static [Inline] public static VkResult CopyAccelerationStructureToMemoryKHR(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); [Inline] public static void CopyMemoryToAccelerationStructureKHR(this VkCommandBuffer commandBuffer, VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); [Inline] public static VkResult CopyMemoryToAccelerationStructureKHR(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); - [Inline] public static void WriteAccelerationStructuresPropertiesKHR(this VkCommandBuffer commandBuffer, uint32 accelerationStructureCount, VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); - [Inline] public static void WriteAccelerationStructuresPropertiesNV(this VkCommandBuffer commandBuffer, uint32 accelerationStructureCount, VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + [Inline] public static void WriteAccelerationStructuresPropertiesKHR(this VkCommandBuffer commandBuffer, Span pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, (.)pAccelerationStructures.Length, pAccelerationStructures.Ptr, queryType, queryPool, firstQuery); + [Inline] public static void WriteAccelerationStructuresPropertiesNV(this VkCommandBuffer commandBuffer, Span pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, (.)pAccelerationStructures.Length, pAccelerationStructures.Ptr, queryType, queryPool, firstQuery); [Inline] public static void BuildAccelerationStructureNV(this VkCommandBuffer commandBuffer, VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) => VulkanLoadedFunctions.current.vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); - [Inline] public static VkResult WriteAccelerationStructuresPropertiesKHR(this VkDevice device, uint32 accelerationStructureCount, VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, c_size dataSize, out void pData, c_size stride) => VulkanLoadedFunctions.current.vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, out pData, stride); + [Inline] public static VkResult WriteAccelerationStructuresPropertiesKHR(this VkDevice device, Span pAccelerationStructures, VkQueryType queryType, Span pData, c_size stride) => VulkanLoadedFunctions.current.vkWriteAccelerationStructuresPropertiesKHR(device, (.)pAccelerationStructures.Length, pAccelerationStructures.Ptr, queryType, (.)pData.Length, pData.Ptr, stride); [Inline] public static void TraceRaysKHR(this VkCommandBuffer commandBuffer, VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32 width, uint32 height, uint32 depth) => VulkanLoadedFunctions.current.vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); [Inline] public static void TraceRaysNV(this VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32 width, uint32 height, uint32 depth) => VulkanLoadedFunctions.current.vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); - [Inline] public static VkResult GetRayTracingShaderGroupHandlesKHR(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, c_size dataSize, out void pData) => VulkanLoadedFunctions.current.vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, out pData); - [Inline] public static VkResult GetRayTracingShaderGroupHandlesNV(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, c_size dataSize, out void pData) => VulkanLoadedFunctions.current.vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, out pData); - [Inline] public static VkResult GetRayTracingCaptureReplayShaderGroupHandlesKHR(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, c_size dataSize, out void pData) => VulkanLoadedFunctions.current.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, out pData); - [Inline] public static VkResult GetHandleNV(this VkAccelerationStructureNV accelerationStructure, VkDevice device, c_size dataSize, out void pData) => VulkanLoadedFunctions.current.vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, out pData); + [Inline] public static VkResult GetRayTracingShaderGroupHandlesKHR(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, Span pData) => VulkanLoadedFunctions.current.vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, (.)pData.Length, pData.Ptr); + [Inline] public static VkResult GetRayTracingShaderGroupHandlesNV(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, Span pData) => VulkanLoadedFunctions.current.vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, (.)pData.Length, pData.Ptr); + [Inline] public static VkResult GetRayTracingCaptureReplayShaderGroupHandlesKHR(this VkPipeline pipeline, VkDevice device, uint32 firstGroup, uint32 groupCount, Span pData) => VulkanLoadedFunctions.current.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, (.)pData.Length, pData.Ptr); + [Inline] public static VkResult GetHandleNV(this VkAccelerationStructureNV accelerationStructure, VkDevice device, Span pData) => VulkanLoadedFunctions.current.vkGetAccelerationStructureHandleNV(device, accelerationStructure, (.)pData.Length, pData.Ptr); [Inline] public static VkResult CreateRayTracingPipelinesNV(this VkPipelineCache pipelineCache, VkDevice device, uint32 createInfoCount, VkRayTracingPipelineCreateInfoNV* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); [Inline] public static VkResult CreateRayTracingPipelinesKHR(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkRayTracingPipelineCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); [Inline] public static VkResult GetCooperativeMatrixPropertiesNV(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, out pPropertyCount, pProperties); @@ -2846,10 +2846,10 @@ static [Inline] public static void SetFrontFaceEXT(this VkCommandBuffer commandBuffer, VkFrontFace frontFace) => VulkanLoadedFunctions.current.vkCmdSetFrontFaceEXT(commandBuffer, frontFace); [Inline] public static void SetPrimitiveTopology(this VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) => VulkanLoadedFunctions.current.vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); [Inline] public static void SetPrimitiveTopologyEXT(this VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) => VulkanLoadedFunctions.current.vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); - [Inline] public static void SetViewportWithCount(this VkCommandBuffer commandBuffer, uint32 viewportCount, VkViewport* pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); - [Inline] public static void SetViewportWithCountEXT(this VkCommandBuffer commandBuffer, uint32 viewportCount, VkViewport* pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); - [Inline] public static void SetScissorWithCount(this VkCommandBuffer commandBuffer, uint32 scissorCount, VkRect2D* pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); - [Inline] public static void SetScissorWithCountEXT(this VkCommandBuffer commandBuffer, uint32 scissorCount, VkRect2D* pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); + [Inline] public static void SetViewportWithCount(this VkCommandBuffer commandBuffer, Span pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCount(commandBuffer, (.)pViewports.Length, pViewports.Ptr); + [Inline] public static void SetViewportWithCountEXT(this VkCommandBuffer commandBuffer, Span pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCountEXT(commandBuffer, (.)pViewports.Length, pViewports.Ptr); + [Inline] public static void SetScissorWithCount(this VkCommandBuffer commandBuffer, Span pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissorWithCount(commandBuffer, (.)pScissors.Length, pScissors.Ptr); + [Inline] public static void SetScissorWithCountEXT(this VkCommandBuffer commandBuffer, Span pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissorWithCountEXT(commandBuffer, (.)pScissors.Length, pScissors.Ptr); [Inline] public static void BindIndexBuffer2(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) => VulkanLoadedFunctions.current.vkCmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType); [Inline] public static void BindIndexBuffer2KHR(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) => VulkanLoadedFunctions.current.vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); [Inline] public static void BindVertexBuffers2(this VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes = null, VkDeviceSize* pStrides = null) => VulkanLoadedFunctions.current.vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); @@ -2882,26 +2882,26 @@ static [Inline] public static void SetAlphaToCoverageEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) => VulkanLoadedFunctions.current.vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); [Inline] public static void SetAlphaToOneEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) => VulkanLoadedFunctions.current.vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); [Inline] public static void SetLogicOpEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) => VulkanLoadedFunctions.current.vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); - [Inline] public static void SetColorBlendEnableEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkBool32* pColorBlendEnables) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); - [Inline] public static void SetColorBlendEquationEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorBlendEquationEXT* pColorBlendEquations) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); - [Inline] public static void SetColorWriteMaskEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorComponentFlags* pColorWriteMasks) => VulkanLoadedFunctions.current.vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); + [Inline] public static void SetColorBlendEnableEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span pColorBlendEnables) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, (.)pColorBlendEnables.Length, pColorBlendEnables.Ptr); + [Inline] public static void SetColorBlendEquationEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span pColorBlendEquations) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, (.)pColorBlendEquations.Length, pColorBlendEquations.Ptr); + [Inline] public static void SetColorWriteMaskEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span pColorWriteMasks) => VulkanLoadedFunctions.current.vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, (.)pColorWriteMasks.Length, pColorWriteMasks.Ptr); [Inline] public static void SetRasterizationStreamEXT(this VkCommandBuffer commandBuffer, uint32 rasterizationStream) => VulkanLoadedFunctions.current.vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); [Inline] public static void SetConservativeRasterizationModeEXT(this VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) => VulkanLoadedFunctions.current.vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); [Inline] public static void SetExtraPrimitiveOverestimationSizeEXT(this VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) => VulkanLoadedFunctions.current.vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); [Inline] public static void SetDepthClipEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); [Inline] public static void SetSampleLocationsEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) => VulkanLoadedFunctions.current.vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); - [Inline] public static void SetColorBlendAdvancedEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorBlendAdvancedEXT* pColorBlendAdvanced) => VulkanLoadedFunctions.current.vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); + [Inline] public static void SetColorBlendAdvancedEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span pColorBlendAdvanced) => VulkanLoadedFunctions.current.vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, (.)pColorBlendAdvanced.Length, pColorBlendAdvanced.Ptr); [Inline] public static void SetProvokingVertexModeEXT(this VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) => VulkanLoadedFunctions.current.vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); [Inline] public static void SetLineRasterizationModeEXT(this VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) => VulkanLoadedFunctions.current.vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); [Inline] public static void SetLineStippleEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) => VulkanLoadedFunctions.current.vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); [Inline] public static void SetDepthClipNegativeOneToOneEXT(this VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) => VulkanLoadedFunctions.current.vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); [Inline] public static void SetViewportWScalingEnableNV(this VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) => VulkanLoadedFunctions.current.vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); - [Inline] public static void SetViewportSwizzleNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewportSwizzleNV* pViewportSwizzles) => VulkanLoadedFunctions.current.vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); + [Inline] public static void SetViewportSwizzleNV(this VkCommandBuffer commandBuffer, uint32 firstViewport, Span pViewportSwizzles) => VulkanLoadedFunctions.current.vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, (.)pViewportSwizzles.Length, pViewportSwizzles.Ptr); [Inline] public static void SetCoverageToColorEnableNV(this VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) => VulkanLoadedFunctions.current.vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); [Inline] public static void SetCoverageToColorLocationNV(this VkCommandBuffer commandBuffer, uint32 coverageToColorLocation) => VulkanLoadedFunctions.current.vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); [Inline] public static void SetCoverageModulationModeNV(this VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) => VulkanLoadedFunctions.current.vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); [Inline] public static void SetCoverageModulationTableEnableNV(this VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) => VulkanLoadedFunctions.current.vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); - [Inline] public static void SetCoverageModulationTableNV(this VkCommandBuffer commandBuffer, uint32 coverageModulationTableCount, float* pCoverageModulationTable) => VulkanLoadedFunctions.current.vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); + [Inline] public static void SetCoverageModulationTableNV(this VkCommandBuffer commandBuffer, Span pCoverageModulationTable) => VulkanLoadedFunctions.current.vkCmdSetCoverageModulationTableNV(commandBuffer, (.)pCoverageModulationTable.Length, pCoverageModulationTable.Ptr); [Inline] public static void SetShadingRateImageEnableNV(this VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) => VulkanLoadedFunctions.current.vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); [Inline] public static void SetCoverageReductionModeNV(this VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) => VulkanLoadedFunctions.current.vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); [Inline] public static void SetRepresentativeFragmentTestEnableNV(this VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) => VulkanLoadedFunctions.current.vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); @@ -2929,8 +2929,8 @@ static [Inline] public static VkResult GetFragmentShadingRatesKHR(this VkPhysicalDevice physicalDevice, out uint32 pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, out pFragmentShadingRateCount, pFragmentShadingRates); [Inline] public static void SetFragmentShadingRateEnumNV(this VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, VkFragmentShadingRateCombinerOpKHR[2] combinerOps) => VulkanLoadedFunctions.current.vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); [Inline] public static void GetAccelerationStructureBuildSizesKHR(this VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, uint32* pMaxPrimitiveCounts, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo) => VulkanLoadedFunctions.current.vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, out pSizeInfo); - [Inline] public static void SetVertexInputEXT(this VkCommandBuffer commandBuffer, uint32 vertexBindingDescriptionCount, VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32 vertexAttributeDescriptionCount, VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) => VulkanLoadedFunctions.current.vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); - [Inline] public static void SetColorWriteEnableEXT(this VkCommandBuffer commandBuffer, uint32 attachmentCount, VkBool32* pColorWriteEnables) => VulkanLoadedFunctions.current.vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); + [Inline] public static void SetVertexInputEXT(this VkCommandBuffer commandBuffer, Span pVertexBindingDescriptions, Span pVertexAttributeDescriptions) => VulkanLoadedFunctions.current.vkCmdSetVertexInputEXT(commandBuffer, (.)pVertexBindingDescriptions.Length, pVertexBindingDescriptions.Ptr, (.)pVertexAttributeDescriptions.Length, pVertexAttributeDescriptions.Ptr); + [Inline] public static void SetColorWriteEnableEXT(this VkCommandBuffer commandBuffer, Span pColorWriteEnables) => VulkanLoadedFunctions.current.vkCmdSetColorWriteEnableEXT(commandBuffer, (.)pColorWriteEnables.Length, pColorWriteEnables.Ptr); [Inline] public static void SetEvent2(this VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfo* pDependencyInfo) => VulkanLoadedFunctions.current.vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); [Inline] public static void SetEvent2KHR(this VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfo* pDependencyInfo) => VulkanLoadedFunctions.current.vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); [Inline] public static void ResetEvent2(this VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask = default) => VulkanLoadedFunctions.current.vkCmdResetEvent2(commandBuffer, event, stageMask); @@ -2939,8 +2939,8 @@ static [Inline] public static void WaitEvents2KHR(this VkCommandBuffer commandBuffer, uint32 eventCount, VkEvent* pEvents, VkDependencyInfo* pDependencyInfos) => VulkanLoadedFunctions.current.vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); [Inline] public static void PipelineBarrier2(this VkCommandBuffer commandBuffer, VkDependencyInfo* pDependencyInfo) => VulkanLoadedFunctions.current.vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); [Inline] public static void PipelineBarrier2KHR(this VkCommandBuffer commandBuffer, VkDependencyInfo* pDependencyInfo) => VulkanLoadedFunctions.current.vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); - [Inline] public static VkResult Submit2(this VkQueue queue, uint32 submitCount, VkSubmitInfo2* pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit2(queue, submitCount, pSubmits, fence); - [Inline] public static VkResult Submit2KHR(this VkQueue queue, uint32 submitCount, VkSubmitInfo2* pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence); + [Inline] public static VkResult Submit2(this VkQueue queue, Span pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit2(queue, (.)pSubmits.Length, pSubmits.Ptr, fence); + [Inline] public static VkResult Submit2KHR(this VkQueue queue, Span pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit2KHR(queue, (.)pSubmits.Length, pSubmits.Ptr, fence); [Inline] public static void WriteTimestamp2(this VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32 query) => VulkanLoadedFunctions.current.vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); [Inline] public static void WriteTimestamp2KHR(this VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32 query) => VulkanLoadedFunctions.current.vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); [Inline] public static void WriteBufferMarker2AMD(this VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32 marker) => VulkanLoadedFunctions.current.vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); @@ -2951,8 +2951,8 @@ static [Inline] public static VkResult CopyImageToMemoryEXT(this VkDevice device, VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) => VulkanLoadedFunctions.current.vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); [Inline] public static VkResult CopyImageToImage(this VkDevice device, VkCopyImageToImageInfo* pCopyImageToImageInfo) => VulkanLoadedFunctions.current.vkCopyImageToImage(device, pCopyImageToImageInfo); [Inline] public static VkResult CopyImageToImageEXT(this VkDevice device, VkCopyImageToImageInfo* pCopyImageToImageInfo) => VulkanLoadedFunctions.current.vkCopyImageToImageEXT(device, pCopyImageToImageInfo); - [Inline] public static VkResult TransitionImageLayout(this VkDevice device, uint32 transitionCount, VkHostImageLayoutTransitionInfo* pTransitions) => VulkanLoadedFunctions.current.vkTransitionImageLayout(device, transitionCount, pTransitions); - [Inline] public static VkResult TransitionImageLayoutEXT(this VkDevice device, uint32 transitionCount, VkHostImageLayoutTransitionInfo* pTransitions) => VulkanLoadedFunctions.current.vkTransitionImageLayoutEXT(device, transitionCount, pTransitions); + [Inline] public static VkResult TransitionImageLayout(this VkDevice device, Span pTransitions) => VulkanLoadedFunctions.current.vkTransitionImageLayout(device, (.)pTransitions.Length, pTransitions.Ptr); + [Inline] public static VkResult TransitionImageLayoutEXT(this VkDevice device, Span pTransitions) => VulkanLoadedFunctions.current.vkTransitionImageLayoutEXT(device, (.)pTransitions.Length, pTransitions.Ptr); [Inline] public static VkResult GetVideoCapabilitiesKHR(this VkPhysicalDevice physicalDevice, VkVideoProfileInfoKHR* pVideoProfile, out VkVideoCapabilitiesKHR pCapabilities) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, out pCapabilities); [Inline] public static VkResult GetVideoFormatPropertiesKHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, out uint32 pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, out pVideoFormatPropertyCount, pVideoFormatProperties); [Inline] public static VkResult GetVideoEncodeQualityLevelPropertiesKHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, out VkVideoEncodeQualityLevelPropertiesKHR pQualityLevelProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, out pQualityLevelProperties); @@ -2963,13 +2963,13 @@ static [Inline] public static VkResult GetEncodedVideoSessionParametersKHR(this VkDevice device, VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, out VkVideoEncodeSessionParametersFeedbackInfoKHR pFeedbackInfo, out c_size pDataSize, void* pData = null) => VulkanLoadedFunctions.current.vkGetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, out pFeedbackInfo, out pDataSize, pData); [Inline] public static void DestroyVideoSessionParametersKHR(this VkDevice device, VkVideoSessionParametersKHR videoSessionParameters = null, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); [Inline] public static VkResult GetMemoryRequirementsKHR(this VkVideoSessionKHR videoSession, VkDevice device, out uint32 pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, out pMemoryRequirementsCount, pMemoryRequirements); - [Inline] public static VkResult BindMemoryKHR(this VkVideoSessionKHR videoSession, VkDevice device, uint32 bindSessionMemoryInfoCount, VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) => VulkanLoadedFunctions.current.vkBindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + [Inline] public static VkResult BindMemoryKHR(this VkVideoSessionKHR videoSession, VkDevice device, Span pBindSessionMemoryInfos) => VulkanLoadedFunctions.current.vkBindVideoSessionMemoryKHR(device, videoSession, (.)pBindSessionMemoryInfos.Length, pBindSessionMemoryInfos.Ptr); [Inline] public static void DecodeVideoKHR(this VkCommandBuffer commandBuffer, VkVideoDecodeInfoKHR* pDecodeInfo) => VulkanLoadedFunctions.current.vkCmdDecodeVideoKHR(commandBuffer, pDecodeInfo); [Inline] public static void BeginVideoCodingKHR(this VkCommandBuffer commandBuffer, VkVideoBeginCodingInfoKHR* pBeginInfo) => VulkanLoadedFunctions.current.vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); [Inline] public static void ControlVideoCodingKHR(this VkCommandBuffer commandBuffer, VkVideoCodingControlInfoKHR* pCodingControlInfo) => VulkanLoadedFunctions.current.vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); [Inline] public static void EndVideoCodingKHR(this VkCommandBuffer commandBuffer, VkVideoEndCodingInfoKHR* pEndCodingInfo) => VulkanLoadedFunctions.current.vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); [Inline] public static void EncodeVideoKHR(this VkCommandBuffer commandBuffer, VkVideoEncodeInfoKHR* pEncodeInfo) => VulkanLoadedFunctions.current.vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo); - [Inline] public static void DecompressMemoryNV(this VkCommandBuffer commandBuffer, uint32 decompressRegionCount, VkDecompressMemoryRegionNV* pDecompressMemoryRegions) => VulkanLoadedFunctions.current.vkCmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); + [Inline] public static void DecompressMemoryNV(this VkCommandBuffer commandBuffer, Span pDecompressMemoryRegions) => VulkanLoadedFunctions.current.vkCmdDecompressMemoryNV(commandBuffer, (.)pDecompressMemoryRegions.Length, pDecompressMemoryRegions.Ptr); [Inline] public static void DecompressMemoryIndirectCountNV(this VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); [Inline] public static void GetPartitionedAccelerationStructuresBuildSizesNV(this VkDevice device, VkPartitionedAccelerationStructureInstancesInputNV* pInfo, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo) => VulkanLoadedFunctions.current.vkGetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, out pSizeInfo); [Inline] public static void BuildPartitionedAccelerationStructuresNV(this VkCommandBuffer commandBuffer, VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) => VulkanLoadedFunctions.current.vkCmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo); @@ -2982,8 +2982,8 @@ static [Inline] public static void CuLaunchKernelNVX(this VkCommandBuffer commandBuffer, VkCuLaunchInfoNVX* pLaunchInfo) => VulkanLoadedFunctions.current.vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); [Inline] public static void GetSizeEXT(this VkDescriptorSetLayout layout, VkDevice device, out VkDeviceSize pLayoutSizeInBytes) => VulkanLoadedFunctions.current.vkGetDescriptorSetLayoutSizeEXT(device, layout, out pLayoutSizeInBytes); [Inline] public static void GetBindingOffsetEXT(this VkDescriptorSetLayout layout, VkDevice device, uint32 binding, out VkDeviceSize pOffset) => VulkanLoadedFunctions.current.vkGetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, out pOffset); - [Inline] public static void GetDescriptorEXT(this VkDevice device, VkDescriptorGetInfoEXT* pDescriptorInfo, c_size dataSize, out void pDescriptor) => VulkanLoadedFunctions.current.vkGetDescriptorEXT(device, pDescriptorInfo, dataSize, out pDescriptor); - [Inline] public static void BindDescriptorBuffersEXT(this VkCommandBuffer commandBuffer, uint32 bufferCount, VkDescriptorBufferBindingInfoEXT* pBindingInfos) => VulkanLoadedFunctions.current.vkCmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); + [Inline] public static void GetDescriptorEXT(this VkDevice device, VkDescriptorGetInfoEXT* pDescriptorInfo, Span pDescriptor) => VulkanLoadedFunctions.current.vkGetDescriptorEXT(device, pDescriptorInfo, (.)pDescriptor.Length, pDescriptor.Ptr); + [Inline] public static void BindDescriptorBuffersEXT(this VkCommandBuffer commandBuffer, Span pBindingInfos) => VulkanLoadedFunctions.current.vkCmdBindDescriptorBuffersEXT(commandBuffer, (.)pBindingInfos.Length, pBindingInfos.Ptr); [Inline] public static void SetDescriptorBufferOffsetsEXT(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 firstSet, uint32 setCount, uint32* pBufferIndices, VkDeviceSize* pOffsets) => VulkanLoadedFunctions.current.vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); [Inline] public static void BindDescriptorBufferEmbeddedSamplersEXT(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set) => VulkanLoadedFunctions.current.vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); [Inline] public static VkResult GetBufferOpaqueCaptureDescriptorDataEXT(this VkDevice device, VkBufferCaptureDescriptorDataInfoEXT* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, out pData); @@ -3016,8 +3016,8 @@ static [Inline] public static void GetDescriptorSetLayoutHostMappingInfoVALVE(this VkDevice device, VkDescriptorSetBindingReferenceVALVE* pBindingReference, out VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping) => VulkanLoadedFunctions.current.vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, out pHostMapping); [Inline] public static void GetDescriptorSetHostMappingVALVE(this VkDevice device, VkDescriptorSet descriptorSet, out void* ppData) => VulkanLoadedFunctions.current.vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, out ppData); [Inline] public static VkResult CreateMicromapEXT(this VkDevice device, VkMicromapCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkMicromapEXT pMicromap) => VulkanLoadedFunctions.current.vkCreateMicromapEXT(device, pCreateInfo, pAllocator, out pMicromap); - [Inline] public static void BuildMicromapsEXT(this VkCommandBuffer commandBuffer, uint32 infoCount, VkMicromapBuildInfoEXT* pInfos) => VulkanLoadedFunctions.current.vkCmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); - [Inline] public static VkResult BuildMicromapsEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, uint32 infoCount, VkMicromapBuildInfoEXT* pInfos) => VulkanLoadedFunctions.current.vkBuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); + [Inline] public static void BuildMicromapsEXT(this VkCommandBuffer commandBuffer, Span pInfos) => VulkanLoadedFunctions.current.vkCmdBuildMicromapsEXT(commandBuffer, (.)pInfos.Length, pInfos.Ptr); + [Inline] public static VkResult BuildMicromapsEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, Span pInfos) => VulkanLoadedFunctions.current.vkBuildMicromapsEXT(device, deferredOperation, (.)pInfos.Length, pInfos.Ptr); [Inline] public static void DestroyEXT(this VkMicromapEXT micromap, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyMicromapEXT(device, micromap, pAllocator); [Inline] public static void CopyMicromapEXT(this VkCommandBuffer commandBuffer, VkCopyMicromapInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyMicromapEXT(commandBuffer, pInfo); [Inline] public static VkResult CopyMicromapEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyMicromapInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCopyMicromapEXT(device, deferredOperation, pInfo); @@ -3025,8 +3025,8 @@ static [Inline] public static VkResult CopyMicromapToMemoryEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyMicromapToMemoryInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCopyMicromapToMemoryEXT(device, deferredOperation, pInfo); [Inline] public static void CopyMemoryToMicromapEXT(this VkCommandBuffer commandBuffer, VkCopyMemoryToMicromapInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); [Inline] public static VkResult CopyMemoryToMicromapEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkCopyMemoryToMicromapInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCopyMemoryToMicromapEXT(device, deferredOperation, pInfo); - [Inline] public static void WriteMicromapsPropertiesEXT(this VkCommandBuffer commandBuffer, uint32 micromapCount, VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); - [Inline] public static VkResult WriteMicromapsPropertiesEXT(this VkDevice device, uint32 micromapCount, VkMicromapEXT* pMicromaps, VkQueryType queryType, c_size dataSize, out void pData, c_size stride) => VulkanLoadedFunctions.current.vkWriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, out pData, stride); + [Inline] public static void WriteMicromapsPropertiesEXT(this VkCommandBuffer commandBuffer, Span pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery) => VulkanLoadedFunctions.current.vkCmdWriteMicromapsPropertiesEXT(commandBuffer, (.)pMicromaps.Length, pMicromaps.Ptr, queryType, queryPool, firstQuery); + [Inline] public static VkResult WriteMicromapsPropertiesEXT(this VkDevice device, Span pMicromaps, VkQueryType queryType, Span pData, c_size stride) => VulkanLoadedFunctions.current.vkWriteMicromapsPropertiesEXT(device, (.)pMicromaps.Length, pMicromaps.Ptr, queryType, (.)pData.Length, pData.Ptr, stride); [Inline] public static void GetMicromapCompatibilityEXT(this VkDevice device, VkMicromapVersionInfoEXT* pVersionInfo, out VkAccelerationStructureCompatibilityKHR pCompatibility) => VulkanLoadedFunctions.current.vkGetDeviceMicromapCompatibilityEXT(device, pVersionInfo, out pCompatibility); [Inline] public static void GetMicromapBuildSizesEXT(this VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, VkMicromapBuildInfoEXT* pBuildInfo, out VkMicromapBuildSizesInfoEXT pSizeInfo) => VulkanLoadedFunctions.current.vkGetMicromapBuildSizesEXT(device, buildType, pBuildInfo, out pSizeInfo); [Inline] public static void GetIdentifierEXT(this VkShaderModule shaderModule, VkDevice device, out VkShaderModuleIdentifierEXT pIdentifier) => VulkanLoadedFunctions.current.vkGetShaderModuleIdentifierEXT(device, shaderModule, out pIdentifier); @@ -3096,7 +3096,7 @@ static [Inline] public static VkResult GetMemoryMetalHandlePropertiesEXT(this VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, void* pHandle, out VkMemoryMetalHandlePropertiesEXT pMemoryMetalHandleProperties) => VulkanLoadedFunctions.current.vkGetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, out pMemoryMetalHandleProperties); [Inline] public static VkResult GetCooperativeVectorPropertiesNV(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, out pPropertyCount, pProperties); [Inline] public static VkResult ConvertCooperativeVectorMatrixNV(this VkDevice device, VkConvertCooperativeVectorMatrixInfoNV* pInfo) => VulkanLoadedFunctions.current.vkConvertCooperativeVectorMatrixNV(device, pInfo); - [Inline] public static void ConvertCooperativeVectorMatrixNV(this VkCommandBuffer commandBuffer, uint32 infoCount, VkConvertCooperativeVectorMatrixInfoNV* pInfos) => VulkanLoadedFunctions.current.vkCmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos); + [Inline] public static void ConvertCooperativeVectorMatrixNV(this VkCommandBuffer commandBuffer, Span pInfos) => VulkanLoadedFunctions.current.vkCmdConvertCooperativeVectorMatrixNV(commandBuffer, (.)pInfos.Length, pInfos.Ptr); [Inline] public static void DispatchTileQCOM(this VkCommandBuffer commandBuffer, VkDispatchTileInfoQCOM* pDispatchTileInfo) => VulkanLoadedFunctions.current.vkCmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo); [Inline] public static void BeginPerTileExecutionQCOM(this VkCommandBuffer commandBuffer, VkPerTileBeginInfoQCOM* pPerTileBeginInfo) => VulkanLoadedFunctions.current.vkCmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo); [Inline] public static void EndPerTileExecutionQCOM(this VkCommandBuffer commandBuffer, VkPerTileEndInfoQCOM* pPerTileEndInfo) => VulkanLoadedFunctions.current.vkCmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo); @@ -3108,7 +3108,7 @@ static [Inline] public static VkResult CreateTensorViewARM(this VkDevice device, VkTensorViewCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkTensorViewARM pView) => VulkanLoadedFunctions.current.vkCreateTensorViewARM(device, pCreateInfo, pAllocator, out pView); [Inline] public static void DestroyARM(this VkTensorViewARM tensorView, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyTensorViewARM(device, tensorView, pAllocator); [Inline] public static void GetTensorMemoryRequirementsARM(this VkDevice device, VkTensorMemoryRequirementsInfoARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetTensorMemoryRequirementsARM(device, pInfo, out pMemoryRequirements); - [Inline] public static VkResult BindTensorMemoryARM(this VkDevice device, uint32 bindInfoCount, VkBindTensorMemoryInfoARM* pBindInfos) => VulkanLoadedFunctions.current.vkBindTensorMemoryARM(device, bindInfoCount, pBindInfos); + [Inline] public static VkResult BindTensorMemoryARM(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindTensorMemoryARM(device, (.)pBindInfos.Length, pBindInfos.Ptr); [Inline] public static void GetTensorMemoryRequirementsARM(this VkDevice device, VkDeviceTensorMemoryRequirementsARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDeviceTensorMemoryRequirementsARM(device, pInfo, out pMemoryRequirements); [Inline] public static void CopyTensorARM(this VkCommandBuffer commandBuffer, VkCopyTensorInfoARM* pCopyTensorInfo) => VulkanLoadedFunctions.current.vkCmdCopyTensorARM(commandBuffer, pCopyTensorInfo); [Inline] public static VkResult GetTensorOpaqueCaptureDescriptorDataARM(this VkDevice device, VkTensorCaptureDescriptorDataInfoARM* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, out pData); @@ -3118,18 +3118,18 @@ static [Inline] public static VkResult CreateDataGraphPipelineSessionARM(this VkDevice device, VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDataGraphPipelineSessionARM pSession) => VulkanLoadedFunctions.current.vkCreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, out pSession); [Inline] public static VkResult GetDataGraphPipelineSessionBindPointRequirementsARM(this VkDevice device, VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, out uint32 pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements = null) => VulkanLoadedFunctions.current.vkGetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, out pBindPointRequirementCount, pBindPointRequirements); [Inline] public static void GetDataGraphPipelineSessionMemoryRequirementsARM(this VkDevice device, VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, out pMemoryRequirements); - [Inline] public static VkResult BindDataGraphPipelineSessionMemoryARM(this VkDevice device, uint32 bindInfoCount, VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) => VulkanLoadedFunctions.current.vkBindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos); + [Inline] public static VkResult BindDataGraphPipelineSessionMemoryARM(this VkDevice device, Span pBindInfos) => VulkanLoadedFunctions.current.vkBindDataGraphPipelineSessionMemoryARM(device, (.)pBindInfos.Length, pBindInfos.Ptr); [Inline] public static void DestroyARM(this VkDataGraphPipelineSessionARM session, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDataGraphPipelineSessionARM(device, session, pAllocator); [Inline] public static void DispatchDataGraphARM(this VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, VkDataGraphPipelineDispatchInfoARM* pInfo = null) => VulkanLoadedFunctions.current.vkCmdDispatchDataGraphARM(commandBuffer, session, pInfo); [Inline] public static VkResult GetDataGraphPipelineAvailablePropertiesARM(this VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, out uint32 pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties = null) => VulkanLoadedFunctions.current.vkGetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, out pPropertiesCount, pProperties); - [Inline] public static VkResult GetDataGraphPipelinePropertiesARM(this VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, uint32 propertiesCount, out VkDataGraphPipelinePropertyQueryResultARM pProperties) => VulkanLoadedFunctions.current.vkGetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, out pProperties); + [Inline] public static VkResult GetDataGraphPipelinePropertiesARM(this VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, Span pProperties) => VulkanLoadedFunctions.current.vkGetDataGraphPipelinePropertiesARM(device, pPipelineInfo, (.)pProperties.Length, pProperties.Ptr); [Inline] public static VkResult GetQueueFamilyDataGraphPropertiesARM(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, out pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); [Inline] public static void GetQueueFamilyDataGraphProcessingEnginePropertiesARM(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, out VkQueueFamilyDataGraphProcessingEnginePropertiesARM pQueueFamilyDataGraphProcessingEngineProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, out pQueueFamilyDataGraphProcessingEngineProperties); [Inline] public static VkResult GetNativeBufferPropertiesOHOS(this VkDevice device, out OH_NativeBuffer buffer, out VkNativeBufferPropertiesOHOS pProperties) => VulkanLoadedFunctions.current.vkGetNativeBufferPropertiesOHOS(device, out buffer, out pProperties); [Inline] public static VkResult GetMemoryNativeBufferOHOS(this VkDevice device, VkMemoryGetNativeBufferInfoOHOS* pInfo, out OH_NativeBuffer* pBuffer) => VulkanLoadedFunctions.current.vkGetMemoryNativeBufferOHOS(device, pInfo, out pBuffer); [Inline] public static VkResult GetSwapchainGrallocUsageOHOS(this VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, out uint64 grallocUsage) => VulkanLoadedFunctions.current.vkGetSwapchainGrallocUsageOHOS(device, format, imageUsage, out grallocUsage); [Inline] public static VkResult AcquireOHOS(this VkImage image, VkDevice device, int32 nativeFenceFd, VkSemaphore semaphore = null, VkFence fence = null) => VulkanLoadedFunctions.current.vkAcquireImageOHOS(device, image, nativeFenceFd, semaphore, fence); - [Inline] public static VkResult SignalReleaseImageOHOS(this VkQueue queue, uint32 waitSemaphoreCount, VkSemaphore* pWaitSemaphores, VkImage image, out int32 pNativeFenceFd) => VulkanLoadedFunctions.current.vkQueueSignalReleaseImageOHOS(queue, waitSemaphoreCount, pWaitSemaphores, image, out pNativeFenceFd); + [Inline] public static VkResult SignalReleaseImageOHOS(this VkQueue queue, Span pWaitSemaphores, VkImage image, out int32 pNativeFenceFd) => VulkanLoadedFunctions.current.vkQueueSignalReleaseImageOHOS(queue, (.)pWaitSemaphores.Length, pWaitSemaphores.Ptr, image, out pNativeFenceFd); [Inline] public static VkResult EnumerateQueueFamilyPerformanceCountersByRegionARM(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pCounterCount, VkPerformanceCounterARM* pCounters = null, VkPerformanceCounterDescriptionARM* pCounterDescriptions = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, out pCounterCount, pCounters, pCounterDescriptions); } diff --git a/src/Metadata.bf b/src/Metadata.bf index 9a10436..fd46c2a 100644 --- a/src/Metadata.bf +++ b/src/Metadata.bf @@ -14,6 +14,22 @@ enum VulkanApiVersion case VK_VERSION_1_2 = VK_API_VERSION_1_2; case VK_VERSION_1_3 = VK_API_VERSION_1_3; case VK_VERSION_1_4 = VK_API_VERSION_1_4; + + public VkStructureType FeatureStruct + { + get + { + switch (this) + { + case VK_VERSION_1_0: return VkPhysicalDeviceFeatures2.SType; + case VK_VERSION_1_1: return VkPhysicalDeviceVulkan11Features.SType; + case VK_VERSION_1_2: return VkPhysicalDeviceVulkan12Features.SType; + case VK_VERSION_1_3: return VkPhysicalDeviceVulkan13Features.SType; + case VK_VERSION_1_4: return VkPhysicalDeviceVulkan14Features.SType; + default: return default; + } + } + } } enum VulkanExtension @@ -2699,6 +2715,1147 @@ enum VulkanExtension } } +enum VulkanFeature +{ + case robustBufferAccess; + case fullDrawIndexUint32; + case imageCubeArray; + case independentBlend; + case geometryShader; + case tessellationShader; + case sampleRateShading; + case dualSrcBlend; + case logicOp; + case multiDrawIndirect; + case drawIndirectFirstInstance; + case depthClamp; + case depthBiasClamp; + case fillModeNonSolid; + case depthBounds; + case wideLines; + case largePoints; + case alphaToOne; + case multiViewport; + case samplerAnisotropy; + case textureCompressionETC2; + case textureCompressionASTC_LDR; + case textureCompressionBC; + case occlusionQueryPrecise; + case pipelineStatisticsQuery; + case vertexPipelineStoresAndAtomics; + case fragmentStoresAndAtomics; + case shaderTessellationAndGeometryPointSize; + case shaderImageGatherExtended; + case shaderStorageImageExtendedFormats; + case shaderStorageImageMultisample; + case shaderStorageImageReadWithoutFormat; + case shaderStorageImageWriteWithoutFormat; + case shaderUniformBufferArrayDynamicIndexing; + case shaderSampledImageArrayDynamicIndexing; + case shaderStorageBufferArrayDynamicIndexing; + case shaderStorageImageArrayDynamicIndexing; + case shaderClipDistance; + case shaderCullDistance; + case shaderFloat64; + case shaderInt64; + case shaderInt16; + case shaderResourceResidency; + case shaderResourceMinLod; + case sparseBinding; + case sparseResidencyBuffer; + case sparseResidencyImage2D; + case sparseResidencyImage3D; + case sparseResidency2Samples; + case sparseResidency4Samples; + case sparseResidency8Samples; + case sparseResidency16Samples; + case sparseResidencyAliased; + case variableMultisampleRate; + case inheritedQueries; + case deviceGeneratedCommands; + case deviceGeneratedCompute; + case deviceGeneratedComputePipelines; + case deviceGeneratedComputeCaptureReplay; + case privateData; + case clusterAccelerationStructure; + case variablePointersStorageBuffer; + case variablePointers; + case multiview; + case multiviewGeometryShader; + case multiviewTessellationShader; + case presentId; + case presentId2; + case presentWait; + case presentWait2; + case presentTiming; + case presentAtAbsoluteTime; + case presentAtRelativeTime; + case storageBuffer16BitAccess; + case uniformAndStorageBuffer16BitAccess; + case storagePushConstant16; + case storageInputOutput16; + case shaderSubgroupExtendedTypes; + case samplerYcbcrConversion; + case protectedMemory; + case advancedBlendCoherentOperations; + case multiDraw; + case inlineUniformBlock; + case descriptorBindingInlineUniformBlockUpdateAfterBind; + case maintenance4; + case maintenance5; + case maintenance6; + case maintenance7; + case maintenance8; + case maintenance9; + case maintenance10; + case shaderDrawParameters; + case shaderFloat16; + case shaderInt8; + case hostQueryReset; + case globalPriorityQuery; + case deviceMemoryReport; + case shaderInputAttachmentArrayDynamicIndexing; + case shaderUniformTexelBufferArrayDynamicIndexing; + case shaderStorageTexelBufferArrayDynamicIndexing; + case shaderUniformBufferArrayNonUniformIndexing; + case shaderSampledImageArrayNonUniformIndexing; + case shaderStorageBufferArrayNonUniformIndexing; + case shaderStorageImageArrayNonUniformIndexing; + case shaderInputAttachmentArrayNonUniformIndexing; + case shaderUniformTexelBufferArrayNonUniformIndexing; + case shaderStorageTexelBufferArrayNonUniformIndexing; + case descriptorBindingUniformBufferUpdateAfterBind; + case descriptorBindingSampledImageUpdateAfterBind; + case descriptorBindingStorageImageUpdateAfterBind; + case descriptorBindingStorageBufferUpdateAfterBind; + case descriptorBindingUniformTexelBufferUpdateAfterBind; + case descriptorBindingStorageTexelBufferUpdateAfterBind; + case descriptorBindingUpdateUnusedWhilePending; + case descriptorBindingPartiallyBound; + case descriptorBindingVariableDescriptorCount; + case runtimeDescriptorArray; + case timelineSemaphore; + case storageBuffer8BitAccess; + case uniformAndStorageBuffer8BitAccess; + case storagePushConstant8; + case conditionalRendering; + case inheritedConditionalRendering; + case vulkanMemoryModel; + case vulkanMemoryModelDeviceScope; + case vulkanMemoryModelAvailabilityVisibilityChains; + case shaderBufferInt64Atomics; + case shaderSharedInt64Atomics; + case shaderBufferFloat32Atomics; + case shaderBufferFloat32AtomicAdd; + case shaderBufferFloat64Atomics; + case shaderBufferFloat64AtomicAdd; + case shaderSharedFloat32Atomics; + case shaderSharedFloat32AtomicAdd; + case shaderSharedFloat64Atomics; + case shaderSharedFloat64AtomicAdd; + case shaderImageFloat32Atomics; + case shaderImageFloat32AtomicAdd; + case sparseImageFloat32Atomics; + case sparseImageFloat32AtomicAdd; + case shaderBufferFloat16Atomics; + case shaderBufferFloat16AtomicAdd; + case shaderBufferFloat16AtomicMinMax; + case shaderBufferFloat32AtomicMinMax; + case shaderBufferFloat64AtomicMinMax; + case shaderSharedFloat16Atomics; + case shaderSharedFloat16AtomicAdd; + case shaderSharedFloat16AtomicMinMax; + case shaderSharedFloat32AtomicMinMax; + case shaderSharedFloat64AtomicMinMax; + case shaderImageFloat32AtomicMinMax; + case sparseImageFloat32AtomicMinMax; + case vertexAttributeInstanceRateDivisor; + case vertexAttributeInstanceRateZeroDivisor; + case decodeModeSharedExponent; + case transformFeedback; + case geometryStreams; + case representativeFragmentTest; + case exclusiveScissor; + case cornerSampledImage; + case computeDerivativeGroupQuads; + case computeDerivativeGroupLinear; + case imageFootprint; + case dedicatedAllocationImageAliasing; + case indirectMemoryCopy; + case indirectMemoryToImageCopy; + case indirectCopy; + case memoryDecompression; + case shadingRateImage; + case shadingRateCoarseSampleOrder; + case invocationMask; + case taskShader; + case meshShader; + case multiviewMeshShader; + case primitiveFragmentShadingRateMeshShader; + case meshShaderQueries; + case accelerationStructure; + case accelerationStructureCaptureReplay; + case accelerationStructureIndirectBuild; + case accelerationStructureHostCommands; + case descriptorBindingAccelerationStructureUpdateAfterBind; + case rayTracingPipeline; + case rayTracingPipelineShaderGroupHandleCaptureReplay; + case rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + case rayTracingPipelineTraceRaysIndirect; + case rayTraversalPrimitiveCulling; + case rayQuery; + case rayTracingMaintenance1; + case rayTracingPipelineTraceRaysIndirect2; + case fragmentDensityMap; + case fragmentDensityMapDynamic; + case fragmentDensityMapNonSubsampledImages; + case fragmentDensityMapDeferred; + case fragmentDensityMapOffset; + case scalarBlockLayout; + case uniformBufferStandardLayout; + case depthClipEnable; + case memoryPriority; + case pageableDeviceLocalMemory; + case bufferDeviceAddress; + case bufferDeviceAddressCaptureReplay; + case bufferDeviceAddressMultiDevice; + case imagelessFramebuffer; + case textureCompressionASTC_HDR; + case cooperativeMatrix; + case cooperativeMatrixRobustBufferAccess; + case ycbcrImageArrays; + case presentBarrier; + case performanceCounterQueryPools; + case performanceCounterMultipleQueryPools; + case coverageReductionMode; + case shaderIntegerFunctions2; + case shaderSubgroupClock; + case shaderDeviceClock; + case indexTypeUint8; + case shaderSMBuiltins; + case fragmentShaderSampleInterlock; + case fragmentShaderPixelInterlock; + case fragmentShaderShadingRateInterlock; + case separateDepthStencilLayouts; + case primitiveTopologyListRestart; + case primitiveTopologyPatchListRestart; + case pipelineExecutableInfo; + case shaderDemoteToHelperInvocation; + case texelBufferAlignment; + case subgroupSizeControl; + case computeFullSubgroups; + case rectangularLines; + case bresenhamLines; + case smoothLines; + case stippledRectangularLines; + case stippledBresenhamLines; + case stippledSmoothLines; + case pipelineCreationCacheControl; + case samplerMirrorClampToEdge; + case drawIndirectCount; + case descriptorIndexing; + case samplerFilterMinmax; + case shaderOutputViewportIndex; + case shaderOutputLayer; + case subgroupBroadcastDynamicId; + case robustImageAccess; + case shaderTerminateInvocation; + case synchronization2; + case shaderZeroInitializeWorkgroupMemory; + case dynamicRendering; + case shaderIntegerDotProduct; + case shaderSubgroupRotate; + case shaderSubgroupRotateClustered; + case shaderFloatControls2; + case shaderExpectAssume; + case dynamicRenderingLocalRead; + case pipelineProtectedAccess; + case pipelineRobustness; + case hostImageCopy; + case pushDescriptor; + case deviceCoherentMemory; + case customBorderColors; + case customBorderColorWithoutFormat; + case borderColorSwizzle; + case borderColorSwizzleFromImage; + case extendedDynamicState; + case extendedDynamicState2; + case extendedDynamicState2LogicOp; + case extendedDynamicState2PatchControlPoints; + case extendedDynamicState3TessellationDomainOrigin; + case extendedDynamicState3DepthClampEnable; + case extendedDynamicState3PolygonMode; + case extendedDynamicState3RasterizationSamples; + case extendedDynamicState3SampleMask; + case extendedDynamicState3AlphaToCoverageEnable; + case extendedDynamicState3AlphaToOneEnable; + case extendedDynamicState3LogicOpEnable; + case extendedDynamicState3ColorBlendEnable; + case extendedDynamicState3ColorBlendEquation; + case extendedDynamicState3ColorWriteMask; + case extendedDynamicState3RasterizationStream; + case extendedDynamicState3ConservativeRasterizationMode; + case extendedDynamicState3ExtraPrimitiveOverestimationSize; + case extendedDynamicState3DepthClipEnable; + case extendedDynamicState3SampleLocationsEnable; + case extendedDynamicState3ColorBlendAdvanced; + case extendedDynamicState3ProvokingVertexMode; + case extendedDynamicState3LineRasterizationMode; + case extendedDynamicState3LineStippleEnable; + case extendedDynamicState3DepthClipNegativeOneToOne; + case extendedDynamicState3ViewportWScalingEnable; + case extendedDynamicState3ViewportSwizzle; + case extendedDynamicState3CoverageToColorEnable; + case extendedDynamicState3CoverageToColorLocation; + case extendedDynamicState3CoverageModulationMode; + case extendedDynamicState3CoverageModulationTableEnable; + case extendedDynamicState3CoverageModulationTable; + case extendedDynamicState3CoverageReductionMode; + case extendedDynamicState3RepresentativeFragmentTestEnable; + case extendedDynamicState3ShadingRateImageEnable; + case partitionedAccelerationStructure; + case diagnosticsConfig; + case shaderSubgroupUniformControlFlow; + case robustBufferAccess2; + case robustImageAccess2; + case nullDescriptor; + case workgroupMemoryExplicitLayout; + case workgroupMemoryExplicitLayoutScalarBlockLayout; + case workgroupMemoryExplicitLayout8BitAccess; + case workgroupMemoryExplicitLayout16BitAccess; + case constantAlphaColorBlendFactors; + case events; + case imageViewFormatReinterpretation; + case imageViewFormatSwizzle; + case imageView2DOn3DImage; + case multisampleArrayImage; + case mutableComparisonSamplers; + case pointPolygons; + case samplerMipLodBias; + case separateStencilMaskRef; + case shaderSampleRateInterpolationFunctions; + case tessellationIsolines; + case tessellationPointMode; + case triangleFans; + case vertexAttributeAccessBeyondStride; + case formatA4R4G4B4; + case formatA4B4G4R4; + case subpassShading; + case clustercullingShader; + case multiviewClusterCullingShader; + case clusterShadingRate; + case shaderImageInt64Atomics; + case sparseImageInt64Atomics; + case pipelineFragmentShadingRate; + case primitiveFragmentShadingRate; + case attachmentFragmentShadingRate; + case fragmentShadingRateEnums; + case supersampleFragmentShadingRates; + case noInvocationFragmentShadingRates; + case image2DViewOf3D; + case sampler2DViewOf3D; + case imageSlicedViewOf3D; + case attachmentFeedbackLoopDynamicState; + case legacyVertexAttributes; + case mutableDescriptorType; + case depthClipControl; + case zeroInitializeDeviceMemory; + case customResolve; + case dynamicGeneratedPipelineLayout; + case depthClampControl; + case vertexInputDynamicState; + case externalMemoryRDMA; + case shaderRelaxedExtendedInstruction; + case colorWriteEnable; + case unifiedImageLayouts; + case unifiedImageLayoutsVideo; + case primitivesGeneratedQuery; + case primitivesGeneratedQueryWithRasterizerDiscard; + case primitivesGeneratedQueryWithNonZeroStreams; + case legacyDithering; + case multisampledRenderToSingleSampled; + case videoMaintenance1; + case videoMaintenance2; + case videoDecodeVP9; + case videoEncodeQuantizationMap; + case videoEncodeAV1; + case inheritedViewportScissor2D; + case ycbcr2plane444Formats; + case provokingVertexLast; + case transformFeedbackPreservesProvokingVertex; + case videoEncodeIntraRefresh; + case descriptorBuffer; + case descriptorBufferCaptureReplay; + case descriptorBufferImageLayoutIgnored; + case descriptorBufferPushDescriptors; + case fragmentShaderBarycentric; + case shaderFmaFloat16; + case shaderFmaFloat32; + case shaderFmaFloat64; + case rayTracingMotionBlur; + case rayTracingMotionBlurPipelineTraceRaysIndirect; + case rayTracingValidation; + case spheres; + case linearSweptSpheres; + case formatRgba10x6WithoutYCbCrSampler; + case minLod; + case rasterizationOrderColorAttachmentAccess; + case rasterizationOrderDepthAttachmentAccess; + case rasterizationOrderStencilAttachmentAccess; + case linearColorAttachment; + case graphicsPipelineLibrary; + case pipelineBinaries; + case descriptorSetHostMapping; + case nestedCommandBuffer; + case nestedCommandBufferRendering; + case nestedCommandBufferSimultaneousUse; + case shaderModuleIdentifier; + case imageCompressionControl; + case imageCompressionControlSwapchain; + case subpassMergeFeedback; + case micromap; + case micromapCaptureReplay; + case micromapHostCommands; + case displacementMicromap; + case pipelinePropertiesIdentifier; + case shaderEarlyAndLateFragmentTests; + case nonSeamlessCubeMap; + case textureSampleWeighted; + case textureBoxFilter; + case textureBlockMatch; + case tileProperties; + case amigoProfiling; + case attachmentFeedbackLoopLayout; + case reportAddressBinding; + case opticalFlow; + case deviceFault; + case deviceFaultVendorBinary; + case pipelineLibraryGroupHandles; + case shaderCoreBuiltins; + case frameBoundary; + case dynamicRenderingUnusedAttachments; + case swapchainMaintenance1; + case depthBiasControl; + case leastRepresentableValueForceUnormRepresentation; + case floatRepresentation; + case depthBiasExact; + case rayTracingInvocationReorder; + case extendedSparseAddressSpace; + case multiviewPerViewViewports; + case rayTracingPositionFetch; + case multiviewPerViewRenderAreas; + case shaderObject; + case shaderTileImageColorReadAccess; + case shaderTileImageDepthReadAccess; + case shaderTileImageStencilReadAccess; + case screenBufferImport; + case shaderEnqueue; + case shaderMeshEnqueue; + case antiLag; + case tileMemoryHeap; + case cubicRangeClamp; + case ycbcrDegamma; + case selectableCubicWeights; + case textureBlockMatch2; + case descriptorPoolOverallocation; + case perStageDescriptorSet; + case dynamicPipelineLayout; + case externalFormatResolve; + case cudaKernelLaunchFeatures; + case schedulingControls; + case relaxedLineRasterization; + case renderPassStriped; + case pipelineOpacityMicromap; + case shaderMaximalReconvergence; + case shaderQuadControl; + case shaderFloat16VectorAtomics; + case memoryMapPlaced; + case memoryMapRangePlaced; + case memoryUnmapReserve; + case shaderBFloat16Type; + case shaderBFloat16DotProduct; + case shaderBFloat16CooperativeMatrix; + case shaderRawAccessChains; + case commandBufferInheritance; + case imageAlignmentControl; + case shaderReplicatedComposites; + case presentModeFifoLatestReady; + case cooperativeMatrixWorkgroupScope; + case cooperativeMatrixFlexibleDimensions; + case cooperativeMatrixReductions; + case cooperativeMatrixConversions; + case cooperativeMatrixPerElementOperations; + case cooperativeMatrixTensorAddressing; + case cooperativeMatrixBlockLoads; + case hdrVivid; + case vertexAttributeRobustness; + case denseGeometryFormat; + case depthClampZeroOne; + case cooperativeVector; + case cooperativeVectorTraining; + case tileShading; + case tileShadingFragmentStage; + case tileShadingColorAttachments; + case tileShadingDepthAttachments; + case tileShadingStencilAttachments; + case tileShadingInputAttachments; + case tileShadingSampledAttachments; + case tileShadingPerTileDraw; + case tileShadingPerTileDispatch; + case tileShadingDispatchTile; + case tileShadingApron; + case tileShadingAnisotropicApron; + case tileShadingAtomicOps; + case tileShadingImageProcessing; + case fragmentDensityMapLayered; + case presentMetering; + case shaderUniformBufferUnsizedArray; + case formatPack; + case tensorNonPacked; + case shaderTensorAccess; + case shaderStorageTensorArrayDynamicIndexing; + case shaderStorageTensorArrayNonUniformIndexing; + case descriptorBindingStorageTensorUpdateAfterBind; + case tensors; + case descriptorBufferTensorDescriptors; + case shaderFloat8; + case shaderFloat8CooperativeMatrix; + case dataGraph; + case dataGraphUpdateAfterBind; + case dataGraphSpecializationConstants; + case dataGraphDescriptorBuffer; + case dataGraphShaderModule; + case pipelineCacheIncrementalMode; + case dataGraphModel; + case shaderUntypedPointers; + case videoEncodeRgbConversion; + case shader64BitIndexing; + case performanceCountersByRegion; + + public VulkanApiVersion ApiVersion + { + get + { + switch (this) + { + case robustBufferAccess: return .VK_VERSION_1_0; + case fullDrawIndexUint32: return .VK_VERSION_1_0; + case imageCubeArray: return .VK_VERSION_1_0; + case independentBlend: return .VK_VERSION_1_0; + case geometryShader: return .VK_VERSION_1_0; + case tessellationShader: return .VK_VERSION_1_0; + case sampleRateShading: return .VK_VERSION_1_0; + case dualSrcBlend: return .VK_VERSION_1_0; + case logicOp: return .VK_VERSION_1_0; + case multiDrawIndirect: return .VK_VERSION_1_0; + case drawIndirectFirstInstance: return .VK_VERSION_1_0; + case depthClamp: return .VK_VERSION_1_0; + case depthBiasClamp: return .VK_VERSION_1_0; + case fillModeNonSolid: return .VK_VERSION_1_0; + case depthBounds: return .VK_VERSION_1_0; + case wideLines: return .VK_VERSION_1_0; + case largePoints: return .VK_VERSION_1_0; + case alphaToOne: return .VK_VERSION_1_0; + case multiViewport: return .VK_VERSION_1_0; + case samplerAnisotropy: return .VK_VERSION_1_0; + case textureCompressionETC2: return .VK_VERSION_1_0; + case textureCompressionASTC_LDR: return .VK_VERSION_1_0; + case textureCompressionBC: return .VK_VERSION_1_0; + case occlusionQueryPrecise: return .VK_VERSION_1_0; + case pipelineStatisticsQuery: return .VK_VERSION_1_0; + case vertexPipelineStoresAndAtomics: return .VK_VERSION_1_0; + case fragmentStoresAndAtomics: return .VK_VERSION_1_0; + case shaderTessellationAndGeometryPointSize: return .VK_VERSION_1_0; + case shaderImageGatherExtended: return .VK_VERSION_1_0; + case shaderStorageImageExtendedFormats: return .VK_VERSION_1_0; + case shaderStorageImageMultisample: return .VK_VERSION_1_0; + case shaderStorageImageReadWithoutFormat: return .VK_VERSION_1_0; + case shaderStorageImageWriteWithoutFormat: return .VK_VERSION_1_0; + case shaderUniformBufferArrayDynamicIndexing: return .VK_VERSION_1_0; + case shaderSampledImageArrayDynamicIndexing: return .VK_VERSION_1_0; + case shaderStorageBufferArrayDynamicIndexing: return .VK_VERSION_1_0; + case shaderStorageImageArrayDynamicIndexing: return .VK_VERSION_1_0; + case shaderClipDistance: return .VK_VERSION_1_0; + case shaderCullDistance: return .VK_VERSION_1_0; + case shaderFloat64: return .VK_VERSION_1_0; + case shaderInt64: return .VK_VERSION_1_0; + case shaderInt16: return .VK_VERSION_1_0; + case shaderResourceResidency: return .VK_VERSION_1_0; + case shaderResourceMinLod: return .VK_VERSION_1_0; + case sparseBinding: return .VK_VERSION_1_0; + case sparseResidencyBuffer: return .VK_VERSION_1_0; + case sparseResidencyImage2D: return .VK_VERSION_1_0; + case sparseResidencyImage3D: return .VK_VERSION_1_0; + case sparseResidency2Samples: return .VK_VERSION_1_0; + case sparseResidency4Samples: return .VK_VERSION_1_0; + case sparseResidency8Samples: return .VK_VERSION_1_0; + case sparseResidency16Samples: return .VK_VERSION_1_0; + case sparseResidencyAliased: return .VK_VERSION_1_0; + case variableMultisampleRate: return .VK_VERSION_1_0; + case inheritedQueries: return .VK_VERSION_1_0; + case privateData: return .VK_VERSION_1_3; + case variablePointersStorageBuffer: return .VK_VERSION_1_1; + case variablePointers: return .VK_VERSION_1_1; + case multiview: return .VK_VERSION_1_1; + case multiviewGeometryShader: return .VK_VERSION_1_1; + case multiviewTessellationShader: return .VK_VERSION_1_1; + case storageBuffer16BitAccess: return .VK_VERSION_1_1; + case uniformAndStorageBuffer16BitAccess: return .VK_VERSION_1_1; + case storagePushConstant16: return .VK_VERSION_1_1; + case storageInputOutput16: return .VK_VERSION_1_1; + case shaderSubgroupExtendedTypes: return .VK_VERSION_1_2; + case samplerYcbcrConversion: return .VK_VERSION_1_1; + case protectedMemory: return .VK_VERSION_1_1; + case inlineUniformBlock: return .VK_VERSION_1_3; + case descriptorBindingInlineUniformBlockUpdateAfterBind: return .VK_VERSION_1_3; + case maintenance4: return .VK_VERSION_1_3; + case maintenance5: return .VK_VERSION_1_4; + case maintenance6: return .VK_VERSION_1_4; + case shaderDrawParameters: return .VK_VERSION_1_1; + case shaderFloat16: return .VK_VERSION_1_2; + case shaderInt8: return .VK_VERSION_1_2; + case hostQueryReset: return .VK_VERSION_1_2; + case globalPriorityQuery: return .VK_VERSION_1_4; + case shaderInputAttachmentArrayDynamicIndexing: return .VK_VERSION_1_2; + case shaderUniformTexelBufferArrayDynamicIndexing: return .VK_VERSION_1_2; + case shaderStorageTexelBufferArrayDynamicIndexing: return .VK_VERSION_1_2; + case shaderUniformBufferArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderSampledImageArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderStorageBufferArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderStorageImageArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderInputAttachmentArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderUniformTexelBufferArrayNonUniformIndexing: return .VK_VERSION_1_2; + case shaderStorageTexelBufferArrayNonUniformIndexing: return .VK_VERSION_1_2; + case descriptorBindingUniformBufferUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingSampledImageUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingStorageImageUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingStorageBufferUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingUniformTexelBufferUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingStorageTexelBufferUpdateAfterBind: return .VK_VERSION_1_2; + case descriptorBindingUpdateUnusedWhilePending: return .VK_VERSION_1_2; + case descriptorBindingPartiallyBound: return .VK_VERSION_1_2; + case descriptorBindingVariableDescriptorCount: return .VK_VERSION_1_2; + case runtimeDescriptorArray: return .VK_VERSION_1_2; + case timelineSemaphore: return .VK_VERSION_1_2; + case storageBuffer8BitAccess: return .VK_VERSION_1_2; + case uniformAndStorageBuffer8BitAccess: return .VK_VERSION_1_2; + case storagePushConstant8: return .VK_VERSION_1_2; + case vulkanMemoryModel: return .VK_VERSION_1_2; + case vulkanMemoryModelDeviceScope: return .VK_VERSION_1_2; + case vulkanMemoryModelAvailabilityVisibilityChains: return .VK_VERSION_1_2; + case shaderBufferInt64Atomics: return .VK_VERSION_1_2; + case shaderSharedInt64Atomics: return .VK_VERSION_1_2; + case vertexAttributeInstanceRateDivisor: return .VK_VERSION_1_4; + case vertexAttributeInstanceRateZeroDivisor: return .VK_VERSION_1_4; + case scalarBlockLayout: return .VK_VERSION_1_2; + case uniformBufferStandardLayout: return .VK_VERSION_1_2; + case bufferDeviceAddress: return .VK_VERSION_1_2; + case bufferDeviceAddressCaptureReplay: return .VK_VERSION_1_2; + case bufferDeviceAddressMultiDevice: return .VK_VERSION_1_2; + case imagelessFramebuffer: return .VK_VERSION_1_2; + case textureCompressionASTC_HDR: return .VK_VERSION_1_3; + case indexTypeUint8: return .VK_VERSION_1_4; + case separateDepthStencilLayouts: return .VK_VERSION_1_2; + case shaderDemoteToHelperInvocation: return .VK_VERSION_1_3; + case subgroupSizeControl: return .VK_VERSION_1_3; + case computeFullSubgroups: return .VK_VERSION_1_3; + case rectangularLines: return .VK_VERSION_1_4; + case bresenhamLines: return .VK_VERSION_1_4; + case smoothLines: return .VK_VERSION_1_4; + case stippledRectangularLines: return .VK_VERSION_1_4; + case stippledBresenhamLines: return .VK_VERSION_1_4; + case stippledSmoothLines: return .VK_VERSION_1_4; + case pipelineCreationCacheControl: return .VK_VERSION_1_3; + case samplerMirrorClampToEdge: return .VK_VERSION_1_2; + case drawIndirectCount: return .VK_VERSION_1_2; + case descriptorIndexing: return .VK_VERSION_1_2; + case samplerFilterMinmax: return .VK_VERSION_1_2; + case shaderOutputViewportIndex: return .VK_VERSION_1_2; + case shaderOutputLayer: return .VK_VERSION_1_2; + case subgroupBroadcastDynamicId: return .VK_VERSION_1_2; + case robustImageAccess: return .VK_VERSION_1_3; + case shaderTerminateInvocation: return .VK_VERSION_1_3; + case synchronization2: return .VK_VERSION_1_3; + case shaderZeroInitializeWorkgroupMemory: return .VK_VERSION_1_3; + case dynamicRendering: return .VK_VERSION_1_3; + case shaderIntegerDotProduct: return .VK_VERSION_1_3; + case shaderSubgroupRotate: return .VK_VERSION_1_4; + case shaderSubgroupRotateClustered: return .VK_VERSION_1_4; + case shaderFloatControls2: return .VK_VERSION_1_4; + case shaderExpectAssume: return .VK_VERSION_1_4; + case dynamicRenderingLocalRead: return .VK_VERSION_1_4; + case pipelineProtectedAccess: return .VK_VERSION_1_4; + case pipelineRobustness: return .VK_VERSION_1_4; + case hostImageCopy: return .VK_VERSION_1_4; + case pushDescriptor: return .VK_VERSION_1_4; + default: return default; + } + } + } + + public VkStructureType ExtensionStruct + { + 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; + default: return default; + } + } + } +} + namespace Vulkan; extension VkStructureType diff --git a/src/Vulkan.bf b/src/Vulkan.bf index 20c1d9f..b81d380 100644 --- a/src/Vulkan.bf +++ b/src/Vulkan.bf @@ -4273,18 +4273,26 @@ typealias VkInstanceCreateFlags = VkInstanceCreateFlagBits; public VkApplicationInfo* pApplicationInfo = null; public uint32 enabledLayerCount = 0; public char8** ppEnabledLayerNames = null; // Ordered list of layer names to be enabled + public Span enabledLayerNames + { + get { return .(ppEnabledLayerNames, (.)enabledLayerCount); } + set mut { ppEnabledLayerNames = value.Ptr; enabledLayerCount = (.)value.Length; } + } public uint32 enabledExtensionCount = 0; public char8** ppEnabledExtensionNames = null; // Extension names to be enabled + public Span enabledExtensionNames + { + get { return .(ppEnabledExtensionNames, (.)enabledExtensionCount); } + set mut { ppEnabledExtensionNames = value.Ptr; enabledExtensionCount = (.)value.Length; } + } - public this(void* pNext, VkInstanceCreateFlags flags, VkApplicationInfo* pApplicationInfo, uint32 enabledLayerCount, char8** ppEnabledLayerNames, uint32 enabledExtensionCount, char8** ppEnabledExtensionNames) : this() + public this(void* pNext = null, VkInstanceCreateFlags flags = default, VkApplicationInfo* pApplicationInfo = null, Span enabledLayerNames = default, Span enabledExtensionNames = default) : this() { this.pNext = pNext; this.flags = flags; this.pApplicationInfo = pApplicationInfo; - this.enabledLayerCount = enabledLayerCount; - this.ppEnabledLayerNames = ppEnabledLayerNames; - this.enabledExtensionCount = enabledExtensionCount; - this.ppEnabledExtensionNames = ppEnabledExtensionNames; + this.enabledLayerNames = enabledLayerNames; + this.enabledExtensionNames = enabledExtensionNames; } } @@ -4749,19 +4757,27 @@ typealias VkDeviceCreateFlags = VkFlags; } public uint32 enabledLayerCount = 0; public char8** ppEnabledLayerNames = null; // Ordered list of layer names to be enabled + public Span enabledLayerNames + { + get { return .(ppEnabledLayerNames, (.)enabledLayerCount); } + set mut { ppEnabledLayerNames = value.Ptr; enabledLayerCount = (.)value.Length; } + } public uint32 enabledExtensionCount = 0; public char8** ppEnabledExtensionNames = null; + public Span enabledExtensionNames + { + get { return .(ppEnabledExtensionNames, (.)enabledExtensionCount); } + set mut { ppEnabledExtensionNames = value.Ptr; enabledExtensionCount = (.)value.Length; } + } public VkPhysicalDeviceFeatures* pEnabledFeatures = null; - public this(void* pNext, VkDeviceCreateFlags flags, Span queueCreateInfos, uint32 enabledLayerCount, char8** ppEnabledLayerNames, uint32 enabledExtensionCount, char8** ppEnabledExtensionNames, VkPhysicalDeviceFeatures* pEnabledFeatures = null) : this() + public this(void* pNext = null, VkDeviceCreateFlags flags = default, Span queueCreateInfos = default, Span enabledLayerNames = default, Span enabledExtensionNames = default, VkPhysicalDeviceFeatures* pEnabledFeatures = null) : this() { this.pNext = pNext; this.flags = flags; this.queueCreateInfos = queueCreateInfos; - this.enabledLayerCount = enabledLayerCount; - this.ppEnabledLayerNames = ppEnabledLayerNames; - this.enabledExtensionCount = enabledExtensionCount; - this.ppEnabledExtensionNames = ppEnabledExtensionNames; + this.enabledLayerNames = enabledLayerNames; + this.enabledExtensionNames = enabledExtensionNames; this.pEnabledFeatures = pEnabledFeatures; } } @@ -5403,7 +5419,7 @@ typealias VkQueryResultFlags = VkQueryResultFlagBits; [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateQueryPool(VkDevice device, VkQueryPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkQueryPool pQueryPool); [CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool = null, VkAllocationCallbacks* pAllocator = null); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount, c_size dataSize, out void pData, VkDeviceSize stride, VkQueryResultFlags flags = default); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount, c_size dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags = default); // Buffer commands struct VkBuffer : uint64 @@ -8938,7 +8954,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; public VkStructureType sType = SType; public void* pNext = null; - public VkMemoryRequirements memoryRequirements = default; + public using public VkMemoryRequirements memoryRequirements = default; } [CRepr] struct VkSparseImageMemoryRequirements2 : this() @@ -8946,7 +8962,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; public VkStructureType sType = SType; public void* pNext = null; - public VkSparseImageMemoryRequirements memoryRequirements = default; + public using public VkSparseImageMemoryRequirements memoryRequirements = default; } [CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageMemoryRequirements2(VkDevice device, VkImageMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements); @@ -8959,7 +8975,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkPhysicalDeviceFeatures features = default; + public using public VkPhysicalDeviceFeatures features = default; public this(void* pNext, VkPhysicalDeviceFeatures features) : this() { @@ -8973,7 +8989,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkPhysicalDeviceProperties properties = default; + public using public VkPhysicalDeviceProperties properties = default; } [CRepr] struct VkFormatProperties2 : this() @@ -8981,7 +8997,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkFormatProperties formatProperties = default; + public using public VkFormatProperties formatProperties = default; } [CRepr] struct VkImageFormatProperties2 : this() @@ -8989,7 +9005,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkImageFormatProperties imageFormatProperties = default; + public using public VkImageFormatProperties imageFormatProperties = default; } [CRepr] struct VkPhysicalDeviceImageFormatInfo2 : this() @@ -9019,7 +9035,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkQueueFamilyProperties queueFamilyProperties = default; + public using public VkQueueFamilyProperties queueFamilyProperties = default; } [CRepr] struct VkPhysicalDeviceMemoryProperties2 : this() @@ -9027,7 +9043,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkPhysicalDeviceMemoryProperties memoryProperties = default; + public using public VkPhysicalDeviceMemoryProperties memoryProperties = default; } [CRepr] struct VkSparseImageFormatProperties2 : this() @@ -9035,7 +9051,7 @@ static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } public const VkStructureType SType = .VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2; public VkStructureType sType = SType; public void* pNext = null; - public VkSparseImageFormatProperties properties = default; + public using public VkSparseImageFormatProperties properties = default; } [CRepr] struct VkPhysicalDeviceSparseImageFormatInfo2 : this() @@ -13501,7 +13517,7 @@ typealias VkMemoryUnmapFlags = VkMemoryUnmapFlagBits; public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; public VkStructureType sType = SType; public void* pNext = null; - public VkImageSubresource imageSubresource = default; + public using public VkImageSubresource imageSubresource = default; public this(void* pNext, VkImageSubresource imageSubresource) : this() { @@ -13515,7 +13531,7 @@ typealias VkMemoryUnmapFlags = VkMemoryUnmapFlagBits; public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; public VkStructureType sType = SType; public void* pNext = null; - public VkSubresourceLayout subresourceLayout = default; + public using public VkSubresourceLayout subresourceLayout = default; } typealias VkBufferUsageFlags2 = VkFlags64; @@ -15197,8 +15213,8 @@ struct VkDebugReportCallbackEXT : uint64 uint64 object, c_size location, int32 messageCode, - char8* pLayerPrefix, - char8* pMessage, + /***/ char8* pLayerPrefix, + /***/ char8* pMessage, void* pUserData); [AllowDuplicates] enum VkDebugReportFlagBitsEXT : int32 @@ -19109,7 +19125,7 @@ static { public const let VK_EXT_DEBUG_UTILS_EXTENSION_NAME = "VK_EXT_debug_util [CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkDebugUtilsMessengerCallbackEXT( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + /***/ VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData); [CRepr] struct VkDebugUtilsLabelEXT : this() @@ -20428,7 +20444,7 @@ typealias VkAccelerationStructureCreateFlagsKHR = VkAccelerationStructureCreateF [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyAccelerationStructureInfoKHR* pInfo); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32 accelerationStructureCount, VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, c_size dataSize, out void pData, c_size stride); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32 accelerationStructureCount, VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, c_size dataSize, void* pData, c_size stride); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, VkCopyAccelerationStructureInfoKHR* pInfo); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); @@ -20622,8 +20638,8 @@ static { public const uint32 VK_SHADER_UNUSED_KHR = (~0U); } [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32 width, uint32 height, uint32 depth); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32 createInfoCount, VkRayTracingPipelineCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32 firstGroup, uint32 groupCount, c_size dataSize, out void pData); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32 firstGroup, uint32 groupCount, c_size dataSize, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32 firstGroup, uint32 groupCount, c_size dataSize, void* pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32 firstGroup, uint32 groupCount, c_size dataSize, void* pData); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); [CallingConvention(VKAPI_PTR)] function VkDeviceSize PFN_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32 group, VkShaderGroupShaderKHR groupShader); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32 pipelineStackSize); @@ -21473,7 +21489,7 @@ typealias VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32 width, uint32 height, uint32 depth); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkRayTracingPipelineCreateInfoNV* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); typealias PFN_vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesKHR; -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, c_size dataSize, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, c_size dataSize, void* pData); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32 accelerationStructureCount, VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32 shader); @@ -24377,7 +24393,7 @@ typealias VkDeviceMemoryReportFlagsEXT = VkFlags; } [CallingConvention(VKAPI_PTR)] function void PFN_vkDeviceMemoryReportCallbackEXT( - VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + /***/ VkDeviceMemoryReportCallbackDataEXT* pCallbackData, void* pUserData); // codespell:ignore devault @@ -25635,7 +25651,7 @@ static { public const let VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME = "VK_EXT_desc [CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, out VkDeviceSize pLayoutSizeInBytes); [CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32 binding, out VkDeviceSize pOffset); -[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorEXT(VkDevice device, VkDescriptorGetInfoEXT* pDescriptorInfo, c_size dataSize, out void pDescriptor); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorEXT(VkDevice device, VkDescriptorGetInfoEXT* pDescriptorInfo, c_size dataSize, void* pDescriptor); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32 bufferCount, VkDescriptorBufferBindingInfoEXT* pBindingInfos); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 firstSet, uint32 setCount, uint32* pBufferIndices, VkDeviceSize* pOffsets); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set); @@ -28095,7 +28111,7 @@ typealias VkMicromapCreateFlagsEXT = VkMicromapCreateFlagBitsEXT; [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyMicromapInfoEXT* pInfo); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyMicromapToMemoryInfoEXT* pInfo); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, VkCopyMemoryToMicromapInfoEXT* pInfo); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWriteMicromapsPropertiesEXT(VkDevice device, uint32 micromapCount, VkMicromapEXT* pMicromaps, VkQueryType queryType, c_size dataSize, out void pData, c_size stride); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWriteMicromapsPropertiesEXT(VkDevice device, uint32 micromapCount, VkMicromapEXT* pMicromaps, VkQueryType queryType, c_size dataSize, void* pData, c_size stride); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, VkCopyMicromapInfoEXT* pInfo); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, VkCopyMicromapToMemoryInfoEXT* pInfo); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, VkCopyMemoryToMicromapInfoEXT* pInfo); @@ -29332,7 +29348,7 @@ typealias VkDirectDriverLoadingFlagsLUNARG = VkFlags; } [CallingConvention(VKAPI_PTR)] function PFN_vkVoidFunction PFN_vkGetInstanceProcAddrLUNARG( - VkInstance instance, char8* pName); + VkInstance instance, /***/ char8* pName); static { public const let VK_ARM_TENSORS_SPEC_VERSION = 1; } static { public const let VK_ARM_TENSORS_EXTENSION_NAME = "VK_ARM_tensors"; } @@ -32279,7 +32295,7 @@ typealias VkDataGraphPipelineDispatchFlagsARM = VkFlags64; [CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, VkAllocationCallbacks* pAllocator = null); [CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, VkDataGraphPipelineDispatchInfoARM* pInfo = null); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, out uint32 pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties = null); -[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDataGraphPipelinePropertiesARM(VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, uint32 propertiesCount, out VkDataGraphPipelinePropertyQueryResultARM pProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDataGraphPipelinePropertiesARM(VkDevice device, VkDataGraphPipelineInfoARM* pPipelineInfo, uint32 propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties); [CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties = null); [CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, out VkQueueFamilyDataGraphProcessingEnginePropertiesARM pQueueFamilyDataGraphProcessingEngineProperties);