Rune/Vulkan-Beef
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add features

Browse Source
This commit is contained in:
Rune
2026-03-30 14:39:44 +02:00
parent 486babcf0d
commit 777e60c8a6
8 changed files with 1437 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Setup/BeefProj.toml
View File

@@ -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"}

5
Setup/BeefSpace.toml
View File

@@ -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"}

6
Setup/BeefSpace_Lock.toml Normal file
View File

@@ -0,0 +1,6 @@
FileVersion = 1
[Locks."Expat.git".Git]
URL = "https://git.unicon-gmbh.de/BeefBindings/Expat.git"
Tag = ""
Hash = "97c80cd88dd68f4a70922c7b0bad0b27f86aa3c6"

138
Setup/src/Program.bf
View File

@@ -99,11 +99,12 @@ 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:
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<PureEnum> apiVersion;
public enum ApiVersion { Cases, FeatureStruct }
public static append EnumMetadata<ApiVersion> apiVersion;
public enum Extensions { Cases, Name, Tag, Kind, MinVersion, PromotedTo, Dependencies }
public static append EnumMetadata<Extensions> extensions;
public enum Features { Cases, ApiVersion, ExtensionStruct }
public static append EnumMetadata<Features> features;
public enum TypeEnum { Type }
public static append EnumMetadata<TypeEnum> vkStructureType;
public static append EnumMetadata<TypeEnum> 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<StringView, (int lens, Field field, Field lenField)> 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)
{
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) == true)
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<VulkanExtension> Dependencies", .Property));
Metadata.features.WriteToStream(strBuffer, writer, "enum VulkanFeature",
(null, .Cases),
("public VulkanApiVersion ApiVersion", .Property),
("public VkStructureType ExtensionStruct", .Property));
writer.Write("""
namespace Vulkan;

6
src/Library.bf
View File

@@ -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

164
src/Loader.bf
View File

@@ -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<VkSubmitInfo> 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<VkMappedMemoryRange> pMemoryRanges) => VulkanLoadedFunctions.current.vkFlushMappedMemoryRanges(device, (.)pMemoryRanges.Length, pMemoryRanges.Ptr);
[Inline] public static VkResult InvalidateMappedMemoryRanges(this VkDevice device, Span<VkMappedMemoryRange> 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<VkBindSparseInfo> 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<VkFence> 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<VkFence> 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<void> 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<VkPipelineCache> 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<VkDescriptorSet> pDescriptorSets) => VulkanLoadedFunctions.current.vkFreeDescriptorSets(device, descriptorPool, (.)pDescriptorSets.Length, pDescriptorSets.Ptr);
[Inline] public static void UpdateDescriptorSets(this VkDevice device, Span<VkWriteDescriptorSet> pDescriptorWrites, Span<VkCopyDescriptorSet> 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<VkCommandBuffer> 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<VkViewport> pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewport(commandBuffer, firstViewport, (.)pViewports.Length, pViewports.Ptr);
[Inline] public static void SetScissor(this VkCommandBuffer commandBuffer, uint32 firstScissor, Span<VkRect2D> 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<VkDescriptorSet> pDescriptorSets, Span<uint32> 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<VkMultiDrawInfoEXT> 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<VkMultiDrawIndexedInfoEXT> 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<VkBufferCopy> 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<VkImageCopy> 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<VkImageBlit> 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<VkBufferImageCopy> 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<VkBufferImageCopy> 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<void> 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<VkImageSubresourceRange> 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<VkImageSubresourceRange> pRanges) => VulkanLoadedFunctions.current.vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, (.)pRanges.Length, pRanges.Ptr);
[Inline] public static void ClearAttachments(this VkCommandBuffer commandBuffer, Span<VkClearAttachment> pAttachments, Span<VkClearRect> 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<VkImageResolve> 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<VkEvent> pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, Span<VkMemoryBarrier> pMemoryBarriers, Span<VkBufferMemoryBarrier> pBufferMemoryBarriers, Span<VkImageMemoryBarrier> 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<VkMemoryBarrier> pMemoryBarriers, Span<VkBufferMemoryBarrier> pBufferMemoryBarriers, Span<VkImageMemoryBarrier> 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<void> 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<VkCommandBuffer> 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<VkWriteIndirectExecutionSetPipelineEXT> pExecutionSetWrites) => VulkanLoadedFunctions.current.vkUpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, (.)pExecutionSetWrites.Length, pExecutionSetWrites.Ptr);
[Inline] public static void UpdateShaderEXT(this VkIndirectExecutionSetEXT indirectExecutionSet, VkDevice device, Span<VkWriteIndirectExecutionSetShaderEXT> 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<VkWriteDescriptorSet> 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<VkWriteDescriptorSet> 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<VkBindBufferMemoryInfo> pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2(device, (.)pBindInfos.Length, pBindInfos.Ptr);
[Inline] public static VkResult BindBufferMemory2KHR(this VkDevice device, Span<VkBindBufferMemoryInfo> pBindInfos) => VulkanLoadedFunctions.current.vkBindBufferMemory2KHR(device, (.)pBindInfos.Length, pBindInfos.Ptr);
[Inline] public static VkResult BindImageMemory2(this VkDevice device, Span<VkBindImageMemoryInfo> pBindInfos) => VulkanLoadedFunctions.current.vkBindImageMemory2(device, (.)pBindInfos.Length, pBindInfos.Ptr);
[Inline] public static VkResult BindImageMemory2KHR(this VkDevice device, Span<VkBindImageMemoryInfo> 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<VkViewportWScalingNV> pViewportWScalings) => VulkanLoadedFunctions.current.vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, (.)pViewportWScalings.Length, pViewportWScalings.Ptr);
[Inline] public static void SetDiscardRectangleEXT(this VkCommandBuffer commandBuffer, uint32 firstDiscardRectangle, Span<VkRect2D> 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<VkValidationCacheEXT> 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<VkRect2D> pExclusiveScissors) => VulkanLoadedFunctions.current.vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, (.)pExclusiveScissors.Length, pExclusiveScissors.Ptr);
[Inline] public static void SetExclusiveScissorEnableNV(this VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, Span<VkBool32> 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<VkShadingRatePaletteNV> pShadingRatePalettes) => VulkanLoadedFunctions.current.vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, (.)pShadingRatePalettes.Length, pShadingRatePalettes.Ptr);
[Inline] public static void SetCoarseSampleOrderNV(this VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, Span<VkCoarseSampleOrderCustomNV> 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<VkBindAccelerationStructureMemoryInfoNV> 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<VkAccelerationStructureKHR> 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<VkAccelerationStructureNV> 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<VkAccelerationStructureKHR> pAccelerationStructures, VkQueryType queryType, Span<void> 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<void> 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<void> 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<void> pData) => VulkanLoadedFunctions.current.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, (.)pData.Length, pData.Ptr);
[Inline] public static VkResult GetHandleNV(this VkAccelerationStructureNV accelerationStructure, VkDevice device, Span<void> 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<VkViewport> pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCount(commandBuffer, (.)pViewports.Length, pViewports.Ptr);
[Inline] public static void SetViewportWithCountEXT(this VkCommandBuffer commandBuffer, Span<VkViewport> pViewports) => VulkanLoadedFunctions.current.vkCmdSetViewportWithCountEXT(commandBuffer, (.)pViewports.Length, pViewports.Ptr);
[Inline] public static void SetScissorWithCount(this VkCommandBuffer commandBuffer, Span<VkRect2D> pScissors) => VulkanLoadedFunctions.current.vkCmdSetScissorWithCount(commandBuffer, (.)pScissors.Length, pScissors.Ptr);
[Inline] public static void SetScissorWithCountEXT(this VkCommandBuffer commandBuffer, Span<VkRect2D> 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<VkBool32> pColorBlendEnables) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, (.)pColorBlendEnables.Length, pColorBlendEnables.Ptr);
[Inline] public static void SetColorBlendEquationEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span<VkColorBlendEquationEXT> pColorBlendEquations) => VulkanLoadedFunctions.current.vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, (.)pColorBlendEquations.Length, pColorBlendEquations.Ptr);
[Inline] public static void SetColorWriteMaskEXT(this VkCommandBuffer commandBuffer, uint32 firstAttachment, Span<VkColorComponentFlags> 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<VkColorBlendAdvancedEXT> 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<VkViewportSwizzleNV> 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<float> 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<VkVertexInputBindingDescription2EXT> pVertexBindingDescriptions, Span<VkVertexInputAttributeDescription2EXT> pVertexAttributeDescriptions) => VulkanLoadedFunctions.current.vkCmdSetVertexInputEXT(commandBuffer, (.)pVertexBindingDescriptions.Length, pVertexBindingDescriptions.Ptr, (.)pVertexAttributeDescriptions.Length, pVertexAttributeDescriptions.Ptr);
[Inline] public static void SetColorWriteEnableEXT(this VkCommandBuffer commandBuffer, Span<VkBool32> 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<VkSubmitInfo2> pSubmits, VkFence fence = null) => VulkanLoadedFunctions.current.vkQueueSubmit2(queue, (.)pSubmits.Length, pSubmits.Ptr, fence);
[Inline] public static VkResult Submit2KHR(this VkQueue queue, Span<VkSubmitInfo2> 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<VkHostImageLayoutTransitionInfo> pTransitions) => VulkanLoadedFunctions.current.vkTransitionImageLayout(device, (.)pTransitions.Length, pTransitions.Ptr);
[Inline] public static VkResult TransitionImageLayoutEXT(this VkDevice device, Span<VkHostImageLayoutTransitionInfo> 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<VkBindVideoSessionMemoryInfoKHR> 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<VkDecompressMemoryRegionNV> 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<void> pDescriptor) => VulkanLoadedFunctions.current.vkGetDescriptorEXT(device, pDescriptorInfo, (.)pDescriptor.Length, pDescriptor.Ptr);
[Inline] public static void BindDescriptorBuffersEXT(this VkCommandBuffer commandBuffer, Span<VkDescriptorBufferBindingInfoEXT> 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<VkMicromapBuildInfoEXT> pInfos) => VulkanLoadedFunctions.current.vkCmdBuildMicromapsEXT(commandBuffer, (.)pInfos.Length, pInfos.Ptr);
[Inline] public static VkResult BuildMicromapsEXT(this VkDeferredOperationKHR deferredOperation, VkDevice device, Span<VkMicromapBuildInfoEXT> 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<VkMicromapEXT> 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<VkMicromapEXT> pMicromaps, VkQueryType queryType, Span<void> 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<VkConvertCooperativeVectorMatrixInfoNV> 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<VkBindTensorMemoryInfoARM> 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<VkBindDataGraphPipelineSessionMemoryInfoARM> 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<VkDataGraphPipelinePropertyQueryResultARM> 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<VkSemaphore> 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);
}

1157
src/Metadata.bf
View File

File diff suppressed because it is too large Load Diff

84
src/Vulkan.bf
View File

@@ -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<char8*> 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<char8*> 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<char8*> enabledLayerNames = default, Span<char8*> 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<char8*> enabledLayerNames
{
get { return .(ppEnabledLayerNames, (.)enabledLayerCount); }
set mut { ppEnabledLayerNames = value.Ptr; enabledLayerCount = (.)value.Length; }
}
public uint32 enabledExtensionCount = 0;
public char8** ppEnabledExtensionNames = null;
public Span<char8*> enabledExtensionNames
{
get { return .(ppEnabledExtensionNames, (.)enabledExtensionCount); }
set mut { ppEnabledExtensionNames = value.Ptr; enabledExtensionCount = (.)value.Length; }
}
public VkPhysicalDeviceFeatures* pEnabledFeatures = null;
public this(void* pNext, VkDeviceCreateFlags flags, Span<VkDeviceQueueCreateInfo> queueCreateInfos, uint32 enabledLayerCount, char8** ppEnabledLayerNames, uint32 enabledExtensionCount, char8** ppEnabledExtensionNames, VkPhysicalDeviceFeatures* pEnabledFeatures = null) : this()
public this(void* pNext = null, VkDeviceCreateFlags flags = default, Span<VkDeviceQueueCreateInfo> queueCreateInfos = default, Span<char8*> enabledLayerNames = default, Span<char8*> 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);