From 486babcf0dd4840353726bd5be8f66a937750991 Mon Sep 17 00:00:00 2001 From: Rune Date: Sun, 29 Mar 2026 16:33:12 +0200 Subject: [PATCH] add code --- BeefProj.toml | 6 + BeefSpace.toml | 5 + Setup/BeefProj.toml | 6 + Setup/BeefSpace.toml | 5 + Setup/src/Program.bf | 1677 ++ src/Library.bf | 63 + src/Loader.bf | 5451 ++++++ src/Metadata.bf | 3927 +++++ src/Video.bf | 3604 ++++ src/Vulkan.bf | 36423 +++++++++++++++++++++++++++++++++++++++++ 10 files changed, 51167 insertions(+) create mode 100644 BeefProj.toml create mode 100644 BeefSpace.toml create mode 100644 Setup/BeefProj.toml create mode 100644 Setup/BeefSpace.toml create mode 100644 Setup/src/Program.bf create mode 100644 src/Library.bf create mode 100644 src/Loader.bf create mode 100644 src/Metadata.bf create mode 100644 src/Video.bf create mode 100644 src/Vulkan.bf diff --git a/BeefProj.toml b/BeefProj.toml new file mode 100644 index 0000000..b27dc24 --- /dev/null +++ b/BeefProj.toml @@ -0,0 +1,6 @@ +FileVersion = 1 + +[Project] +Name = "Vulkan" +TargetType = "BeefLib" +StartupObject = "Vulkan.Program" diff --git a/BeefSpace.toml b/BeefSpace.toml new file mode 100644 index 0000000..cf255f9 --- /dev/null +++ b/BeefSpace.toml @@ -0,0 +1,5 @@ +FileVersion = 1 +Projects = {Vulkan = {Path = "."}} + +[Workspace] +StartupProject = "Vulkan" diff --git a/Setup/BeefProj.toml b/Setup/BeefProj.toml new file mode 100644 index 0000000..900efc5 --- /dev/null +++ b/Setup/BeefProj.toml @@ -0,0 +1,6 @@ +FileVersion = 1 +Dependencies = {corlib = "*", Expat = "*"} + +[Project] +Name = "Vulkan.Setup" +StartupObject = "Vulkan.Setup.Program" diff --git a/Setup/BeefSpace.toml b/Setup/BeefSpace.toml new file mode 100644 index 0000000..cc776f1 --- /dev/null +++ b/Setup/BeefSpace.toml @@ -0,0 +1,5 @@ +FileVersion = 1 +Projects = {"Vulkan.Setup" = {Path = "."}, Expat = {Path = "../../../RandomStuff/Cpp2Beef/Bindings/Expat"}} + +[Workspace] +StartupProject = "Vulkan.Setup" diff --git a/Setup/src/Program.bf b/Setup/src/Program.bf new file mode 100644 index 0000000..9167bec --- /dev/null +++ b/Setup/src/Program.bf @@ -0,0 +1,1677 @@ +using System; +using System.IO; +using System.Collections; +using System.Diagnostics; + +using Expat; + +namespace Vulkan.Setup; + +static +{ + public const StringView[?] vkApis = .("vulkan", "vulkanbase"); + + public static BumpAllocator alloc; + public static Dictionary vkTypes; + public static Dictionary vkCommands; + public static List tags; + public static Dictionary handles; + public static List vulkanBf; + public static List videoBf; + + public static void WriteComment(StringView comment, String outString) + { + if (comment.StartsWith('/')) + { + outString.Append(comment); + return; + } + if (comment.IsEmpty) return; + outString.Append("// ", comment); + } +} + +static class Metadata +{ + public class EnumMetadata : Dictionary where T : Enum, operator explicit int + { + public struct Values + { + public VulkanFeature.Kind* predicate; + public SizedArray underlying; + + public ref String At(T idx) mut + { + return ref (underlying.[Friend]mVal[(int)idx]); + } + } + + public Values* For(StringView key, VulkanFeature.Kind* predicate = null) + { + switch (TryAdd(key)) + { + case .Added(let keyPtr, let valuePtr): + *keyPtr = new:alloc String(key); + valuePtr.predicate = predicate; + return valuePtr; + case .Exists(let keyPtr, let valuePtr): + return valuePtr; + } + } + + public void WriteToStream(String strBuffer, StreamWriter writer, StringView decl, params Span<(StringView sig, enum { Method, Property, Cases } mode)> methodSigs) + { + strBuffer.Clear(); + strBuffer.Append(decl, "\n{\n"); + for (let sig in methodSigs) + { + if (@sig.Index != 0) strBuffer.Append('\n'); + StringView indent; + strBuffer.Append("\t", sig.sig); + switch (sig.mode) + { + case .Method: + indent = "\t\t"; + strBuffer.Append(""" + + { + switch (this) + { + + """); + case .Property: + indent = "\t\t\t"; + strBuffer.Append(""" + + { + get + { + switch (this) + { + + """); + case .Cases: + indent = "\t"; + strBuffer.Length--; + } + for (let kv in this) + { + if (kv.value.predicate != null && *kv.value.predicate != .AlreadyWritten) + continue; + let val = kv.value.underlying.[Friend]mVal[@sig.Index]; + if (val == null) continue; + strBuffer.Append(indent, "case ", kv.key); + switch (sig.mode) + { + case .Cases: + strBuffer.Append(" = "); + case .Method, .Property: + strBuffer.Append(": return "); + } + strBuffer.Append(val, ";\n"); + } + switch (sig.mode) + { + case .Method: + strBuffer.Append(""" + default: return default; + } + } + + """); + case .Property: + strBuffer.Append(""" + default: return default; + } + } + } + + """); + case .Cases: + } + } + strBuffer.Append("}\n\n"); + writer.Write(strBuffer); + } + } + + public enum PureEnum { Cases } + public static append EnumMetadata apiVersion; + public enum Extensions { Cases, Name, Tag, Kind, MinVersion, PromotedTo, Dependencies } + public static append EnumMetadata extensions; + public enum TypeEnum { Type } + public static append EnumMetadata vkStructureType; + public static append EnumMetadata vkObjectType; +} + +class VulkanFeature +{ + public enum Kind { Invalid, Comment, HasBody, Command, TypeAlias, Constant, AlreadyWritten = -1 } + + public Kind kind; + public String name; + public String comment; + + public virtual void Write(String str) + { + kind = .AlreadyWritten; + if (!String.IsNullOrEmpty(comment)) + { + WriteComment(comment, str); + str.Append('\n'); + } + } +} + +class PregeneratedFeature : VulkanFeature +{ + public String content; + + public override void Write(String str) + { + base.Write(str); + str.Append(content); + str.Append('\n'); + } +} + +class CommandFeature : PregeneratedFeature +{ + public String prettyExecute; + public Range spellingRange = .(-1, -1); + public Range callRange = .(-1, -1); + + public String handle; + public enum Category { None, Instance, Device } + public Category category; + + public String mixinOutArrayFmt; +} + +class EnumFeature : VulkanFeature +{ + public struct Case : this(String name, String value, String comment), IHashable + { + public int GetHashCode() + { + return name.GetHashCode(); + } + } + public append HashSet cases; + + public override void Write(String str) + { + base.Write(str); + str.Append("[AllowDuplicates] enum ", name, " : int32\n{\n"); + StringView lastCaseName = null; + for (let enumcase in cases) + { + if (lastCaseName == enumcase.name) continue; + str.Append("\t[NoShow] "); + str.Append(enumcase.name); + str.Append(" = "); + str.Append(enumcase.value); + str.Append(','); + if (!String.IsNullOrEmpty(enumcase.comment)) + { + str.Append(' '); + WriteComment(enumcase.comment, str); + } + str.Append('\n'); + lastCaseName = enumcase.name; + } + str.Append("\t// pretty names\n"); + StringView prefix = name; + for (let t in tags) + { + if (!prefix.EndsWith(t)) continue; + prefix.RemoveFromEnd(t.Length); + break; + } + if (prefix.EndsWith("FlagBits")) + prefix.RemoveFromEnd(8); + String lastName = scope .(128); + for (let enumcase in cases) + { + void PrettyName(StringView cName, String str) + { + if (name == "VkFormat") + { + str.Append(cName["VK_FORMAT_".Length...]); + return; + } + + var cName; + StringView tag = null; + for (let t in tags) + { + if (!cName.EndsWith(t)) continue; + tag = t; + cName.RemoveFromEnd(t.Length + 1); + break; + } + if (cName.EndsWith("_BIT")) + cName.RemoveFromEnd(4); + + let index = str.Length; + bool upper = true; + for (let c in cName) + if (c == '_') + { + upper = true; + if (str.Length > 0 && str[^1].IsDigit) + str.Append('_'); + } + else + { + str.Append(upper ? c.ToUpper : c.ToLower); + upper = false; + } + isPrefixed: do + { + int strI = index; + int prefixI = 0; + repeat + { + char8 c = str[strI++]; + if (c == '_') continue; + if (c != prefix[prefixI++]) break isPrefixed; + if (strI >= str.Length) break isPrefixed; + } + while (prefixI < prefix.Length); + str.Remove(index, strI); + } + str.Append(tag); + if (str[index].IsDigit) str.Insert(index, '_'); + } + + String name = PrettyName(enumcase.name, ..scope .(enumcase.name.Length)); + String value = scope .(enumcase.value.Length); + if (enumcase.value.StartsWith("VK_")) + PrettyName(enumcase.value, value); + else + value.Append(enumcase.value); + + if (name == lastName || name == value) continue; + lastName.Set(name) ; + + str.Append("\t", name, " = ", value, ","); + if (!String.IsNullOrEmpty(enumcase.comment)) + { + str.Append(' '); + WriteComment(enumcase.comment, str); + } + str.Append('\n'); + } + str.Append("}\n"); + } +} + +class RegistryParser : XmlParser +{ + List vkOutput; + public this(List output) : base(null) + { + vkOutput = output; + } + + enum Element + { + Registry, + Ignore, + + Tags, + + Types, + Type_Struct, + Type_Union, + Type_Bitmask, + Type_Basetype, + Type_Handle, + Type_FuncPtr, + Type_Define, + + Enums, + Enums_Constants, + + Member, + Name, + Type, + Comment, + Enum, + + Commands, + Command, + Proto, + Param, + + Feature, + Extensions, + Extension, + Require, + } + append List eStack = .(16); + + append String strBuf = .(1024); + class Field + { + public append String name; + public append String type; + public append String comment, values, length; + public append String spanType, spanName; + public int bitfieldWidth; + public enum { None, Optional = 1, CommentOnly = 2, Bitfield = 4, SpanNoWrite = 8, SpanWrite = 16 } flags; + + public void Clear() + { + name.Clear(); + type.Clear(); + comment.Clear(); + values.Clear(); + length.Clear(); + spanType.Clear(); + spanName.Clear(); + bitfieldWidth = -1; + flags = .None; + } + } + int fieldBufferIdx = -1; + bool struct_returnOnly = false; + append List fieldBuffer = .(128); + append List fields = .(128); + Field AcquireField() + { + if (++fieldBufferIdx >= fieldBuffer.Count) + fieldBuffer.Add(new:alloc .()); + let field = fieldBuffer[fieldBufferIdx]; + field.Clear(); + return field; + } + + append String type_name = .(128), type_comment = .(128); + void InitTypeFeature(VulkanFeature feature) + { + feature.name = new:alloc .(type_name); + feature.comment = new:alloc .(type_comment); + } + + StringView CToBeefType(StringView type) + { + switch (type) + { + case "uint32_t": return "uint32"; + case "uint8_t": return "uint8"; + case "uint64_t": return "uint64"; + case "uint16_t": return "uint16"; + case "char": return "char8"; + case "int32_t": return "int32"; + case "int8_t": return "int8"; + case "int64_t": return "int64"; + case "int16_t": return "int16"; + case "size_t": return "c_size"; + case "int": return "c_int"; + default: return _; + } + } + + StringView DefaultValueForType(StringView type) + { + if (type.EndsWith('*')) return "null"; + if (type == "VkBool32") return "false"; + if (type.Contains('[') /*|| type.StartsWith("Span<")*/) return ".()"; //TODO: await span fix + if (type == "float" || type == "double" || type == "c_size" || type.StartsWith("int") || type.StartsWith("uint")) + return "0"; + if (handles.ContainsKeyAlt(type)) + return "null"; + return "default"; + } + + append String bitmask_requires = .(64); + enum { Unknown, Handle, Opaque, TypeAlias } basetype_variant; + + String handle_objval = bitmask_requires; + append String handle_parent = .(64); + + EnumFeature curEnum; + int ext_number = -1; + + class Param + { + public append String name; + 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 void Clear() + { + name.Clear(); + type.Clear(); + length.Clear(); + call.Clear(); + flags = .None; + } + } + int paramBufferIdx = -1; + append String command_rettype = .(64); + append List paramBuffer = .(16); + append List parameters = .(16); + Param AcquireParam() + { + if (++paramBufferIdx >= paramBuffer.Count) + paramBuffer.Add(new:alloc .()); + let param = paramBuffer[paramBufferIdx]; + param.Clear(); + return param; + } + + public override void StartElementHandler(char8* nameC, char8** attsC) + { + HandleCData(); + + if (!eStack.IsEmpty && eStack.Back == .Ignore) + { + eStack.Add(.Ignore); + return; + } + + StringView element = .(nameC); + Dictionary atts = scope .(8); + for (int i = 0; attsC[i] != null; i += 2) + atts.Add(.(attsC[i]), .(attsC[i + 1])); + + if (atts.TryGetValue("api", var apis) || + (element == "extension" && atts.TryGetValue("supported", out apis)) || + (element == "command" && atts.TryGetValue("export", out apis)) + ) api: do + { + for (let api in apis.Split(',')) + if (vkApis.Contains(api)) + break api; + eStack.Add(.Ignore); + return; + } + + void FeatureComment() + { + if (atts.TryGetValue("comment", let comment)) + vkOutput.Add(new:alloc .() + { + comment = new:alloc .(comment), + kind = .Comment, + }); + } + + switch (element) + { + case "registry": eStack.Add(.Registry); + case "tags": eStack.Add(.Tags); + case "tag": tags.Add(new:alloc .(atts["name"])); eStack.Add(.Ignore); + case "types": eStack.Add(.Types); + case "type": + switch (eStack.Back) + { + case .Types: + type_name.Set(atts.GetValueOrDefault("name")); + type_comment.Set(atts.GetValueOrDefault("comment")); + if (atts.TryGetValue("alias", let alias)) + { + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + InitTypeFeature(feature); + strBuf.Clear(); + strBuf.Append("typealias ", type_name, " = ", alias, ";"); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + eStack.Add(.Ignore); + break; + } + switch (atts.GetValueOrDefault("category")) + { + case "struct": + fields.Clear(); + fieldBufferIdx = -1; + struct_returnOnly = atts.Contains(("returnedonly", "true")); + eStack.Add(.Type_Struct); + case "union": + fields.Clear(); + fieldBufferIdx = -1; + struct_returnOnly = atts.Contains(("returnedonly", "true")); + eStack.Add(.Type_Union); + case "bitmask": + strBuf.Set("typealias "); + bitmask_requires.Set(atts.GetValueOrDefault("requires")); + eStack.Add(.Type_Bitmask); + case "basetype": + strBuf.Clear(); + basetype_variant = .Unknown; + eStack.Add(.Type_Basetype); + case "enum": + EnumFeature feature = new:alloc .() { kind = .HasBody }; + InitTypeFeature(feature); + vkTypes.Add(feature.name, feature); + eStack.Add(.Ignore); + case "handle": + handle_objval.Set(atts["objtypeenum"]); + handle_parent.Set(atts.GetValueOrDefault("parent")); + strBuf.Clear(); + eStack.Add(.Type_Handle); + case "funcpointer": + strBuf.Clear(); + type_name.Clear(); + eStack.Add(.Type_FuncPtr); + 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/")) + { + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + InitTypeFeature(feature); + strBuf.Clear(); + switch (type_name) + { + case "DWORD": strBuf.Append("typealias DWORD = int32;"); + case "LPCWSTR": strBuf.Append("typealias LPCWSTR = c_wchar*;"); + + when _.StartsWith('H'): + strBuf.Append("struct ", type_name, " : int {}"); + default: + strBuf.Append("struct ", type_name, ";"); + } + feature.content = new:alloc .(strBuf); + vkOutput.Add(feature); + }*/ + fallthrough; + default: + eStack.Add(.Ignore); + } + case .Require: + if (vkTypes.TryGetValue(atts["name"], let value)) + vkOutput.Add(value); + eStack.Add(.Ignore); + default: + eStack.Add(.Type); + } + case "member": + if (eStack.Back == .Type_Struct || eStack.Back == .Type_Union) + { + let field = AcquireField(); + field.values.Append(atts.GetValueOrDefault("values")); + field.length.Append(atts.GetValueOrDefault("len")); + if (atts.GetValueOrDefault("optional") == "true") field.flags |= .Optional; + fields.Add(field); + } + eStack.Add(.Member); + case "comment": + if (eStack.Back == .Type_Struct || eStack.Back == .Type_Union) + { + let field = AcquireField(); + field.flags |= .CommentOnly; + fields.Add(field); + } + eStack.Add(.Comment); + case "enums": + if (atts["type"] == "constants") + eStack.Add(.Enums_Constants); + else + { + curEnum = (.)vkTypes[atts["name"]]; + eStack.Add(.Enums); + } + case "enum": + switch (eStack.Back) + { + case .Require: + StringView extends = null, value = null, bitpos = null, offset = null, enumType = null; + if (!atts.TryGetValue("extends", out extends) & + (!atts.TryGetValue("value", out value) && + !atts.TryGetValue("alias", out value)) & + !atts.TryGetValue("bitpos", out bitpos) & + !atts.TryGetValue("offset", out offset) & + !atts.TryGetValue("type", out enumType)) + { + if (vkTypes.TryGetValue(atts["name"], let feature)) + vkOutput.Add(feature); + break; + } + int extnumber = ext_number; + if (atts.TryGetValue("extnumber", let extnumberStr)) + extnumber = int.Parse(extnumberStr); + String name = new:alloc .(atts["name"]); + String comment = atts.TryGetValue("comment", let attComment) ? new:alloc .(attComment) : null; + if (extends.IsNull) + { + PregeneratedFeature feature = new:alloc .() { kind = .Constant }; + feature.name = name; + feature.comment = comment; + strBuf.Clear(); + enumType = CToBeefType(enumType); + if (enumType.IsNull) enumType = "let"; + strBuf.Append("static { public const ", enumType, " ", feature.name, " = ", value, "; }"); + feature.content = new:alloc .(strBuf); + vkOutput.Add(feature); + break; + } + String casevalue = scope .(128); + if (atts.TryGetValue("dir", let dir)) casevalue.Append(dir); + if (!value.IsNull) casevalue.Append(value); + else if (!bitpos.IsNull) casevalue.Append("1 << ", bitpos); + else if (!offset.IsNull) (1'000'000'000 + (extnumber-1)*1000 + int.Parse(offset)).ToString(casevalue); + else Runtime.FatalError(); + (vkTypes[extends] as EnumFeature).cases.Add(.(name, new:alloc .(casevalue), comment)); + case .Enums: + String case_value; + if (atts.TryGetValue("value", var val) || atts.TryGetValue("alias", out val)) + case_value = new:alloc .(val); + else if (atts.TryGetValue("bitpos", let bitpos)) + case_value = new:alloc .(bitpos.Length + "1 << ".Length) + ..Append("1 << ", bitpos); + else + Runtime.FatalError(); + String case_name = new:alloc .(atts["name"]); + String case_comment = atts.TryGetValue("comment", let comment) ? new:alloc .(comment) : null; + curEnum.cases.Add(.(case_name, case_value, case_comment)); + case .Enums_Constants: + PregeneratedFeature feature = new:alloc .() { kind = .Constant }; + feature.name = new:alloc .(atts["name"]); + feature.comment = atts.TryGetValue("comment", let attComment) ? new:alloc .(attComment) : null; + var value = atts["value"]; + if (value == "(~0ULL)") value = "(~0UL)"; + feature.content = new:alloc $"static {{ public const {CToBeefType(atts["type"])} {atts["name"]} = {value}; }}"; + vkTypes.Add(feature.name, feature); + default: + eStack.Add(.Enum); + return; + } + eStack.Add(.Ignore); + + case "commands": eStack.Add(.Commands); + case "command": + switch (eStack.Back) + { + case .Commands: + if (atts.TryGetValue("alias", let alias)) + { + let name = atts["name"]; + CommandFeature feature = new:alloc .() + { + kind = .Command, + name = new:alloc .(name), + comment = atts.TryGetValue("comment", let comment) ? new:alloc .(comment) : null, + content = new:alloc .({ strBuf.Clear(); strBuf..Append("typealias PFN_", name, " = PFN_", alias, ";") }) + }; + Runtime.Assert(vkCommands.TryGetValue(alias, let aliased)); + feature.category = aliased.category; + feature.handle = aliased.handle; + feature.prettyExecute = new:alloc .(aliased.prettyExecute); + feature.prettyExecute.Replace(aliased.callRange, name); + feature.prettyExecute.Replace(aliased.spellingRange, WriteCommandPrettyName(name, feature.handle, ..scope .())); + vkCommands.Add(feature.name, feature); + eStack.Add(.Ignore); + break; + } + parameters.Clear(); + paramBufferIdx = -1; + command_rettype.Clear(); + type_name.Clear(); + type_comment.Set(atts.GetValueOrDefault("comment")); + eStack.Add(.Command); + case .Require: + vkOutput.Add(vkCommands[atts["name"]]); + eStack.Add(.Ignore); + default: + eStack.Add(.Ignore); + } + case "proto": eStack.Add(.Proto); + case "param": + let param = AcquireParam(); + if (atts.TryGetValue("len", let len)) param.length.Append(len); + if (atts.Contains(("optional", "true"))) param.flags |= .Optional; + parameters.Add(param); + eStack.Add(.Param); + + case "name": eStack.Add(.Name); + case "extensions": eStack.Add(.Extensions); + case "feature": eStack.Add(.Feature); FeatureComment(); + case "extension": + eStack.Add(.Extension); + FeatureComment(); + ext_number = int.Parse(atts["number"]); + + let name = atts["name"]; + if (!name.StartsWith("VK")) break; + var value = Metadata.extensions.For(name); + value.At(.Cases) = new:alloc .(atts["number"]); + value.At(.Tag) = new:alloc $"\"{atts.GetValueOrDefault("author")}\""; + value.At(.Name) = new:alloc $"nameof({name})"; + if (atts.TryGetValue("promotedto", let promotedto) && promotedto.StartsWith("VK_VERSION_")) + value.At(.PromotedTo) = new:alloc $".{promotedto}"; + switch (atts["type"]) + { + case "instance": value.At(.Kind) = ".Instance"; + case "device": value.At(.Kind) = ".Device"; + default: Runtime.FatalError("Unhandled ext type"); + } + command_rettype.Clear(); + if (atts.TryGetValue("depends", let depends)) + { + strBuf.Set("Self[?]("); + cdata.Clear(); + char8 lastOp = '\0'; + void Handle(char8 c) + { + mixin Version() { Runtime.Assert(command_rettype.IsEmpty); command_rettype.Set(cdata); } + mixin Extension() { strBuf.Append(cdata, ", "); } + + if (!cdata.IsEmpty) + { + bool isExtension = !cdata.StartsWith("VK_VERSION_"); + switch (c) + { + case '(': + case ')', '\0': + if (isExtension) + Extension!(); + else if (lastOp != ',') + Version!(); + case ',': + if (isExtension) + Extension!(); + case '+': + if (isExtension) + Extension!(); + else + Version!(); + } + } + lastOp = c; + cdata.Clear(); + } + for (let c in depends) + { + if (c.IsLetterOrDigit || c == '_') + { + cdata.Append(c); + continue; + } + Handle(c); + } + Handle(lastOp); + if (!strBuf.EndsWith('(')) + { + strBuf.Length -= 2; + strBuf.Append(')'); + value.At(.Dependencies) = new:alloc .(strBuf); + } + } + if (command_rettype.IsEmpty) + command_rettype.Set("VK_VERSION_1_0"); + value.At(.MinVersion) = new:alloc $".{command_rettype}"; + case "require": eStack.Add(.Require); FeatureComment(); + default: eStack.Add(.Ignore); + } + } + + append String cdata = .(1024); + public override void CharacterDataHandler(char8* s, int32 len) + { + cdata.Append(s, len); + } + + void HandleCData() + { + if (eStack.Count > 0 && eStack.Back != .Type_FuncPtr) + cdata.Trim(); + defer cdata.Clear(); + if (cdata.IsEmpty) return; + + void IfNotEmptyWriteTypePtr(String outString) + { + if (outString.IsEmpty) return; + switch (cdata) + { + case "* const *", + "* const*": cdata.Set("**"); + case "* const": cdata.Set("*"); + } + outString.Append(cdata); + } + + switch (eStack.Back) + { + case .Member: + if (cdata.StartsWith(':')) + { + fields.Back.bitfieldWidth = int.Parse(cdata[1...]..Trim()); + fields.Back.flags |= .Bitfield; + break; + } + IfNotEmptyWriteTypePtr(fields.Back.type); + case .Proto: IfNotEmptyWriteTypePtr(command_rettype); + case .Param: + if (parameters.Back.type.IsEmpty && cdata == "const") + parameters.Back.flags |= .Const; + else + IfNotEmptyWriteTypePtr(parameters.Back.type); + case .Type_Basetype: + if (basetype_variant != .Unknown) break; + if (cdata.StartsWith("#ifdef __OBJC__") || cdata.EndsWith('*')) + basetype_variant = .Handle; + else if (cdata == "struct" || cdata.StartsWith("typedef struct")) + basetype_variant = .Opaque; + else if (cdata == "typedef") + basetype_variant = .TypeAlias; + case .Type: + cdata.Set(CToBeefType(cdata)); + switch (eStack[^2]) + { + case .Member: + fields.Back.type.Append(cdata); + case .Proto: + command_rettype.Append(cdata); + case .Param: + parameters.Back.type.Append(cdata); + case .Type_Bitmask: + if (bitmask_requires.IsEmpty) + bitmask_requires.Append(cdata); + case .Type_Basetype: + if (basetype_variant == .TypeAlias) + strBuf.Append(cdata); + case .Type_FuncPtr, .Type_Handle: + strBuf.Append(cdata); + case .Type_Define: + strBuf.Append(" = ", cdata); + default: + } + case .Name: + switch (eStack[^2]) + { + case .Member: + Compiler.Identifier.GetSourceName(cdata, fields.Back.name); + case .Proto: + type_name.Append(cdata); + case .Param: + Compiler.Identifier.GetSourceName(cdata, parameters.Back.name); + case .Type_Bitmask: + type_name.Append(cdata); + strBuf.Append(cdata); + case .Type_Basetype: + type_name.Append(cdata); + switch (basetype_variant) + { + case .Unknown: Runtime.FatalError(); + case .Handle: strBuf.Append("struct ", cdata, " : int {}"); + case .Opaque: strBuf.Append("struct ", cdata, ";"); + case .TypeAlias: strBuf.Insert(0, scope $"typealias {cdata} = "); strBuf.Append(';'); + } + case .Type_Handle: + StringView type; + switch (strBuf) + { + case "VK_DEFINE_HANDLE": type = "int"; + case "VK_DEFINE_NON_DISPATCHABLE_HANDLE": type = "uint64"; + default: Runtime.FatalError("Invalid handle type"); + } + strBuf..Clear().Append("struct ", cdata, " : ", type, + "\n{\n\tpublic const VkObjectType ObjectType = .", handle_objval, + ";\n\tpublic static operator Self(decltype(null)) => VK_NULL_HANDLE;\n}"); + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + feature.name = new:alloc .(cdata); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + eStack.Back = .Ignore; + handles.Add(feature.name, new:alloc .(handle_parent)); + Metadata.vkObjectType.For(handle_objval, &feature.kind).At(.Type) = new:alloc $"typeof({feature.name})"; + case .Type_FuncPtr, .Type_Define: + type_name.Append(cdata); + strBuf.Append(cdata); + default: + } + case .Comment: + switch (eStack[^2]) + { + case .Member: + fields.Back.comment.Append(cdata); + default: + } + case .Enum: + switch (eStack[^2]) + { + case .Member: + fields.Back.type.Append(cdata); + default: + } + case .Type_FuncPtr, .Type_Define: + strBuf.Append(cdata); + default: + } + } + + public override void EndElementHandler(char8* nodeName) + { + HandleCData(); + + switch (eStack.PopBack()) + { + case .Type_Struct, .Type_Union: + PregeneratedFeature feature = new:alloc .() { kind = .HasBody }; + InitTypeFeature(feature); + + { + Dictionary dict = scope .((.)fields.Count); + for (let field in fields) + { + if (field.flags.HasFlag(.CommentOnly)) continue; + dict.Add(field.name, (0, field, null)); + if (field.length.IsEmpty) continue; + if (!dict.TryGetRef(field.length, ?, let value)) continue; + value.lens++; + value.lenField = field; + } + + for (let val in dict.Values) + { + if (val.lens != 1) continue; + val.field.flags |= .SpanNoWrite; + val.lenField.flags |= .SpanWrite; + if (val.field.flags.HasFlag(.Optional)) + val.lenField.flags |= .Optional; + + val.lenField.spanType.Set("Span<"); + val.lenField.spanType.Append(val.lenField.type); + int index; + if (val.lenField.type.EndsWith('*')) + val.lenField.spanType[^1] = '>'; + else if ({ index = val.lenField.spanType.IndexOf('['); (index >= 0) }) + val.lenField.spanType.Replace(index..., ">"); + else + Runtime.FatalError("Unhandled span type"); + + val.lenField.spanName.Set(val.lenField.name); + val.lenField.spanName.TrimStart('p'); + val.lenField.spanName[0] = val.lenField.spanName[0].ToLower; + if (Compiler.Identifier.sReservedNameSet.Contains(val.lenField.spanName)) + val.lenField.spanName.Insert(0, '@'); + if (val.lenField.spanName == val.lenField.name) + val.lenField.spanName.Append("Span"); + } + } + + strBuf.Clear(); + switch (_) + { + case .Type_Struct: strBuf.Append("[CRepr]"); + case .Type_Union: strBuf.Append("[CRepr, Union]"); + default: Runtime.FatalError(); + } + strBuf.Append(" struct ", type_name, " : this()\n{\n"); + int bitfieldBits = 0; + field: for (let field in fields) + { + if (field.flags.HasFlag(.CommentOnly)) + { + strBuf.Append('\t'); + WriteComment(field.comment, strBuf); + strBuf.Append('\n'); + continue; + } + + String constField = null; + if (!field.values.IsEmpty) + { + constField = scope:field .(field.name); + constField[0] = constField[0].ToUpper; + strBuf.Append("\tpublic const ", field.type, " ", constField, " = .", field.values, ";\n"); + + if (constField == "SType") + Metadata.vkStructureType.For(field.values, &feature.kind).At(.Type) = new:alloc $"typeof({type_name})"; + } + + if (field.flags.HasFlag(.Bitfield)) + { + strBuf.AppendF($"\t[Bitfield(.Public, .Bits({field.bitfieldWidth}), \"{field.name}\")]\n"); + bitfieldBits += field.bitfieldWidth; + int typeWidth; + switch (field.type) + { + case "int8", "uint8": typeWidth = 8; + case "int16", "uint16": typeWidth = 16; + case "int32", "uint32": typeWidth = 32; + case "int64", "uint64": typeWidth = 64; + case "VkGeometryInstanceFlagsKHR": typeWidth = 32; field.type.Set("VkFlags"); + default: Runtime.FatalError("Unhandled bitfield type"); + } + if (bitfieldBits >= typeWidth) + { + strBuf.Append("\tprivate ", field.type, " __bitfields_", field.name, " = 0;\n"); + bitfieldBits -= typeWidth; + } + continue; + } + + strBuf.Append("\tpublic ", field.type, " ", field.name); + if (field.values.IsEmpty) + strBuf.Append(" = ", DefaultValueForType(field.type)); + else + strBuf.Append(" = ", constField); + strBuf.Append(';'); + if (!field.comment.IsEmpty) + { + strBuf.Append(' '); + WriteComment(field.comment, strBuf); + } + strBuf.Append('\n'); + + if (field.flags.HasFlag(.SpanWrite)) + { + if (field.type.EndsWith(']')) + strBuf.Append("\tpublic ", field.spanType, " ", field.spanName, + "\n\t{\n\t\tget mut { return .(&", field.name, ", (.)", field.length, "); }\n" + + "\t\tset mut { value.CopyTo(", field.name, "); ", field.length, " = (.)value.Length; }\n\t}\n"); + else if (field.type.EndsWith('*')) + strBuf.Append("\tpublic ", field.spanType, " ", field.spanName, + "\n\t{\n\t\tget { return .(", field.name, ", (.)", field.length, "); }\n" + + "\t\tset mut { ", field.name, " = value.Ptr; ", field.length, " = (.)value.Length; }\n\t}\n"); + else + Runtime.FatalError("Unhandled span type"); + } + } + if (bitfieldBits != 0) + strBuf.Append("\tprivate uint32 __bitfields_remainder = 0;\n"); + + if (!struct_returnOnly) + { + int optionalFrom = fields.Count; + repeat optionalFrom--; while (optionalFrom >= 0 && fields[optionalFrom].flags.HasFlag(.Optional)); + + mixin Exclude(Field field) + { + if (!field.values.IsEmpty || + field.flags & (.CommentOnly | .SpanNoWrite) != 0) + continue; + field.flags.HasFlag(.SpanWrite) ? + (field.spanName, field.spanType) : + (field.name, field.type) + } + + strBuf.Append("\n\tpublic this("); + for (let field in fields) + { + (let name, let type) = Exclude!(field); + strBuf.Append(type, " ", name); + if (@field.Index > optionalFrom) + strBuf.Append(" = ", DefaultValueForType(type)); + strBuf.Append(", "); + } + strBuf.Length -= 2; + strBuf.Append(") : this()\n\t{\n"); + for (let field in fields) + { + let name = Exclude!(field).0; + strBuf.Append("\t\tthis.", name.StartsWith('@') ? name[1...] : name, " = ", name, ";\n"); + } + strBuf.Append("\t}\n"); + } + + strBuf.Append('}'); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + + fields.Clear(); + fieldBufferIdx = -1; + case .Type_Bitmask: + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + InitTypeFeature(feature); + strBuf.Append(" = ", bitmask_requires, ";"); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + case .Type_Basetype: + if (type_name == "VkBool32") break; + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + InitTypeFeature(feature); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + case .Type_Define: + if (String[?]("VK_USE_64_BIT_PTR_DEFINES", "VK_DEFINE_HANDLE", "VK_NULL_HANDLE", "VK_DEFINE_NON_DISPATCHABLE_HANDLE").Contains(type_name)) break; + PregeneratedFeature feature = new:alloc .() { kind = .TypeAlias }; + InitTypeFeature(feature); + if (type_name == "VK_HEADER_VERSION") + { + int i; + for (i = strBuf.Length-1; i >= 0 && strBuf[i].IsDigit; i--) {} + strBuf.Insert(i+1, " = "); + } + close: do + { + for (int i = strBuf.Length-2; i >= 0; i--) + { + if (strBuf[i] == '\n') break; + if (strBuf[i...i+1] != "//") continue; + strBuf.Insert(i, "; }"); + break close; + } + strBuf.Append("; }"); + } + if (strBuf.Contains("(version)")) + { + strBuf.Replace("#define", "static { public static uint32 "); + strBuf.Replace("(version) (", "(uint32 version) => ("); + strBuf.Replace("(uint32_t)", "(uint32)"); + } + else if (strBuf.Contains("major, minor, patch)")) + { + strBuf.Replace("#define", "static { public static uint32 "); + strBuf.Replace("(variant, major, minor, patch) \\", "(uint32 variant, uint32 major, uint32 minor, uint32 patch) =>"); + strBuf.Replace("(major, minor, patch) \\", "(uint32 major, uint32 minor, uint32 patch) =>"); + strBuf.Replace("(uint32_t)", "(uint32)"); + } + 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); + vkTypes.Add(feature.name, feature); + case .Type_FuncPtr: + PregeneratedFeature feature = new:alloc .() { kind = .HasBody }; + InitTypeFeature(feature); + strBuf.Replace("const ", ""); + strBuf.Replace("(VKAPI_PTR *", ""); + strBuf.Replace(")(", "("); + strBuf.Remove(0, "typedef".Length); + strBuf.Insert(0, "[CallingConvention(VKAPI_PTR)] function"); + feature.content = new:alloc .(strBuf); + vkTypes.Add(feature.name, feature); + case .Command: + CommandFeature feature = new:alloc .() { kind = .Command }; + InitTypeFeature(feature); + strBuf.Set("[CallingConvention(VKAPI_PTR)] function "); + strBuf.Append(command_rettype, " PFN_", type_name, "("); + + Param lastParam = null; + bool hasOutArray = false; + for (let param in parameters) + { + 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) + { + lastParam.flags |= .OutArrayLen; + param.flags |= .OutArrayPtr; + hasOutArray = true; + continue; + } + if (lastParam?.flags.HasFlag(.OutArrayPtr) == true) + { + param.flags |= .OutArrayPtr; + continue; + } + param.type.Length--; + param.type.Insert(0, "out "); + param.call.Insert(0, "out "); + param.flags |= .OutParam; + param.flags &= ~.Optional; + } + + int optionalFrom = parameters.Count; + repeat optionalFrom--; while (optionalFrom >= 0 && parameters[optionalFrom].flags.HasFlag(.Optional)); + + for (let param in parameters) + { + if (@param.Index != 0) strBuf.Append(", "); + strBuf.Append(param.type, " ", param.name); + if (@param.Index > optionalFrom) + strBuf.Append(" = ", DefaultValueForType(param.type)); + } + + strBuf.Append(");"); + feature.content = new:alloc .(strBuf); + + int handleIndex = -1; + handle: do + { + String handle = scope .(128); + for (let param in parameters) + { + if (!handles.TryGet(param.type, let paramHandle, let paramHandleParent)) break; + if (!handle.IsEmpty && handle != paramHandleParent) break; + handle.Set(paramHandle); + handleIndex = @param.Index; + } + feature.handle = new:alloc .(handle); + repeat + { + switch (handle) + { + case "": feature.category = .None; + case "VkInstance": feature.category = .Instance; + case "VkDevice": feature.category = .Device; + default: continue; + } + break handle; + } + while (handles.TryGetValue(handle, out handle)); + Runtime.FatalError("Unhandled function handle"); + } + + strBuf.Clear(); + strBuf.Append("\t[Inline] public static ", command_rettype, " "); + int rangeStart = strBuf.Length; + WriteCommandPrettyName(type_name, feature.handle, strBuf); + feature.spellingRange = rangeStart.. optionalFrom) + strBuf.Append(" = ", DefaultValueForType(param.type)); + } + strBuf.Append(") => VulkanLoadedFunctions.current."); + rangeStart = strBuf.Length; + strBuf.Append(type_name); + feature.callRange = rangeStart.. optionalFrom) + strBuf.Append(" = ", DefaultValueForType(param.type)); + } + strBuf.Append("{1})\n\t{{\n"); + bool result; StringView inIfIndent; + switch (command_rettype) + { + case "void": result = false; inIfIndent = "\t\t"; + case "VkResult": result = true; inIfIndent = "\t\t\t"; + default: Runtime.FatalError("Unhandled out array rettype"); + } + strBuf.Append("\t\t"); + if (result) strBuf.Append("VkResult result = "); + strBuf.Append(thisDot, spelling, "("); + writeComma = false; + for (let param in parameters) + { + int idx = @param.Index; + if (idx == handleIndex) continue; + if (writeComma) strBuf.Append(", "); + writeComma = true; + + if (param.flags.HasFlag(.OutArrayLen)) + strBuf.Append("var ", param.name); + else if (param.flags.HasFlag(.OutArrayPtr)) + strBuf.Append("null"); + else + strBuf.Append(param.call); + } + strBuf.Append(");\n"); + if (result) + strBuf.Append(""" + if (result == .VkSuccess) + {{ + + """); + for (let param in parameters) + { + if (!param.flags.HasFlag(.OutArrayPtr)) continue; + strBuf.Append(inIfIndent, param.name, " = {2} .[", param.length, "];\n"); + } + strBuf.Append(inIfIndent); + if (result) strBuf.Append("result = "); + strBuf.Append(thisDot, spelling, "("); + writeComma = false; + for (let param in parameters) + { + int idx = @param.Index; + if (idx == handleIndex) continue; + if (writeComma) strBuf.Append(", "); + writeComma = true; + + if (param.flags.HasFlag(.OutArrayPtr)) + strBuf.Append(param.name, ".Ptr"); + else + strBuf.Append(param.call); + } + strBuf.Append(");\n"); + if (result) + { + strBuf.Append(""" + }} + else + {{ + + """); + for (let param in parameters) + { + if (!param.flags.HasFlag(.OutArrayPtr)) continue; + strBuf.Append("\t\t\t", param.name, " = null;\n"); + } + strBuf.Append(""" + }} + result + + """); + } + strBuf.Append("\t}}\n"); + feature.mixinOutArrayFmt = new:alloc .(strBuf); + } + + vkCommands.Add(feature.name, feature); + default: + } + } + + static void WriteCommandPrettyName(StringView name, StringView handle, String outString) + { + if (!handle.IsEmpty) + { + String newName = scope .(name); + var self = handle; + self.RemoveFromStart(2); + for (let tag in tags) + if (self.EndsWith(tag)) + self.RemoveFromEnd(tag.Length); + newName.Replace(self, ""); + if (handle == "VkCommandBuffer") + newName.Replace("vkCmd", ""); + if (newName.StartsWith("vk")) + newName.Remove(0, 2); + outString.Append(newName); + } + else + outString.Append(name); + } +} + +class Program +{ + public static int Main(String[] args) + { + StringView vkXml = @"C:\VulkanSDK\1.4.335.0\share\vulkan\registry\vk.xml"; + StringView videoXml = @"C:\VulkanSDK\1.4.335.0\share\vulkan\registry\video.xml"; + + alloc = scope .(); + vkTypes = scope .(1024 * 15); + vkCommands = scope .(1024); + tags = scope .(48); + handles = scope .(64); + vulkanBf = scope .(1024 * 15); + videoBf = scope .(1024 * 2); + + void ParseRegistry(StringView path, List output) + { + RegistryParser parser = scope .(output); + parser.ParserInitResult.Get(); + UnbufferedFileStream stream = scope .()..Open(path, .Read, .Read); + uint8[4096] buffer = .(); + read: while (true) + switch (stream.TryRead(.(&buffer, buffer.Count))) + { + case .Ok(let val): + parser.Parse((.)&buffer, (.)val, isFinal: (.)(val == 0 ? XML.TRUE : XML.FALSE)); + if (val == 0) break read; + case .Err: + Runtime.FatalError("Failed to read from file"); + } + } + + ParseRegistry(vkXml, vulkanBf); + ParseRegistry(videoXml, videoBf); + + void WriteOutput(List output, StreamWriter writer) + { + VulkanFeature.Kind lastKind = .Invalid; + String strBuffer = scope .(1024); + for (let feature in output) + { + if (feature.kind == .AlreadyWritten) continue; + switch (lastKind) + { + case .Invalid: + case .Comment: + case .HasBody: + strBuffer.Append('\n'); + case .Command, .TypeAlias, .Constant: + if (feature.kind != _) strBuffer.Append('\n'); + case .AlreadyWritten: + Runtime.FatalError(); + } + lastKind = feature.kind; + feature.Write(strBuffer); + writer.Write(strBuffer); + strBuffer.Clear(); + } + } + + { + StreamWriter writer = scope .()..Create("../src/Vulkan.bf"); + writer.Write(""" + // This file was generated by Setup/Program.bf + // Based on vk.xml + + using System; + using System.Interop; + + using Vulkan.Video; + using Vulkan.External; + + namespace Vulkan; + + + """); + WriteOutput(vulkanBf, writer); + } + + { + StreamWriter writer = scope .()..Create("../src/Video.bf"); + writer.Write(""" + // This file was generated by Setup/Program.bf + // Based on video.xml + + using System; + using System.Interop; + + using Vulkan; + + namespace Vulkan.Video; + + + """); + WriteOutput(videoBf, writer); + } + + { + StreamWriter writer = scope .()..Create("../src/Loader.bf"); + writer.Write(""" + // This file was generated by Setup/Program.bf + + using System; + using System.Interop; + + using Vulkan; + using Vulkan.Video; + using Vulkan.External; + using Vulkan.Loader; + + namespace Vulkan.Loader; + + struct VulkanLoadedFunctions + { + public static Self* current; + + + """); + String str = scope .(1024); + for (let cmd in vkCommands) + { + if (cmd.value.kind != .AlreadyWritten) continue; + str.Clear(); + str.Append("\tpublic PFN_", cmd.key, " ", cmd.key, ";\n"); + writer.Write(str); + } + writer.Write(""" + + public void Load(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) mut + { + this.vkGetInstanceProcAddr = vkGetInstanceProcAddr; + + """); + void LoadFunc(StringView getProc, StringView param, CommandFeature.Category category) + { + for (let cmd in vkCommands) + { + if (cmd.value.kind != .AlreadyWritten || cmd.value.category != category) continue; + str.Clear(); + str.Append("\t\t", cmd.key, " = (.)(void*)", getProc, "(", param, ", nameof(", cmd.key, "));\n"); + writer.Write(str); + } + } + LoadFunc("vkGetInstanceProcAddr", "null", .None); + writer.Write(""" + } + + public void LoadInstance(VkInstance instance) mut + { + + """); + LoadFunc("vkGetInstanceProcAddr", "instance", .Instance); + writer.Write(""" + } + + public void LoadDevice(VkDevice device) mut + { + + """); + LoadFunc("vkGetDeviceProcAddr", "device", .Device); + writer.Write(""" + } + + public void LoadTrampoline(VkInstance instance) mut + { + + """); + LoadFunc("vkGetInstanceProcAddr", "instance", .Instance); + LoadFunc("vkGetInstanceProcAddr", "instance", .Device); + writer.Write(""" + } + } + + static + { + + """); + for (let cmd in vkCommands) + { + if (cmd.value.kind != .AlreadyWritten) continue; + writer.Write(cmd.value.prettyExecute); + } + writer.Write(""" + } + + namespace Vulkan; + """); + String curHandle = null; + for (let cmd in vkCommands) + { + if (cmd.value.kind != .AlreadyWritten || cmd.value.mixinOutArrayFmt == null) continue; + str.Clear(); + if (cmd.value.handle != curHandle) + { + if (curHandle != null) str.Append('}'); + if (cmd.value.handle.IsEmpty) + str.Append("\n\nstatic"); + else + str.Append("\n\nextension ", cmd.value.handle); + str.Append("\n{\n"); + curHandle = cmd.value.handle; + } + else + str.Append('\n'); + str.AppendF(cmd.value.mixinOutArrayFmt, "Scope", "", "scope:mixin"); writer.Write(str); str.Clear(); + str.AppendF(cmd.value.mixinOutArrayFmt, "New", "", "new"); writer.Write(str); str.Clear(); + str.AppendF(cmd.value.mixinOutArrayFmt, "New", ", IRawAllocator alloc", "new:alloc"); writer.Write(str); + } + writer.Write(""" + } + + """); + } + + { + StreamWriter writer = scope .()..Create("../src/Metadata.bf"); + writer.Write(""" + // This file was generated by Setup/Program.bf + + using System; + using System.Interop; + + using Vulkan; + + namespace Vulkan.Metadata; + + + """); + String strBuffer = scope .(1024); + Metadata.apiVersion.WriteToStream(strBuffer, writer, "enum VulkanApiVersion", + (null, .Cases)); + Metadata.extensions.WriteToStream(strBuffer, writer, "enum VulkanExtension", + (null, .Cases), + ("public String Name", .Property), + ("public String Tag", .Property), + ("public Kind Kind", .Property), + ("public VulkanApiVersion MinVersion", .Property), + ("public VulkanApiVersion PromotedTo", .Property), + ("public Span Dependencies", .Property)); + writer.Write(""" + namespace Vulkan; + + + """); + Metadata.vkStructureType.WriteToStream(strBuffer, writer, "extension VkStructureType", + ("public Type Type", .Property)); + Metadata.vkObjectType.WriteToStream(strBuffer, writer, "extension VkObjectType", + ("public Type Type", .Property)); + } + + return 0; + } +} \ No newline at end of file diff --git a/src/Library.bf b/src/Library.bf new file mode 100644 index 0000000..9eba61b --- /dev/null +++ b/src/Library.bf @@ -0,0 +1,63 @@ +// This file is NOT auto-generated + +using System; +using System.Interop; + +namespace Vulkan; + +struct VkBool32 : uint32 +{ + public static operator bool(Self b) => b != VK_FALSE; + public static operator Self(bool b) => b ? VK_TRUE : VK_FALSE; +} + +static +{ + public const CallingConventionAttribute.Kind VKAPI_PTR = +#if BF_PLATFORM_WINDOWS + .Stdcall; +#else + .Cdecl; +#endif + + public const let VK_NULL_HANDLE = 0; +} + +namespace Vulkan.Metadata; + +extension VulkanExtension +{ + public enum Kind { Instance, Device } +} + +namespace Vulkan.External; + +struct Display; +struct VisualID; +struct Window : uint32 {} +struct RROutput; +struct wl_display; +struct wl_surface; +struct HINSTANCE : int {} +struct HWND : int {} +struct HMONITOR : int {} +struct HANDLE : int {} +struct SECURITY_ATTRIBUTES; +typealias DWORD = int32; +typealias LPCWSTR = c_wchar*; +struct xcb_connection_t; +struct xcb_visualid_t; +struct xcb_window_t : uint32 {} +struct IDirectFB; +struct IDirectFBSurface; +struct zx_handle_t : int {} +struct GgpStreamDescriptor { /* this struct is propritary, so we don't know it's size */ } +typealias GgpFrameToken = uint32; +struct _screen_context; +struct _screen_window; +struct _screen_buffer; +struct NvSciSyncAttrList; +struct NvSciSyncObj; +struct NvSciSyncFence; +struct NvSciBufAttrList; +struct NvSciBufObj; diff --git a/src/Loader.bf b/src/Loader.bf new file mode 100644 index 0000000..f5bda82 --- /dev/null +++ b/src/Loader.bf @@ -0,0 +1,5451 @@ +// This file was generated by Setup/Program.bf + +using System; +using System.Interop; + +using Vulkan; +using Vulkan.Video; +using Vulkan.External; +using Vulkan.Loader; + +namespace Vulkan.Loader; + +struct VulkanLoadedFunctions +{ + public static Self* current; + + public PFN_vkCreateInstance vkCreateInstance; + public PFN_vkDestroyInstance vkDestroyInstance; + public PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; + public PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; + public PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; + public PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; + public PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; + public PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; + public PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; + public PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; + public PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; + public PFN_vkCreateDevice vkCreateDevice; + public PFN_vkDestroyDevice vkDestroyDevice; + public PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; + public PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; + public PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; + public PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties; + public PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; + public PFN_vkGetDeviceQueue vkGetDeviceQueue; + public PFN_vkQueueSubmit vkQueueSubmit; + public PFN_vkQueueWaitIdle vkQueueWaitIdle; + public PFN_vkDeviceWaitIdle vkDeviceWaitIdle; + public PFN_vkAllocateMemory vkAllocateMemory; + public PFN_vkFreeMemory vkFreeMemory; + public PFN_vkMapMemory vkMapMemory; + public PFN_vkUnmapMemory vkUnmapMemory; + public PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; + public PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; + public PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; + public PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; + public PFN_vkBindBufferMemory vkBindBufferMemory; + public PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; + public PFN_vkBindImageMemory vkBindImageMemory; + public PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; + public PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties; + public PFN_vkQueueBindSparse vkQueueBindSparse; + public PFN_vkCreateFence vkCreateFence; + public PFN_vkDestroyFence vkDestroyFence; + public PFN_vkResetFences vkResetFences; + public PFN_vkGetFenceStatus vkGetFenceStatus; + public PFN_vkWaitForFences vkWaitForFences; + public PFN_vkCreateSemaphore vkCreateSemaphore; + public PFN_vkDestroySemaphore vkDestroySemaphore; + public PFN_vkCreateEvent vkCreateEvent; + public PFN_vkDestroyEvent vkDestroyEvent; + public PFN_vkGetEventStatus vkGetEventStatus; + public PFN_vkSetEvent vkSetEvent; + public PFN_vkResetEvent vkResetEvent; + public PFN_vkCreateQueryPool vkCreateQueryPool; + public PFN_vkDestroyQueryPool vkDestroyQueryPool; + public PFN_vkGetQueryPoolResults vkGetQueryPoolResults; + public PFN_vkResetQueryPool vkResetQueryPool; + public PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT; + public PFN_vkCreateBuffer vkCreateBuffer; + public PFN_vkDestroyBuffer vkDestroyBuffer; + public PFN_vkCreateBufferView vkCreateBufferView; + public PFN_vkDestroyBufferView vkDestroyBufferView; + public PFN_vkCreateImage vkCreateImage; + public PFN_vkDestroyImage vkDestroyImage; + public PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; + public PFN_vkCreateImageView vkCreateImageView; + public PFN_vkDestroyImageView vkDestroyImageView; + public PFN_vkCreateShaderModule vkCreateShaderModule; + public PFN_vkDestroyShaderModule vkDestroyShaderModule; + public PFN_vkCreatePipelineCache vkCreatePipelineCache; + public PFN_vkDestroyPipelineCache vkDestroyPipelineCache; + public PFN_vkGetPipelineCacheData vkGetPipelineCacheData; + public PFN_vkMergePipelineCaches vkMergePipelineCaches; + public PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR; + public PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR; + public PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR; + public PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR; + public PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR; + public PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; + public PFN_vkCreateComputePipelines vkCreateComputePipelines; + public PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + public PFN_vkDestroyPipeline vkDestroyPipeline; + public PFN_vkCreatePipelineLayout vkCreatePipelineLayout; + public PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; + public PFN_vkCreateSampler vkCreateSampler; + public PFN_vkDestroySampler vkDestroySampler; + public PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; + public PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; + public PFN_vkCreateDescriptorPool vkCreateDescriptorPool; + public PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; + public PFN_vkResetDescriptorPool vkResetDescriptorPool; + public PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; + public PFN_vkFreeDescriptorSets vkFreeDescriptorSets; + public PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; + public PFN_vkCreateFramebuffer vkCreateFramebuffer; + public PFN_vkDestroyFramebuffer vkDestroyFramebuffer; + public PFN_vkCreateRenderPass vkCreateRenderPass; + public PFN_vkDestroyRenderPass vkDestroyRenderPass; + public PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; + public PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity; + public PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR; + public PFN_vkCreateCommandPool vkCreateCommandPool; + public PFN_vkDestroyCommandPool vkDestroyCommandPool; + public PFN_vkResetCommandPool vkResetCommandPool; + public PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; + public PFN_vkFreeCommandBuffers vkFreeCommandBuffers; + public PFN_vkBeginCommandBuffer vkBeginCommandBuffer; + public PFN_vkEndCommandBuffer vkEndCommandBuffer; + public PFN_vkResetCommandBuffer vkResetCommandBuffer; + public PFN_vkCmdBindPipeline vkCmdBindPipeline; + public PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT; + public PFN_vkCmdSetViewport vkCmdSetViewport; + public PFN_vkCmdSetScissor vkCmdSetScissor; + public PFN_vkCmdSetLineWidth vkCmdSetLineWidth; + public PFN_vkCmdSetDepthBias vkCmdSetDepthBias; + public PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; + public PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; + public PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; + public PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; + public PFN_vkCmdSetStencilReference vkCmdSetStencilReference; + public PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; + public PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; + public PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; + public PFN_vkCmdDraw vkCmdDraw; + public PFN_vkCmdDrawIndexed vkCmdDrawIndexed; + public PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; + public PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; + public PFN_vkCmdDrawIndirect vkCmdDrawIndirect; + public PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; + public PFN_vkCmdDispatch vkCmdDispatch; + public PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; + public PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI; + public PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI; + public PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI; + public PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV; + public PFN_vkCmdCopyBuffer vkCmdCopyBuffer; + public PFN_vkCmdCopyImage vkCmdCopyImage; + public PFN_vkCmdBlitImage vkCmdBlitImage; + public PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; + public PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; + public PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV; + public PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR; + public PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV; + public PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR; + public PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; + public PFN_vkCmdFillBuffer vkCmdFillBuffer; + public PFN_vkCmdClearColorImage vkCmdClearColorImage; + public PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; + public PFN_vkCmdClearAttachments vkCmdClearAttachments; + public PFN_vkCmdResolveImage vkCmdResolveImage; + public PFN_vkCmdSetEvent vkCmdSetEvent; + public PFN_vkCmdResetEvent vkCmdResetEvent; + public PFN_vkCmdWaitEvents vkCmdWaitEvents; + public PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; + public PFN_vkCmdBeginQuery vkCmdBeginQuery; + public PFN_vkCmdEndQuery vkCmdEndQuery; + public PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; + public PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; + public PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT; + public PFN_vkCmdResetQueryPool vkCmdResetQueryPool; + public PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; + public PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; + public PFN_vkCmdPushConstants vkCmdPushConstants; + public PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; + public PFN_vkCmdNextSubpass vkCmdNextSubpass; + public PFN_vkCmdEndRenderPass vkCmdEndRenderPass; + public PFN_vkCmdExecuteCommands vkCmdExecuteCommands; + public PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; + public PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS; + public PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; + public PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; + public PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; + public PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; + public PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR; + public PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; + public PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; + public PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; + public PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; + public PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; + public PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + public PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; + public PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; + public PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; + public PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; + public PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; + public PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; + public PFN_vkQueuePresentKHR vkQueuePresentKHR; + public PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; + public PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; + public PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; + public PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; + public PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; + public PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; + public PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; + public PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; + public PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; + public PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; + public PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; + public PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; + public PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; + public PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; + public PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX; + public PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT; + public PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT; + public PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT; + public PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; + public PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; + public PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT; + public PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT; + public PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT; + public PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + public PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; + public PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV; + public PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV; + public PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV; + public PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV; + public PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV; + public PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV; + public PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT; + public PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT; + public PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT; + public PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT; + public PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT; + public PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT; + public PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT; + public PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT; + public PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT; + public PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2; + public PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR; + public PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; + public PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR; + public PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2; + public PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR; + public PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2; + public PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR; + public PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2; + public PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR; + public PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2; + public PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR; + public PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2; + public PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + public PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet; + public PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; + public PFN_vkTrimCommandPool vkTrimCommandPool; + public PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; + public PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties; + public PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR; + public PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; + public PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; + public PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; + public PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; + public PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA; + public PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA; + public PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV; + public PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties; + public PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + public PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; + public PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; + public PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; + public PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; + public PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA; + public PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA; + public PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties; + public PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR; + public PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; + public PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; + public PFN_vkGetFenceFdKHR vkGetFenceFdKHR; + public PFN_vkImportFenceFdKHR vkImportFenceFdKHR; + public PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT; + public PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; + public PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; + public PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; + public PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; + public PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT; + public PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT; + public PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT; + public PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT; + public PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT; + public PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups; + public PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR; + public PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; + public PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR; + public PFN_vkBindBufferMemory2 vkBindBufferMemory2; + public PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; + public PFN_vkBindImageMemory2 vkBindImageMemory2; + public PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; + public PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; + public PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR; + public PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; + public PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR; + public PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; + public PFN_vkCmdDispatchBase vkCmdDispatchBase; + public PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR; + public PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR; + public PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; + public PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR; + public PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; + public PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR; + public PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; + public PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR; + public PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate; + public PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; + public PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT; + public PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR; + public PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; + public PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; + public PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; + public PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; + public PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; + public PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV; + public PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; + public PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT; + public PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT; + public PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; + public PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT; + public PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR; + public PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR; + public PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR; + public PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR; + public PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR; + public PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR; + public PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; + public PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR; + public PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; + public PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR; + public PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; + public PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR; + public PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; + public PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR; + public PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; + public PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR; + public PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; + public PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR; + public PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; + public PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR; + public PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; + public PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR; + public PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; + public PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT; + public PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT; + public PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT; + public PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT; + public PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; + public PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; + public PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD; + public PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD; + public PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + public PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + public PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR; + public PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; + public PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT; + public PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT; + public PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT; + public PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT; + public PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT; + public PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT; + public PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT; + public PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT; + public PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT; + public PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT; + public PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT; + public PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; + public PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD; + public PFN_vkCreateRenderPass2 vkCreateRenderPass2; + public PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR; + public PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; + public PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; + public PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; + public PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR; + public PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; + public PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; + public PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; + public PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; + public PFN_vkWaitSemaphores vkWaitSemaphores; + public PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; + public PFN_vkSignalSemaphore vkSignalSemaphore; + public PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; + public PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; + public PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; + public PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; + public PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR; + public PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD; + public PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; + public PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR; + public PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD; + public PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV; + public PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV; + public PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; + public PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; + public PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; + public PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; + public PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; + public PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; + public PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV; + public PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV; + public PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV; + public PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV; + public PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV; + public PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV; + public PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV; + public PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV; + public PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT; + public PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT; + public PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT; + public PFN_vkCompileDeferredNV vkCompileDeferredNV; + public PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV; + public PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI; + public PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR; + public PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV; + public PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV; + public PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV; + public PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV; + public PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR; + public PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR; + public PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR; + public PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR; + public PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR; + public PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR; + public PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR; + public PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV; + public PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV; + public PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR; + public PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR; + public PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV; + public PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR; + public PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV; + public PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + public PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV; + public PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV; + public PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR; + public PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + public PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR; + public PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR; + public PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV; + public PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV; + public PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR; + public PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR; + public PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR; + public PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX; + public PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX; + public PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX; + public PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; + public PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; + public PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; + public PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; + public PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; + public PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; + public PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; + public PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; + public PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; + public PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; + public PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; + public PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; + public PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; + public PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT; + public PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT; + public PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + public PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL; + public PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL; + public PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL; + public PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL; + public PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL; + public PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL; + public PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL; + public PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL; + public PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL; + public PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; + public PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; + public PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; + public PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR; + public PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; + public PFN_vkCmdSetLineStipple vkCmdSetLineStipple; + public PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR; + public PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; + public PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties; + public PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT; + public PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; + public PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR; + public PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR; + public PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR; + public PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR; + public PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR; + public PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR; + public PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR; + public PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR; + public PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR; + public PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV; + public PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV; + public PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD; + public PFN_vkCmdSetCullMode vkCmdSetCullMode; + public PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT; + public PFN_vkCmdSetFrontFace vkCmdSetFrontFace; + public PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT; + public PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; + public PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; + public PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; + public PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT; + public PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; + public PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT; + public PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2; + public PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR; + public PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; + public PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT; + public PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; + public PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT; + public PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; + public PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT; + public PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; + public PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT; + public PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; + public PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT; + public PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; + public PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT; + public PFN_vkCmdSetStencilOp vkCmdSetStencilOp; + public PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT; + public PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; + public PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; + public PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT; + public PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; + public PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT; + public PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; + public PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; + public PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; + public PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; + public PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; + public PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; + public PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; + public PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; + public PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; + public PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; + public PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; + public PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; + public PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; + public PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; + public PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; + public PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; + public PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; + public PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; + public PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; + public PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; + public PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; + public PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; + public PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; + public PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; + public PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; + public PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; + public PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; + public PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; + public PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; + public PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; + public PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; + public PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; + public PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; + public PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; + public PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot; + public PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT; + public PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot; + public PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT; + public PFN_vkSetPrivateData vkSetPrivateData; + public PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; + public PFN_vkGetPrivateData vkGetPrivateData; + public PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; + public PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; + public PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR; + public PFN_vkCmdCopyImage2 vkCmdCopyImage2; + public PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR; + public PFN_vkCmdBlitImage2 vkCmdBlitImage2; + public PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR; + public PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; + public PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR; + public PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; + public PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR; + public PFN_vkCmdResolveImage2 vkCmdResolveImage2; + public PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR; + public PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; + public PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR; + public PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; + public PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR; + public PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; + public PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; + public PFN_vkCmdSetEvent2 vkCmdSetEvent2; + public PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; + public PFN_vkCmdResetEvent2 vkCmdResetEvent2; + public PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR; + public PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; + public PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR; + public PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; + public PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR; + public PFN_vkQueueSubmit2 vkQueueSubmit2; + public PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR; + public PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; + public PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR; + public PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD; + public PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV; + public PFN_vkCopyMemoryToImage vkCopyMemoryToImage; + public PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT; + public PFN_vkCopyImageToMemory vkCopyImageToMemory; + public PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT; + public PFN_vkCopyImageToImage vkCopyImageToImage; + public PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT; + public PFN_vkTransitionImageLayout vkTransitionImageLayout; + public PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT; + public PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; + public PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; + public PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; + public PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; + public PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; + public PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; + public PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; + public PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR; + public PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; + public PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; + public PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; + public PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; + public PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; + public PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; + public PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; + public PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR; + public PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV; + public PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV; + public PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV; + public PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV; + public PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT; + public PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT; + public PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX; + public PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX; + public PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX; + public PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX; + public PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX; + public PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT; + public PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT; + public PFN_vkGetDescriptorEXT vkGetDescriptorEXT; + public PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT; + public PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT; + public PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT; + public PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT; + public PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT; + public PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT; + public PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT; + public PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + public PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; + public PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT; + public PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT; + public PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR; + public PFN_vkWaitForPresentKHR vkWaitForPresentKHR; + public PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA; + public PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA; + public PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA; + public PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA; + public PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA; + public PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV; + public PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV; + public PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV; + public PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV; + public PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV; + public PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV; + public PFN_vkCmdBeginRendering vkCmdBeginRendering; + public PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR; + public PFN_vkCmdEndRendering vkCmdEndRendering; + public PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR; + public PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT; + public PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR; + public PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; + public PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; + public PFN_vkCreateMicromapEXT vkCreateMicromapEXT; + public PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; + public PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; + public PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; + public PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; + public PFN_vkCopyMicromapEXT vkCopyMicromapEXT; + public PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; + public PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; + public PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; + public PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; + public PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; + public PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; + public PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; + public PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; + public PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; + public PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; + public PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2; + public PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR; + public PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; + public PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT; + public PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT; + public PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM; + public PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; + public PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; + public PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + public PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; + public PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; + public PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; + public PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; + public PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; + public PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT; + public PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR; + public PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT; + public PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout; + public PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR; + public PFN_vkMapMemory2 vkMapMemory2; + public PFN_vkMapMemory2KHR vkMapMemory2KHR; + public PFN_vkUnmapMemory2 vkUnmapMemory2; + public PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR; + public PFN_vkCreateShadersEXT vkCreateShadersEXT; + public PFN_vkDestroyShaderEXT vkDestroyShaderEXT; + public PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT; + public PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT; + public PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT; + public PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT; + public PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT; + public PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT; + public PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX; + public PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; + public PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX; + public PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX; + public PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX; + public PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX; + public PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX; + public PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX; + public PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX; + public PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2; + public PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR; + public PFN_vkCmdPushConstants2 vkCmdPushConstants2; + public PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR; + public PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2; + public PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR; + public PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2; + public PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR; + public PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT; + public PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; + public PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV; + public PFN_vkLatencySleepNV vkLatencySleepNV; + public PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV; + public PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV; + public PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV; + public PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations; + public PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR; + public PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices; + public PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR; + public PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT; + public PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV; + public PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT; + public PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT; + public PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV; + public PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV; + public PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV; + public PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM; + public PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM; + public PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM; + public PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV; + public PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV; + public PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV; + public PFN_vkCreateTensorARM vkCreateTensorARM; + public PFN_vkDestroyTensorARM vkDestroyTensorARM; + public PFN_vkCreateTensorViewARM vkCreateTensorViewARM; + public PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM; + public PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM; + public PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM; + public PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM; + public PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM; + public PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM; + public PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM; + public PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM; + public PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM; + public PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM; + public PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM; + public PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM; + public PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM; + public PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM; + public PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM; + public PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM; + public PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM; + public PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM; + public PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM; + public PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS; + public PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS; + public PFN_vkGetSwapchainGrallocUsageOHOS vkGetSwapchainGrallocUsageOHOS; + public PFN_vkAcquireImageOHOS vkAcquireImageOHOS; + public PFN_vkQueueSignalReleaseImageOHOS vkQueueSignalReleaseImageOHOS; + public PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM; + + public void Load(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) mut + { + this.vkGetInstanceProcAddr = vkGetInstanceProcAddr; + vkCreateInstance = (.)(void*)vkGetInstanceProcAddr(null, nameof(vkCreateInstance)); + vkEnumerateInstanceVersion = (.)(void*)vkGetInstanceProcAddr(null, nameof(vkEnumerateInstanceVersion)); + vkEnumerateInstanceLayerProperties = (.)(void*)vkGetInstanceProcAddr(null, nameof(vkEnumerateInstanceLayerProperties)); + vkEnumerateInstanceExtensionProperties = (.)(void*)vkGetInstanceProcAddr(null, nameof(vkEnumerateInstanceExtensionProperties)); + } + + public void LoadInstance(VkInstance instance) mut + { + vkDestroyInstance = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyInstance)); + vkEnumeratePhysicalDevices = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDevices)); + vkGetInstanceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetInstanceProcAddr)); + vkGetPhysicalDeviceProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties)); + vkGetPhysicalDeviceQueueFamilyProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties)); + vkGetPhysicalDeviceMemoryProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties)); + vkGetPhysicalDeviceFeatures = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures)); + vkGetPhysicalDeviceFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties)); + vkGetPhysicalDeviceImageFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties)); + vkCreateDevice = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDevice)); + vkEnumerateDeviceLayerProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumerateDeviceLayerProperties)); + vkEnumerateDeviceExtensionProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumerateDeviceExtensionProperties)); + vkGetPhysicalDeviceSparseImageFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties)); + vkCreateAndroidSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateAndroidSurfaceKHR)); + vkCreateSurfaceOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSurfaceOHOS)); + vkGetPhysicalDeviceDisplayPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPropertiesKHR)); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPlanePropertiesKHR)); + vkGetDisplayPlaneSupportedDisplaysKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneSupportedDisplaysKHR)); + vkGetDisplayModePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayModePropertiesKHR)); + vkCreateDisplayModeKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDisplayModeKHR)); + vkGetDisplayPlaneCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneCapabilitiesKHR)); + vkCreateDisplayPlaneSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDisplayPlaneSurfaceKHR)); + vkDestroySurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySurfaceKHR)); + vkGetPhysicalDeviceSurfaceSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceSupportKHR)); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)); + vkGetPhysicalDeviceSurfaceFormatsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceFormatsKHR)); + vkGetPhysicalDeviceSurfacePresentModesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfacePresentModesKHR)); + vkCreateViSurfaceNN = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateViSurfaceNN)); + vkCreateWaylandSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateWaylandSurfaceKHR)); + vkGetPhysicalDeviceWaylandPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceWaylandPresentationSupportKHR)); + vkCreateWin32SurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateWin32SurfaceKHR)); + vkGetPhysicalDeviceWin32PresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceWin32PresentationSupportKHR)); + vkCreateXlibSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateXlibSurfaceKHR)); + vkGetPhysicalDeviceXlibPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceXlibPresentationSupportKHR)); + vkCreateXcbSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateXcbSurfaceKHR)); + vkGetPhysicalDeviceXcbPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceXcbPresentationSupportKHR)); + vkCreateDirectFBSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDirectFBSurfaceEXT)); + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDirectFBPresentationSupportEXT)); + vkCreateImagePipeSurfaceFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateImagePipeSurfaceFUCHSIA)); + vkCreateStreamDescriptorSurfaceGGP = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateStreamDescriptorSurfaceGGP)); + vkCreateScreenSurfaceQNX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateScreenSurfaceQNX)); + vkGetPhysicalDeviceScreenPresentationSupportQNX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceScreenPresentationSupportQNX)); + vkCreateDebugReportCallbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDebugReportCallbackEXT)); + vkDestroyDebugReportCallbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDebugReportCallbackEXT)); + vkDebugReportMessageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDebugReportMessageEXT)); + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalImageFormatPropertiesNV)); + vkGetPhysicalDeviceFeatures2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures2)); + vkGetPhysicalDeviceFeatures2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures2KHR)); + vkGetPhysicalDeviceProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties2)); + vkGetPhysicalDeviceProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties2KHR)); + vkGetPhysicalDeviceFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties2)); + vkGetPhysicalDeviceFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties2KHR)); + vkGetPhysicalDeviceImageFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties2)); + vkGetPhysicalDeviceImageFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties2KHR)); + vkGetPhysicalDeviceQueueFamilyProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties2)); + vkGetPhysicalDeviceQueueFamilyProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties2KHR)); + vkGetPhysicalDeviceMemoryProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties2)); + vkGetPhysicalDeviceMemoryProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties2KHR)); + vkGetPhysicalDeviceSparseImageFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties2)); + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties2KHR)); + vkGetPhysicalDeviceExternalBufferProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalBufferProperties)); + vkGetPhysicalDeviceExternalBufferPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalBufferPropertiesKHR)); + vkGetPhysicalDeviceExternalSemaphoreProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalSemaphoreProperties)); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)); + vkGetPhysicalDeviceExternalFenceProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalFenceProperties)); + vkGetPhysicalDeviceExternalFencePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalFencePropertiesKHR)); + vkReleaseDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseDisplayEXT)); + vkAcquireXlibDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireXlibDisplayEXT)); + vkGetRandROutputDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRandROutputDisplayEXT)); + vkAcquireWinrtDisplayNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireWinrtDisplayNV)); + vkGetWinrtDisplayNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetWinrtDisplayNV)); + vkGetPhysicalDeviceSurfaceCapabilities2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilities2EXT)); + vkEnumeratePhysicalDeviceGroups = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceGroups)); + vkEnumeratePhysicalDeviceGroupsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceGroupsKHR)); + vkGetPhysicalDevicePresentRectanglesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDevicePresentRectanglesKHR)); + vkCreateIOSSurfaceMVK = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateIOSSurfaceMVK)); + vkCreateMacOSSurfaceMVK = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateMacOSSurfaceMVK)); + vkCreateMetalSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateMetalSurfaceEXT)); + vkGetPhysicalDeviceMultisamplePropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMultisamplePropertiesEXT)); + vkGetPhysicalDeviceSurfaceCapabilities2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilities2KHR)); + vkGetPhysicalDeviceSurfaceFormats2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceFormats2KHR)); + vkGetPhysicalDeviceDisplayProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayProperties2KHR)); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPlaneProperties2KHR)); + vkGetDisplayModeProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayModeProperties2KHR)); + vkGetDisplayPlaneCapabilities2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneCapabilities2KHR)); + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)); + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)); + vkCreateDebugUtilsMessengerEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDebugUtilsMessengerEXT)); + vkDestroyDebugUtilsMessengerEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDebugUtilsMessengerEXT)); + vkSubmitDebugUtilsMessageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSubmitDebugUtilsMessageEXT)); + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)); + vkGetPhysicalDeviceSurfacePresentModes2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfacePresentModes2EXT)); + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)); + vkCreateHeadlessSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateHeadlessSurfaceEXT)); + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)); + vkGetPhysicalDeviceToolProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceToolProperties)); + vkGetPhysicalDeviceToolPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceToolPropertiesEXT)); + vkGetPhysicalDeviceFragmentShadingRatesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFragmentShadingRatesKHR)); + vkGetPhysicalDeviceVideoCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoCapabilitiesKHR)); + vkGetPhysicalDeviceVideoFormatPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoFormatPropertiesKHR)); + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)); + vkAcquireDrmDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireDrmDisplayEXT)); + vkGetDrmDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDrmDisplayEXT)); + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceOpticalFlowImageFormatsNV)); + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)); + vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)); + vkGetPhysicalDeviceCooperativeVectorPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeVectorPropertiesNV)); + vkGetPhysicalDeviceExternalTensorPropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalTensorPropertiesARM)); + vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)); + vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)); + vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)); + } + + public void LoadDevice(VkDevice device) mut + { + vkGetDeviceProcAddr = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceProcAddr)); + vkDestroyDevice = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDevice)); + vkGetDeviceQueue = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceQueue)); + vkQueueSubmit = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueSubmit)); + vkQueueWaitIdle = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueWaitIdle)); + vkDeviceWaitIdle = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDeviceWaitIdle)); + vkAllocateMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAllocateMemory)); + vkFreeMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkFreeMemory)); + vkMapMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkMapMemory)); + vkUnmapMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUnmapMemory)); + vkFlushMappedMemoryRanges = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkFlushMappedMemoryRanges)); + vkInvalidateMappedMemoryRanges = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkInvalidateMappedMemoryRanges)); + vkGetDeviceMemoryCommitment = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceMemoryCommitment)); + vkGetBufferMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferMemoryRequirements)); + vkBindBufferMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindBufferMemory)); + vkGetImageMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageMemoryRequirements)); + vkBindImageMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindImageMemory)); + vkGetImageSparseMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSparseMemoryRequirements)); + vkQueueBindSparse = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueBindSparse)); + vkCreateFence = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateFence)); + vkDestroyFence = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyFence)); + vkResetFences = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetFences)); + vkGetFenceStatus = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetFenceStatus)); + vkWaitForFences = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWaitForFences)); + vkCreateSemaphore = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSemaphore)); + vkDestroySemaphore = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroySemaphore)); + vkCreateEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateEvent)); + vkDestroyEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyEvent)); + vkGetEventStatus = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetEventStatus)); + vkSetEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetEvent)); + vkResetEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetEvent)); + vkCreateQueryPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateQueryPool)); + vkDestroyQueryPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyQueryPool)); + vkGetQueryPoolResults = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetQueryPoolResults)); + vkResetQueryPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetQueryPool)); + vkResetQueryPoolEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetQueryPoolEXT)); + vkCreateBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateBuffer)); + vkDestroyBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyBuffer)); + vkCreateBufferView = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateBufferView)); + vkDestroyBufferView = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyBufferView)); + vkCreateImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateImage)); + vkDestroyImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyImage)); + vkGetImageSubresourceLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSubresourceLayout)); + vkCreateImageView = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateImageView)); + vkDestroyImageView = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyImageView)); + vkCreateShaderModule = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateShaderModule)); + vkDestroyShaderModule = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyShaderModule)); + vkCreatePipelineCache = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreatePipelineCache)); + vkDestroyPipelineCache = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPipelineCache)); + vkGetPipelineCacheData = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineCacheData)); + vkMergePipelineCaches = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkMergePipelineCaches)); + vkCreatePipelineBinariesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreatePipelineBinariesKHR)); + vkDestroyPipelineBinaryKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPipelineBinaryKHR)); + vkGetPipelineKeyKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineKeyKHR)); + vkGetPipelineBinaryDataKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineBinaryDataKHR)); + vkReleaseCapturedPipelineDataKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleaseCapturedPipelineDataKHR)); + vkCreateGraphicsPipelines = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateGraphicsPipelines)); + vkCreateComputePipelines = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateComputePipelines)); + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)); + vkDestroyPipeline = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPipeline)); + vkCreatePipelineLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreatePipelineLayout)); + vkDestroyPipelineLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPipelineLayout)); + vkCreateSampler = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSampler)); + vkDestroySampler = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroySampler)); + vkCreateDescriptorSetLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDescriptorSetLayout)); + vkDestroyDescriptorSetLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDescriptorSetLayout)); + vkCreateDescriptorPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDescriptorPool)); + vkDestroyDescriptorPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDescriptorPool)); + vkResetDescriptorPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetDescriptorPool)); + vkAllocateDescriptorSets = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAllocateDescriptorSets)); + vkFreeDescriptorSets = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkFreeDescriptorSets)); + vkUpdateDescriptorSets = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateDescriptorSets)); + vkCreateFramebuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateFramebuffer)); + vkDestroyFramebuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyFramebuffer)); + vkCreateRenderPass = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateRenderPass)); + vkDestroyRenderPass = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyRenderPass)); + vkGetRenderAreaGranularity = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRenderAreaGranularity)); + vkGetRenderingAreaGranularity = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRenderingAreaGranularity)); + vkGetRenderingAreaGranularityKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRenderingAreaGranularityKHR)); + vkCreateCommandPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateCommandPool)); + vkDestroyCommandPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyCommandPool)); + vkResetCommandPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetCommandPool)); + vkAllocateCommandBuffers = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAllocateCommandBuffers)); + vkFreeCommandBuffers = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkFreeCommandBuffers)); + vkBeginCommandBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBeginCommandBuffer)); + vkEndCommandBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkEndCommandBuffer)); + vkResetCommandBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkResetCommandBuffer)); + vkCmdBindPipeline = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindPipeline)); + vkCmdSetAttachmentFeedbackLoopEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetAttachmentFeedbackLoopEnableEXT)); + vkCmdSetViewport = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewport)); + vkCmdSetScissor = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetScissor)); + vkCmdSetLineWidth = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineWidth)); + vkCmdSetDepthBias = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBias)); + vkCmdSetBlendConstants = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetBlendConstants)); + vkCmdSetDepthBounds = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBounds)); + vkCmdSetStencilCompareMask = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilCompareMask)); + vkCmdSetStencilWriteMask = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilWriteMask)); + vkCmdSetStencilReference = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilReference)); + vkCmdBindDescriptorSets = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorSets)); + vkCmdBindIndexBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindIndexBuffer)); + vkCmdBindVertexBuffers = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindVertexBuffers)); + vkCmdDraw = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDraw)); + vkCmdDrawIndexed = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndexed)); + vkCmdDrawMultiEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMultiEXT)); + vkCmdDrawMultiIndexedEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMultiIndexedEXT)); + vkCmdDrawIndirect = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndirect)); + vkCmdDrawIndexedIndirect = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndexedIndirect)); + vkCmdDispatch = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatch)); + vkCmdDispatchIndirect = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchIndirect)); + vkCmdSubpassShadingHUAWEI = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSubpassShadingHUAWEI)); + vkCmdDrawClusterHUAWEI = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawClusterHUAWEI)); + vkCmdDrawClusterIndirectHUAWEI = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawClusterIndirectHUAWEI)); + vkCmdUpdatePipelineIndirectBufferNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdUpdatePipelineIndirectBufferNV)); + vkCmdCopyBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBuffer)); + vkCmdCopyImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImage)); + vkCmdBlitImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBlitImage)); + vkCmdCopyBufferToImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBufferToImage)); + vkCmdCopyImageToBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImageToBuffer)); + vkCmdCopyMemoryIndirectNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryIndirectNV)); + vkCmdCopyMemoryIndirectKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryIndirectKHR)); + vkCmdCopyMemoryToImageIndirectNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryToImageIndirectNV)); + vkCmdCopyMemoryToImageIndirectKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryToImageIndirectKHR)); + vkCmdUpdateBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdUpdateBuffer)); + vkCmdFillBuffer = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdFillBuffer)); + vkCmdClearColorImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdClearColorImage)); + vkCmdClearDepthStencilImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdClearDepthStencilImage)); + vkCmdClearAttachments = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdClearAttachments)); + vkCmdResolveImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResolveImage)); + vkCmdSetEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetEvent)); + vkCmdResetEvent = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResetEvent)); + vkCmdWaitEvents = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWaitEvents)); + vkCmdPipelineBarrier = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPipelineBarrier)); + vkCmdBeginQuery = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginQuery)); + vkCmdEndQuery = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndQuery)); + vkCmdBeginConditionalRenderingEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginConditionalRenderingEXT)); + vkCmdEndConditionalRenderingEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndConditionalRenderingEXT)); + vkCmdBeginCustomResolveEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginCustomResolveEXT)); + vkCmdResetQueryPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResetQueryPool)); + vkCmdWriteTimestamp = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteTimestamp)); + vkCmdCopyQueryPoolResults = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyQueryPoolResults)); + vkCmdPushConstants = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushConstants)); + vkCmdBeginRenderPass = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginRenderPass)); + vkCmdNextSubpass = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdNextSubpass)); + vkCmdEndRenderPass = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRenderPass)); + vkCmdExecuteCommands = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdExecuteCommands)); + vkCreateSharedSwapchainsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSharedSwapchainsKHR)); + vkCreateSwapchainKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSwapchainKHR)); + vkDestroySwapchainKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroySwapchainKHR)); + vkGetSwapchainImagesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainImagesKHR)); + vkAcquireNextImageKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquireNextImageKHR)); + vkQueuePresentKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueuePresentKHR)); + vkDebugMarkerSetObjectNameEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDebugMarkerSetObjectNameEXT)); + vkDebugMarkerSetObjectTagEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDebugMarkerSetObjectTagEXT)); + vkCmdDebugMarkerBeginEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDebugMarkerBeginEXT)); + vkCmdDebugMarkerEndEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDebugMarkerEndEXT)); + vkCmdDebugMarkerInsertEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDebugMarkerInsertEXT)); + vkGetMemoryWin32HandleNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryWin32HandleNV)); + vkCmdExecuteGeneratedCommandsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdExecuteGeneratedCommandsNV)); + vkCmdPreprocessGeneratedCommandsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPreprocessGeneratedCommandsNV)); + vkCmdBindPipelineShaderGroupNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindPipelineShaderGroupNV)); + vkGetGeneratedCommandsMemoryRequirementsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetGeneratedCommandsMemoryRequirementsNV)); + vkCreateIndirectCommandsLayoutNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateIndirectCommandsLayoutNV)); + vkDestroyIndirectCommandsLayoutNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyIndirectCommandsLayoutNV)); + vkCmdExecuteGeneratedCommandsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdExecuteGeneratedCommandsEXT)); + vkCmdPreprocessGeneratedCommandsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPreprocessGeneratedCommandsEXT)); + vkGetGeneratedCommandsMemoryRequirementsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetGeneratedCommandsMemoryRequirementsEXT)); + vkCreateIndirectCommandsLayoutEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateIndirectCommandsLayoutEXT)); + vkDestroyIndirectCommandsLayoutEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyIndirectCommandsLayoutEXT)); + vkCreateIndirectExecutionSetEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateIndirectExecutionSetEXT)); + vkDestroyIndirectExecutionSetEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyIndirectExecutionSetEXT)); + vkUpdateIndirectExecutionSetPipelineEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateIndirectExecutionSetPipelineEXT)); + vkUpdateIndirectExecutionSetShaderEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateIndirectExecutionSetShaderEXT)); + vkCmdPushDescriptorSet = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSet)); + vkCmdPushDescriptorSetKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSetKHR)); + vkTrimCommandPool = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkTrimCommandPool)); + vkTrimCommandPoolKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkTrimCommandPoolKHR)); + vkGetMemoryWin32HandleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryWin32HandleKHR)); + vkGetMemoryWin32HandlePropertiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryWin32HandlePropertiesKHR)); + vkGetMemoryFdKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryFdKHR)); + vkGetMemoryFdPropertiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryFdPropertiesKHR)); + vkGetMemoryZirconHandleFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryZirconHandleFUCHSIA)); + vkGetMemoryZirconHandlePropertiesFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryZirconHandlePropertiesFUCHSIA)); + vkGetMemoryRemoteAddressNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryRemoteAddressNV)); + vkGetSemaphoreWin32HandleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSemaphoreWin32HandleKHR)); + vkImportSemaphoreWin32HandleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkImportSemaphoreWin32HandleKHR)); + vkGetSemaphoreFdKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSemaphoreFdKHR)); + vkImportSemaphoreFdKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkImportSemaphoreFdKHR)); + vkGetSemaphoreZirconHandleFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSemaphoreZirconHandleFUCHSIA)); + vkImportSemaphoreZirconHandleFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkImportSemaphoreZirconHandleFUCHSIA)); + vkGetFenceWin32HandleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetFenceWin32HandleKHR)); + vkImportFenceWin32HandleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkImportFenceWin32HandleKHR)); + vkGetFenceFdKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetFenceFdKHR)); + vkImportFenceFdKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkImportFenceFdKHR)); + vkDisplayPowerControlEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDisplayPowerControlEXT)); + vkRegisterDeviceEventEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkRegisterDeviceEventEXT)); + vkRegisterDisplayEventEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkRegisterDisplayEventEXT)); + vkGetSwapchainCounterEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainCounterEXT)); + vkGetDeviceGroupPeerMemoryFeatures = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceGroupPeerMemoryFeatures)); + vkGetDeviceGroupPeerMemoryFeaturesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceGroupPeerMemoryFeaturesKHR)); + vkBindBufferMemory2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindBufferMemory2)); + vkBindBufferMemory2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindBufferMemory2KHR)); + vkBindImageMemory2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindImageMemory2)); + vkBindImageMemory2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindImageMemory2KHR)); + vkCmdSetDeviceMask = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDeviceMask)); + vkCmdSetDeviceMaskKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDeviceMaskKHR)); + vkGetDeviceGroupPresentCapabilitiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceGroupPresentCapabilitiesKHR)); + vkGetDeviceGroupSurfacePresentModesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceGroupSurfacePresentModesKHR)); + vkAcquireNextImage2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquireNextImage2KHR)); + vkCmdDispatchBase = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchBase)); + vkCmdDispatchBaseKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchBaseKHR)); + vkCreateDescriptorUpdateTemplate = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDescriptorUpdateTemplate)); + vkCreateDescriptorUpdateTemplateKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDescriptorUpdateTemplateKHR)); + vkDestroyDescriptorUpdateTemplate = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDescriptorUpdateTemplate)); + vkDestroyDescriptorUpdateTemplateKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDescriptorUpdateTemplateKHR)); + vkUpdateDescriptorSetWithTemplate = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateDescriptorSetWithTemplate)); + vkUpdateDescriptorSetWithTemplateKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateDescriptorSetWithTemplateKHR)); + vkCmdPushDescriptorSetWithTemplate = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSetWithTemplate)); + vkCmdPushDescriptorSetWithTemplateKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSetWithTemplateKHR)); + vkSetHdrMetadataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetHdrMetadataEXT)); + vkGetSwapchainStatusKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainStatusKHR)); + vkGetRefreshCycleDurationGOOGLE = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRefreshCycleDurationGOOGLE)); + vkGetPastPresentationTimingGOOGLE = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPastPresentationTimingGOOGLE)); + vkCmdSetViewportWScalingNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportWScalingNV)); + vkCmdSetDiscardRectangleEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDiscardRectangleEXT)); + vkCmdSetDiscardRectangleEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDiscardRectangleEnableEXT)); + vkCmdSetDiscardRectangleModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDiscardRectangleModeEXT)); + vkCmdSetSampleLocationsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetSampleLocationsEXT)); + vkGetBufferMemoryRequirements2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferMemoryRequirements2)); + vkGetBufferMemoryRequirements2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferMemoryRequirements2KHR)); + vkGetImageMemoryRequirements2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageMemoryRequirements2)); + vkGetImageMemoryRequirements2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageMemoryRequirements2KHR)); + vkGetImageSparseMemoryRequirements2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSparseMemoryRequirements2)); + vkGetImageSparseMemoryRequirements2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSparseMemoryRequirements2KHR)); + vkGetDeviceBufferMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceBufferMemoryRequirements)); + vkGetDeviceBufferMemoryRequirementsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceBufferMemoryRequirementsKHR)); + vkGetDeviceImageMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageMemoryRequirements)); + vkGetDeviceImageMemoryRequirementsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageMemoryRequirementsKHR)); + vkGetDeviceImageSparseMemoryRequirements = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageSparseMemoryRequirements)); + vkGetDeviceImageSparseMemoryRequirementsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageSparseMemoryRequirementsKHR)); + vkCreateSamplerYcbcrConversion = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSamplerYcbcrConversion)); + vkCreateSamplerYcbcrConversionKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateSamplerYcbcrConversionKHR)); + vkDestroySamplerYcbcrConversion = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroySamplerYcbcrConversion)); + vkDestroySamplerYcbcrConversionKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroySamplerYcbcrConversionKHR)); + vkGetDeviceQueue2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceQueue2)); + vkCreateValidationCacheEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateValidationCacheEXT)); + vkDestroyValidationCacheEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyValidationCacheEXT)); + vkGetValidationCacheDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetValidationCacheDataEXT)); + vkMergeValidationCachesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkMergeValidationCachesEXT)); + vkGetDescriptorSetLayoutSupport = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetLayoutSupport)); + vkGetDescriptorSetLayoutSupportKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetLayoutSupportKHR)); + vkGetShaderInfoAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetShaderInfoAMD)); + vkSetLocalDimmingAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetLocalDimmingAMD)); + vkGetCalibratedTimestampsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetCalibratedTimestampsKHR)); + vkGetCalibratedTimestampsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetCalibratedTimestampsEXT)); + vkSetDebugUtilsObjectNameEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetDebugUtilsObjectNameEXT)); + vkSetDebugUtilsObjectTagEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetDebugUtilsObjectTagEXT)); + vkQueueBeginDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueBeginDebugUtilsLabelEXT)); + vkQueueEndDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueEndDebugUtilsLabelEXT)); + vkQueueInsertDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueInsertDebugUtilsLabelEXT)); + vkCmdBeginDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginDebugUtilsLabelEXT)); + vkCmdEndDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndDebugUtilsLabelEXT)); + vkCmdInsertDebugUtilsLabelEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdInsertDebugUtilsLabelEXT)); + vkGetMemoryHostPointerPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryHostPointerPropertiesEXT)); + vkCmdWriteBufferMarkerAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteBufferMarkerAMD)); + vkCreateRenderPass2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateRenderPass2)); + vkCreateRenderPass2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateRenderPass2KHR)); + vkCmdBeginRenderPass2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginRenderPass2)); + vkCmdBeginRenderPass2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginRenderPass2KHR)); + vkCmdNextSubpass2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdNextSubpass2)); + vkCmdNextSubpass2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdNextSubpass2KHR)); + vkCmdEndRenderPass2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRenderPass2)); + vkCmdEndRenderPass2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRenderPass2KHR)); + vkGetSemaphoreCounterValue = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSemaphoreCounterValue)); + vkGetSemaphoreCounterValueKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSemaphoreCounterValueKHR)); + vkWaitSemaphores = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWaitSemaphores)); + vkWaitSemaphoresKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWaitSemaphoresKHR)); + vkSignalSemaphore = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSignalSemaphore)); + vkSignalSemaphoreKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSignalSemaphoreKHR)); + vkGetAndroidHardwareBufferPropertiesANDROID = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAndroidHardwareBufferPropertiesANDROID)); + vkGetMemoryAndroidHardwareBufferANDROID = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryAndroidHardwareBufferANDROID)); + vkCmdDrawIndirectCount = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndirectCount)); + vkCmdDrawIndirectCountKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndirectCountKHR)); + vkCmdDrawIndirectCountAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndirectCountAMD)); + vkCmdDrawIndexedIndirectCount = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndexedIndirectCount)); + vkCmdDrawIndexedIndirectCountKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndexedIndirectCountKHR)); + vkCmdDrawIndexedIndirectCountAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndexedIndirectCountAMD)); + vkCmdSetCheckpointNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCheckpointNV)); + vkGetQueueCheckpointDataNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetQueueCheckpointDataNV)); + vkCmdBindTransformFeedbackBuffersEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindTransformFeedbackBuffersEXT)); + vkCmdBeginTransformFeedbackEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginTransformFeedbackEXT)); + vkCmdEndTransformFeedbackEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndTransformFeedbackEXT)); + vkCmdBeginQueryIndexedEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginQueryIndexedEXT)); + vkCmdEndQueryIndexedEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndQueryIndexedEXT)); + vkCmdDrawIndirectByteCountEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawIndirectByteCountEXT)); + vkCmdSetExclusiveScissorNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetExclusiveScissorNV)); + vkCmdSetExclusiveScissorEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetExclusiveScissorEnableNV)); + vkCmdBindShadingRateImageNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindShadingRateImageNV)); + vkCmdSetViewportShadingRatePaletteNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportShadingRatePaletteNV)); + vkCmdSetCoarseSampleOrderNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoarseSampleOrderNV)); + vkCmdDrawMeshTasksNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksNV)); + vkCmdDrawMeshTasksIndirectNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksIndirectNV)); + vkCmdDrawMeshTasksIndirectCountNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksIndirectCountNV)); + vkCmdDrawMeshTasksEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksEXT)); + vkCmdDrawMeshTasksIndirectEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksIndirectEXT)); + vkCmdDrawMeshTasksIndirectCountEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDrawMeshTasksIndirectCountEXT)); + vkCompileDeferredNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCompileDeferredNV)); + vkCreateAccelerationStructureNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateAccelerationStructureNV)); + vkCmdBindInvocationMaskHUAWEI = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindInvocationMaskHUAWEI)); + vkDestroyAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyAccelerationStructureKHR)); + vkDestroyAccelerationStructureNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyAccelerationStructureNV)); + vkGetAccelerationStructureMemoryRequirementsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAccelerationStructureMemoryRequirementsNV)); + vkBindAccelerationStructureMemoryNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindAccelerationStructureMemoryNV)); + vkCmdCopyAccelerationStructureNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyAccelerationStructureNV)); + vkCmdCopyAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyAccelerationStructureKHR)); + vkCopyAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyAccelerationStructureKHR)); + vkCmdCopyAccelerationStructureToMemoryKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyAccelerationStructureToMemoryKHR)); + vkCopyAccelerationStructureToMemoryKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyAccelerationStructureToMemoryKHR)); + vkCmdCopyMemoryToAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryToAccelerationStructureKHR)); + vkCopyMemoryToAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMemoryToAccelerationStructureKHR)); + vkCmdWriteAccelerationStructuresPropertiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteAccelerationStructuresPropertiesKHR)); + vkCmdWriteAccelerationStructuresPropertiesNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteAccelerationStructuresPropertiesNV)); + vkCmdBuildAccelerationStructureNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildAccelerationStructureNV)); + vkWriteAccelerationStructuresPropertiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWriteAccelerationStructuresPropertiesKHR)); + vkCmdTraceRaysKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdTraceRaysKHR)); + vkCmdTraceRaysNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdTraceRaysNV)); + vkGetRayTracingShaderGroupHandlesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRayTracingShaderGroupHandlesKHR)); + vkGetRayTracingShaderGroupHandlesNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRayTracingShaderGroupHandlesNV)); + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)); + vkGetAccelerationStructureHandleNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAccelerationStructureHandleNV)); + vkCreateRayTracingPipelinesNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateRayTracingPipelinesNV)); + vkCreateRayTracingPipelinesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateRayTracingPipelinesKHR)); + vkCmdTraceRaysIndirectKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdTraceRaysIndirectKHR)); + vkCmdTraceRaysIndirect2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdTraceRaysIndirect2KHR)); + vkGetClusterAccelerationStructureBuildSizesNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetClusterAccelerationStructureBuildSizesNV)); + vkCmdBuildClusterAccelerationStructureIndirectNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildClusterAccelerationStructureIndirectNV)); + vkGetDeviceAccelerationStructureCompatibilityKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceAccelerationStructureCompatibilityKHR)); + vkGetRayTracingShaderGroupStackSizeKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetRayTracingShaderGroupStackSizeKHR)); + vkCmdSetRayTracingPipelineStackSizeKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRayTracingPipelineStackSizeKHR)); + vkGetImageViewHandleNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageViewHandleNVX)); + vkGetImageViewHandle64NVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageViewHandle64NVX)); + vkGetImageViewAddressNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageViewAddressNVX)); + vkGetDeviceGroupSurfacePresentModes2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceGroupSurfacePresentModes2EXT)); + vkAcquireFullScreenExclusiveModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquireFullScreenExclusiveModeEXT)); + vkReleaseFullScreenExclusiveModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleaseFullScreenExclusiveModeEXT)); + vkAcquireProfilingLockKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquireProfilingLockKHR)); + vkReleaseProfilingLockKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleaseProfilingLockKHR)); + vkGetImageDrmFormatModifierPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageDrmFormatModifierPropertiesEXT)); + vkGetBufferOpaqueCaptureAddress = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferOpaqueCaptureAddress)); + vkGetBufferOpaqueCaptureAddressKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferOpaqueCaptureAddressKHR)); + vkGetBufferDeviceAddress = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferDeviceAddress)); + vkGetBufferDeviceAddressKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferDeviceAddressKHR)); + vkGetBufferDeviceAddressEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferDeviceAddressEXT)); + vkInitializePerformanceApiINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkInitializePerformanceApiINTEL)); + vkUninitializePerformanceApiINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUninitializePerformanceApiINTEL)); + vkCmdSetPerformanceMarkerINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPerformanceMarkerINTEL)); + vkCmdSetPerformanceStreamMarkerINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPerformanceStreamMarkerINTEL)); + vkCmdSetPerformanceOverrideINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPerformanceOverrideINTEL)); + vkAcquirePerformanceConfigurationINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquirePerformanceConfigurationINTEL)); + vkReleasePerformanceConfigurationINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleasePerformanceConfigurationINTEL)); + vkQueueSetPerformanceConfigurationINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueSetPerformanceConfigurationINTEL)); + vkGetPerformanceParameterINTEL = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPerformanceParameterINTEL)); + vkGetDeviceMemoryOpaqueCaptureAddress = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceMemoryOpaqueCaptureAddress)); + vkGetDeviceMemoryOpaqueCaptureAddressKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceMemoryOpaqueCaptureAddressKHR)); + vkGetPipelineExecutablePropertiesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineExecutablePropertiesKHR)); + vkGetPipelineExecutableStatisticsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineExecutableStatisticsKHR)); + vkGetPipelineExecutableInternalRepresentationsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineExecutableInternalRepresentationsKHR)); + vkCmdSetLineStipple = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineStipple)); + vkCmdSetLineStippleKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineStippleKHR)); + vkCmdSetLineStippleEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineStippleEXT)); + vkCreateAccelerationStructureKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateAccelerationStructureKHR)); + vkCmdBuildAccelerationStructuresKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildAccelerationStructuresKHR)); + vkCmdBuildAccelerationStructuresIndirectKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildAccelerationStructuresIndirectKHR)); + vkBuildAccelerationStructuresKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBuildAccelerationStructuresKHR)); + vkGetAccelerationStructureDeviceAddressKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAccelerationStructureDeviceAddressKHR)); + vkCreateDeferredOperationKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDeferredOperationKHR)); + vkDestroyDeferredOperationKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDeferredOperationKHR)); + vkGetDeferredOperationMaxConcurrencyKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeferredOperationMaxConcurrencyKHR)); + vkGetDeferredOperationResultKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeferredOperationResultKHR)); + vkDeferredOperationJoinKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDeferredOperationJoinKHR)); + vkGetPipelineIndirectMemoryRequirementsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineIndirectMemoryRequirementsNV)); + vkGetPipelineIndirectDeviceAddressNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelineIndirectDeviceAddressNV)); + vkAntiLagUpdateAMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAntiLagUpdateAMD)); + vkCmdSetCullMode = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCullMode)); + vkCmdSetCullModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCullModeEXT)); + vkCmdSetFrontFace = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetFrontFace)); + vkCmdSetFrontFaceEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetFrontFaceEXT)); + vkCmdSetPrimitiveTopology = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPrimitiveTopology)); + vkCmdSetPrimitiveTopologyEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPrimitiveTopologyEXT)); + vkCmdSetViewportWithCount = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportWithCount)); + vkCmdSetViewportWithCountEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportWithCountEXT)); + vkCmdSetScissorWithCount = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetScissorWithCount)); + vkCmdSetScissorWithCountEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetScissorWithCountEXT)); + vkCmdBindIndexBuffer2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindIndexBuffer2)); + vkCmdBindIndexBuffer2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindIndexBuffer2KHR)); + vkCmdBindVertexBuffers2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindVertexBuffers2)); + vkCmdBindVertexBuffers2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindVertexBuffers2EXT)); + vkCmdSetDepthTestEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthTestEnable)); + vkCmdSetDepthTestEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthTestEnableEXT)); + vkCmdSetDepthWriteEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthWriteEnable)); + vkCmdSetDepthWriteEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthWriteEnableEXT)); + vkCmdSetDepthCompareOp = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthCompareOp)); + vkCmdSetDepthCompareOpEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthCompareOpEXT)); + vkCmdSetDepthBoundsTestEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBoundsTestEnable)); + vkCmdSetDepthBoundsTestEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBoundsTestEnableEXT)); + vkCmdSetStencilTestEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilTestEnable)); + vkCmdSetStencilTestEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilTestEnableEXT)); + vkCmdSetStencilOp = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilOp)); + vkCmdSetStencilOpEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetStencilOpEXT)); + vkCmdSetPatchControlPointsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPatchControlPointsEXT)); + vkCmdSetRasterizerDiscardEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRasterizerDiscardEnable)); + vkCmdSetRasterizerDiscardEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRasterizerDiscardEnableEXT)); + vkCmdSetDepthBiasEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBiasEnable)); + vkCmdSetDepthBiasEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBiasEnableEXT)); + vkCmdSetLogicOpEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLogicOpEXT)); + vkCmdSetPrimitiveRestartEnable = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPrimitiveRestartEnable)); + vkCmdSetPrimitiveRestartEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPrimitiveRestartEnableEXT)); + vkCmdSetTessellationDomainOriginEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetTessellationDomainOriginEXT)); + vkCmdSetDepthClampEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthClampEnableEXT)); + vkCmdSetPolygonModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetPolygonModeEXT)); + vkCmdSetRasterizationSamplesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRasterizationSamplesEXT)); + vkCmdSetSampleMaskEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetSampleMaskEXT)); + vkCmdSetAlphaToCoverageEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetAlphaToCoverageEnableEXT)); + vkCmdSetAlphaToOneEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetAlphaToOneEnableEXT)); + vkCmdSetLogicOpEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLogicOpEnableEXT)); + vkCmdSetColorBlendEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetColorBlendEnableEXT)); + vkCmdSetColorBlendEquationEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetColorBlendEquationEXT)); + vkCmdSetColorWriteMaskEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetColorWriteMaskEXT)); + vkCmdSetRasterizationStreamEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRasterizationStreamEXT)); + vkCmdSetConservativeRasterizationModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetConservativeRasterizationModeEXT)); + vkCmdSetExtraPrimitiveOverestimationSizeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetExtraPrimitiveOverestimationSizeEXT)); + vkCmdSetDepthClipEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthClipEnableEXT)); + vkCmdSetSampleLocationsEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetSampleLocationsEnableEXT)); + vkCmdSetColorBlendAdvancedEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetColorBlendAdvancedEXT)); + vkCmdSetProvokingVertexModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetProvokingVertexModeEXT)); + vkCmdSetLineRasterizationModeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineRasterizationModeEXT)); + vkCmdSetLineStippleEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetLineStippleEnableEXT)); + vkCmdSetDepthClipNegativeOneToOneEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthClipNegativeOneToOneEXT)); + vkCmdSetViewportWScalingEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportWScalingEnableNV)); + vkCmdSetViewportSwizzleNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetViewportSwizzleNV)); + vkCmdSetCoverageToColorEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageToColorEnableNV)); + vkCmdSetCoverageToColorLocationNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageToColorLocationNV)); + vkCmdSetCoverageModulationModeNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageModulationModeNV)); + vkCmdSetCoverageModulationTableEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageModulationTableEnableNV)); + vkCmdSetCoverageModulationTableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageModulationTableNV)); + vkCmdSetShadingRateImageEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetShadingRateImageEnableNV)); + vkCmdSetCoverageReductionModeNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetCoverageReductionModeNV)); + vkCmdSetRepresentativeFragmentTestEnableNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRepresentativeFragmentTestEnableNV)); + vkCreatePrivateDataSlot = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreatePrivateDataSlot)); + vkCreatePrivateDataSlotEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreatePrivateDataSlotEXT)); + vkDestroyPrivateDataSlot = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPrivateDataSlot)); + vkDestroyPrivateDataSlotEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyPrivateDataSlotEXT)); + vkSetPrivateData = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetPrivateData)); + vkSetPrivateDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetPrivateDataEXT)); + vkGetPrivateData = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPrivateData)); + vkGetPrivateDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPrivateDataEXT)); + vkCmdCopyBuffer2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBuffer2)); + vkCmdCopyBuffer2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBuffer2KHR)); + vkCmdCopyImage2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImage2)); + vkCmdCopyImage2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImage2KHR)); + vkCmdBlitImage2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBlitImage2)); + vkCmdBlitImage2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBlitImage2KHR)); + vkCmdCopyBufferToImage2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBufferToImage2)); + vkCmdCopyBufferToImage2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyBufferToImage2KHR)); + vkCmdCopyImageToBuffer2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImageToBuffer2)); + vkCmdCopyImageToBuffer2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyImageToBuffer2KHR)); + vkCmdResolveImage2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResolveImage2)); + vkCmdResolveImage2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResolveImage2KHR)); + vkCmdSetFragmentShadingRateKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetFragmentShadingRateKHR)); + vkCmdSetFragmentShadingRateEnumNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetFragmentShadingRateEnumNV)); + vkGetAccelerationStructureBuildSizesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAccelerationStructureBuildSizesKHR)); + vkCmdSetVertexInputEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetVertexInputEXT)); + vkCmdSetColorWriteEnableEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetColorWriteEnableEXT)); + vkCmdSetEvent2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetEvent2)); + vkCmdSetEvent2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetEvent2KHR)); + vkCmdResetEvent2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResetEvent2)); + vkCmdResetEvent2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdResetEvent2KHR)); + vkCmdWaitEvents2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWaitEvents2)); + vkCmdWaitEvents2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWaitEvents2KHR)); + vkCmdPipelineBarrier2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPipelineBarrier2)); + vkCmdPipelineBarrier2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPipelineBarrier2KHR)); + vkQueueSubmit2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueSubmit2)); + vkQueueSubmit2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueSubmit2KHR)); + vkCmdWriteTimestamp2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteTimestamp2)); + vkCmdWriteTimestamp2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteTimestamp2KHR)); + vkCmdWriteBufferMarker2AMD = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteBufferMarker2AMD)); + vkGetQueueCheckpointData2NV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetQueueCheckpointData2NV)); + vkCopyMemoryToImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMemoryToImage)); + vkCopyMemoryToImageEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMemoryToImageEXT)); + vkCopyImageToMemory = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyImageToMemory)); + vkCopyImageToMemoryEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyImageToMemoryEXT)); + vkCopyImageToImage = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyImageToImage)); + vkCopyImageToImageEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyImageToImageEXT)); + vkTransitionImageLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkTransitionImageLayout)); + vkTransitionImageLayoutEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkTransitionImageLayoutEXT)); + vkCreateVideoSessionKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateVideoSessionKHR)); + vkDestroyVideoSessionKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyVideoSessionKHR)); + vkCreateVideoSessionParametersKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateVideoSessionParametersKHR)); + vkUpdateVideoSessionParametersKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUpdateVideoSessionParametersKHR)); + vkGetEncodedVideoSessionParametersKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetEncodedVideoSessionParametersKHR)); + vkDestroyVideoSessionParametersKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyVideoSessionParametersKHR)); + vkGetVideoSessionMemoryRequirementsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetVideoSessionMemoryRequirementsKHR)); + vkBindVideoSessionMemoryKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindVideoSessionMemoryKHR)); + vkCmdDecodeVideoKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDecodeVideoKHR)); + vkCmdBeginVideoCodingKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginVideoCodingKHR)); + vkCmdControlVideoCodingKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdControlVideoCodingKHR)); + vkCmdEndVideoCodingKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndVideoCodingKHR)); + vkCmdEncodeVideoKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEncodeVideoKHR)); + vkCmdDecompressMemoryNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDecompressMemoryNV)); + vkCmdDecompressMemoryIndirectCountNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDecompressMemoryIndirectCountNV)); + vkGetPartitionedAccelerationStructuresBuildSizesNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPartitionedAccelerationStructuresBuildSizesNV)); + vkCmdBuildPartitionedAccelerationStructuresNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildPartitionedAccelerationStructuresNV)); + vkCmdDecompressMemoryEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDecompressMemoryEXT)); + vkCmdDecompressMemoryIndirectCountEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDecompressMemoryIndirectCountEXT)); + vkCreateCuModuleNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateCuModuleNVX)); + vkCreateCuFunctionNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateCuFunctionNVX)); + vkDestroyCuModuleNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyCuModuleNVX)); + vkDestroyCuFunctionNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyCuFunctionNVX)); + vkCmdCuLaunchKernelNVX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCuLaunchKernelNVX)); + vkGetDescriptorSetLayoutSizeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetLayoutSizeEXT)); + vkGetDescriptorSetLayoutBindingOffsetEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetLayoutBindingOffsetEXT)); + vkGetDescriptorEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorEXT)); + vkCmdBindDescriptorBuffersEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorBuffersEXT)); + vkCmdSetDescriptorBufferOffsetsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDescriptorBufferOffsetsEXT)); + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorBufferEmbeddedSamplersEXT)); + vkGetBufferOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferOpaqueCaptureDescriptorDataEXT)); + vkGetImageOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageOpaqueCaptureDescriptorDataEXT)); + vkGetImageViewOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageViewOpaqueCaptureDescriptorDataEXT)); + vkGetSamplerOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSamplerOpaqueCaptureDescriptorDataEXT)); + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)); + vkSetDeviceMemoryPriorityEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetDeviceMemoryPriorityEXT)); + vkWaitForPresent2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWaitForPresent2KHR)); + vkWaitForPresentKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWaitForPresentKHR)); + vkCreateBufferCollectionFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateBufferCollectionFUCHSIA)); + vkSetBufferCollectionBufferConstraintsFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetBufferCollectionBufferConstraintsFUCHSIA)); + vkSetBufferCollectionImageConstraintsFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetBufferCollectionImageConstraintsFUCHSIA)); + vkDestroyBufferCollectionFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyBufferCollectionFUCHSIA)); + vkGetBufferCollectionPropertiesFUCHSIA = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetBufferCollectionPropertiesFUCHSIA)); + vkCreateCudaModuleNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateCudaModuleNV)); + vkGetCudaModuleCacheNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetCudaModuleCacheNV)); + vkCreateCudaFunctionNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateCudaFunctionNV)); + vkDestroyCudaModuleNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyCudaModuleNV)); + vkDestroyCudaFunctionNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyCudaFunctionNV)); + vkCmdCudaLaunchKernelNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCudaLaunchKernelNV)); + vkCmdBeginRendering = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginRendering)); + vkCmdBeginRenderingKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginRenderingKHR)); + vkCmdEndRendering = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRendering)); + vkCmdEndRendering2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRendering2KHR)); + vkCmdEndRendering2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRendering2EXT)); + vkCmdEndRenderingKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndRenderingKHR)); + vkGetDescriptorSetLayoutHostMappingInfoVALVE = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetLayoutHostMappingInfoVALVE)); + vkGetDescriptorSetHostMappingVALVE = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDescriptorSetHostMappingVALVE)); + vkCreateMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateMicromapEXT)); + vkCmdBuildMicromapsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBuildMicromapsEXT)); + vkBuildMicromapsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBuildMicromapsEXT)); + vkDestroyMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyMicromapEXT)); + vkCmdCopyMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMicromapEXT)); + vkCopyMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMicromapEXT)); + vkCmdCopyMicromapToMemoryEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMicromapToMemoryEXT)); + vkCopyMicromapToMemoryEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMicromapToMemoryEXT)); + vkCmdCopyMemoryToMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyMemoryToMicromapEXT)); + vkCopyMemoryToMicromapEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCopyMemoryToMicromapEXT)); + vkCmdWriteMicromapsPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdWriteMicromapsPropertiesEXT)); + vkWriteMicromapsPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkWriteMicromapsPropertiesEXT)); + vkGetDeviceMicromapCompatibilityEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceMicromapCompatibilityEXT)); + vkGetMicromapBuildSizesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMicromapBuildSizesEXT)); + vkGetShaderModuleIdentifierEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetShaderModuleIdentifierEXT)); + vkGetShaderModuleCreateInfoIdentifierEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetShaderModuleCreateInfoIdentifierEXT)); + vkGetImageSubresourceLayout2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSubresourceLayout2)); + vkGetImageSubresourceLayout2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSubresourceLayout2KHR)); + vkGetImageSubresourceLayout2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetImageSubresourceLayout2EXT)); + vkGetPipelinePropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPipelinePropertiesEXT)); + vkExportMetalObjectsEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkExportMetalObjectsEXT)); + vkCmdBindTileMemoryQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindTileMemoryQCOM)); + vkGetFramebufferTilePropertiesQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetFramebufferTilePropertiesQCOM)); + vkGetDynamicRenderingTilePropertiesQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDynamicRenderingTilePropertiesQCOM)); + vkCreateOpticalFlowSessionNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateOpticalFlowSessionNV)); + vkDestroyOpticalFlowSessionNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyOpticalFlowSessionNV)); + vkBindOpticalFlowSessionImageNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindOpticalFlowSessionImageNV)); + vkCmdOpticalFlowExecuteNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdOpticalFlowExecuteNV)); + vkGetDeviceFaultInfoEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceFaultInfoEXT)); + vkCmdSetDepthBias2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthBias2EXT)); + vkReleaseSwapchainImagesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleaseSwapchainImagesKHR)); + vkReleaseSwapchainImagesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkReleaseSwapchainImagesEXT)); + vkGetDeviceImageSubresourceLayout = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageSubresourceLayout)); + vkGetDeviceImageSubresourceLayoutKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceImageSubresourceLayoutKHR)); + vkMapMemory2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkMapMemory2)); + vkMapMemory2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkMapMemory2KHR)); + vkUnmapMemory2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUnmapMemory2)); + vkUnmapMemory2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkUnmapMemory2KHR)); + vkCreateShadersEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateShadersEXT)); + vkDestroyShaderEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyShaderEXT)); + vkGetShaderBinaryDataEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetShaderBinaryDataEXT)); + vkCmdBindShadersEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindShadersEXT)); + vkSetSwapchainPresentTimingQueueSizeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetSwapchainPresentTimingQueueSizeEXT)); + vkGetSwapchainTimingPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainTimingPropertiesEXT)); + vkGetSwapchainTimeDomainPropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainTimeDomainPropertiesEXT)); + vkGetPastPresentationTimingEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetPastPresentationTimingEXT)); + vkGetScreenBufferPropertiesQNX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetScreenBufferPropertiesQNX)); + vkGetExecutionGraphPipelineScratchSizeAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetExecutionGraphPipelineScratchSizeAMDX)); + vkGetExecutionGraphPipelineNodeIndexAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetExecutionGraphPipelineNodeIndexAMDX)); + vkCreateExecutionGraphPipelinesAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateExecutionGraphPipelinesAMDX)); + vkCmdInitializeGraphScratchMemoryAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdInitializeGraphScratchMemoryAMDX)); + vkCmdDispatchGraphAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchGraphAMDX)); + vkCmdDispatchGraphIndirectAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchGraphIndirectAMDX)); + vkCmdDispatchGraphIndirectCountAMDX = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchGraphIndirectCountAMDX)); + vkCmdBindDescriptorSets2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorSets2)); + vkCmdBindDescriptorSets2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorSets2KHR)); + vkCmdPushConstants2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushConstants2)); + vkCmdPushConstants2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushConstants2KHR)); + vkCmdPushDescriptorSet2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSet2)); + vkCmdPushDescriptorSet2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSet2KHR)); + vkCmdPushDescriptorSetWithTemplate2 = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSetWithTemplate2)); + vkCmdPushDescriptorSetWithTemplate2KHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdPushDescriptorSetWithTemplate2KHR)); + vkCmdSetDescriptorBufferOffsets2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDescriptorBufferOffsets2EXT)); + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)); + vkSetLatencySleepModeNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetLatencySleepModeNV)); + vkLatencySleepNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkLatencySleepNV)); + vkSetLatencyMarkerNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkSetLatencyMarkerNV)); + vkGetLatencyTimingsNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetLatencyTimingsNV)); + vkQueueNotifyOutOfBandNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueNotifyOutOfBandNV)); + vkCmdSetRenderingAttachmentLocations = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRenderingAttachmentLocations)); + vkCmdSetRenderingAttachmentLocationsKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRenderingAttachmentLocationsKHR)); + vkCmdSetRenderingInputAttachmentIndices = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRenderingInputAttachmentIndices)); + vkCmdSetRenderingInputAttachmentIndicesKHR = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetRenderingInputAttachmentIndicesKHR)); + vkCmdSetDepthClampRangeEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdSetDepthClampRangeEXT)); + vkGetMemoryMetalHandleEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryMetalHandleEXT)); + vkGetMemoryMetalHandlePropertiesEXT = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryMetalHandlePropertiesEXT)); + vkConvertCooperativeVectorMatrixNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkConvertCooperativeVectorMatrixNV)); + vkCmdConvertCooperativeVectorMatrixNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdConvertCooperativeVectorMatrixNV)); + vkCmdDispatchTileQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchTileQCOM)); + vkCmdBeginPerTileExecutionQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdBeginPerTileExecutionQCOM)); + vkCmdEndPerTileExecutionQCOM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdEndPerTileExecutionQCOM)); + vkCreateExternalComputeQueueNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateExternalComputeQueueNV)); + vkDestroyExternalComputeQueueNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyExternalComputeQueueNV)); + vkGetExternalComputeQueueDataNV = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetExternalComputeQueueDataNV)); + vkCreateTensorARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateTensorARM)); + vkDestroyTensorARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyTensorARM)); + vkCreateTensorViewARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateTensorViewARM)); + vkDestroyTensorViewARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyTensorViewARM)); + vkGetTensorMemoryRequirementsARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetTensorMemoryRequirementsARM)); + vkBindTensorMemoryARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindTensorMemoryARM)); + vkGetDeviceTensorMemoryRequirementsARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDeviceTensorMemoryRequirementsARM)); + vkCmdCopyTensorARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdCopyTensorARM)); + vkGetTensorOpaqueCaptureDescriptorDataARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetTensorOpaqueCaptureDescriptorDataARM)); + vkGetTensorViewOpaqueCaptureDescriptorDataARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetTensorViewOpaqueCaptureDescriptorDataARM)); + vkCreateDataGraphPipelinesARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDataGraphPipelinesARM)); + vkCreateDataGraphPipelineSessionARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCreateDataGraphPipelineSessionARM)); + vkGetDataGraphPipelineSessionBindPointRequirementsARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDataGraphPipelineSessionBindPointRequirementsARM)); + vkGetDataGraphPipelineSessionMemoryRequirementsARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDataGraphPipelineSessionMemoryRequirementsARM)); + vkBindDataGraphPipelineSessionMemoryARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkBindDataGraphPipelineSessionMemoryARM)); + vkDestroyDataGraphPipelineSessionARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkDestroyDataGraphPipelineSessionARM)); + vkCmdDispatchDataGraphARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkCmdDispatchDataGraphARM)); + vkGetDataGraphPipelineAvailablePropertiesARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDataGraphPipelineAvailablePropertiesARM)); + vkGetDataGraphPipelinePropertiesARM = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetDataGraphPipelinePropertiesARM)); + vkGetNativeBufferPropertiesOHOS = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetNativeBufferPropertiesOHOS)); + vkGetMemoryNativeBufferOHOS = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetMemoryNativeBufferOHOS)); + vkGetSwapchainGrallocUsageOHOS = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkGetSwapchainGrallocUsageOHOS)); + vkAcquireImageOHOS = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkAcquireImageOHOS)); + vkQueueSignalReleaseImageOHOS = (.)(void*)vkGetDeviceProcAddr(device, nameof(vkQueueSignalReleaseImageOHOS)); + } + + public void LoadTrampoline(VkInstance instance) mut + { + vkDestroyInstance = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyInstance)); + vkEnumeratePhysicalDevices = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDevices)); + vkGetInstanceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetInstanceProcAddr)); + vkGetPhysicalDeviceProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties)); + vkGetPhysicalDeviceQueueFamilyProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties)); + vkGetPhysicalDeviceMemoryProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties)); + vkGetPhysicalDeviceFeatures = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures)); + vkGetPhysicalDeviceFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties)); + vkGetPhysicalDeviceImageFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties)); + vkCreateDevice = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDevice)); + vkEnumerateDeviceLayerProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumerateDeviceLayerProperties)); + vkEnumerateDeviceExtensionProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumerateDeviceExtensionProperties)); + vkGetPhysicalDeviceSparseImageFormatProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties)); + vkCreateAndroidSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateAndroidSurfaceKHR)); + vkCreateSurfaceOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSurfaceOHOS)); + vkGetPhysicalDeviceDisplayPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPropertiesKHR)); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPlanePropertiesKHR)); + vkGetDisplayPlaneSupportedDisplaysKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneSupportedDisplaysKHR)); + vkGetDisplayModePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayModePropertiesKHR)); + vkCreateDisplayModeKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDisplayModeKHR)); + vkGetDisplayPlaneCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneCapabilitiesKHR)); + vkCreateDisplayPlaneSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDisplayPlaneSurfaceKHR)); + vkDestroySurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySurfaceKHR)); + vkGetPhysicalDeviceSurfaceSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceSupportKHR)); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)); + vkGetPhysicalDeviceSurfaceFormatsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceFormatsKHR)); + vkGetPhysicalDeviceSurfacePresentModesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfacePresentModesKHR)); + vkCreateViSurfaceNN = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateViSurfaceNN)); + vkCreateWaylandSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateWaylandSurfaceKHR)); + vkGetPhysicalDeviceWaylandPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceWaylandPresentationSupportKHR)); + vkCreateWin32SurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateWin32SurfaceKHR)); + vkGetPhysicalDeviceWin32PresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceWin32PresentationSupportKHR)); + vkCreateXlibSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateXlibSurfaceKHR)); + vkGetPhysicalDeviceXlibPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceXlibPresentationSupportKHR)); + vkCreateXcbSurfaceKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateXcbSurfaceKHR)); + vkGetPhysicalDeviceXcbPresentationSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceXcbPresentationSupportKHR)); + vkCreateDirectFBSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDirectFBSurfaceEXT)); + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDirectFBPresentationSupportEXT)); + vkCreateImagePipeSurfaceFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateImagePipeSurfaceFUCHSIA)); + vkCreateStreamDescriptorSurfaceGGP = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateStreamDescriptorSurfaceGGP)); + vkCreateScreenSurfaceQNX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateScreenSurfaceQNX)); + vkGetPhysicalDeviceScreenPresentationSupportQNX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceScreenPresentationSupportQNX)); + vkCreateDebugReportCallbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDebugReportCallbackEXT)); + vkDestroyDebugReportCallbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDebugReportCallbackEXT)); + vkDebugReportMessageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDebugReportMessageEXT)); + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalImageFormatPropertiesNV)); + vkGetPhysicalDeviceFeatures2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures2)); + vkGetPhysicalDeviceFeatures2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFeatures2KHR)); + vkGetPhysicalDeviceProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties2)); + vkGetPhysicalDeviceProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceProperties2KHR)); + vkGetPhysicalDeviceFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties2)); + vkGetPhysicalDeviceFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFormatProperties2KHR)); + vkGetPhysicalDeviceImageFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties2)); + vkGetPhysicalDeviceImageFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceImageFormatProperties2KHR)); + vkGetPhysicalDeviceQueueFamilyProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties2)); + vkGetPhysicalDeviceQueueFamilyProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyProperties2KHR)); + vkGetPhysicalDeviceMemoryProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties2)); + vkGetPhysicalDeviceMemoryProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMemoryProperties2KHR)); + vkGetPhysicalDeviceSparseImageFormatProperties2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties2)); + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSparseImageFormatProperties2KHR)); + vkGetPhysicalDeviceExternalBufferProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalBufferProperties)); + vkGetPhysicalDeviceExternalBufferPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalBufferPropertiesKHR)); + vkGetPhysicalDeviceExternalSemaphoreProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalSemaphoreProperties)); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)); + vkGetPhysicalDeviceExternalFenceProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalFenceProperties)); + vkGetPhysicalDeviceExternalFencePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalFencePropertiesKHR)); + vkReleaseDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseDisplayEXT)); + vkAcquireXlibDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireXlibDisplayEXT)); + vkGetRandROutputDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRandROutputDisplayEXT)); + vkAcquireWinrtDisplayNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireWinrtDisplayNV)); + vkGetWinrtDisplayNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetWinrtDisplayNV)); + vkGetPhysicalDeviceSurfaceCapabilities2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilities2EXT)); + vkEnumeratePhysicalDeviceGroups = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceGroups)); + vkEnumeratePhysicalDeviceGroupsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceGroupsKHR)); + vkGetPhysicalDevicePresentRectanglesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDevicePresentRectanglesKHR)); + vkCreateIOSSurfaceMVK = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateIOSSurfaceMVK)); + vkCreateMacOSSurfaceMVK = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateMacOSSurfaceMVK)); + vkCreateMetalSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateMetalSurfaceEXT)); + vkGetPhysicalDeviceMultisamplePropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceMultisamplePropertiesEXT)); + vkGetPhysicalDeviceSurfaceCapabilities2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceCapabilities2KHR)); + vkGetPhysicalDeviceSurfaceFormats2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfaceFormats2KHR)); + vkGetPhysicalDeviceDisplayProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayProperties2KHR)); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceDisplayPlaneProperties2KHR)); + vkGetDisplayModeProperties2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayModeProperties2KHR)); + vkGetDisplayPlaneCapabilities2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDisplayPlaneCapabilities2KHR)); + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)); + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)); + vkCreateDebugUtilsMessengerEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDebugUtilsMessengerEXT)); + vkDestroyDebugUtilsMessengerEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDebugUtilsMessengerEXT)); + vkSubmitDebugUtilsMessageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSubmitDebugUtilsMessageEXT)); + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)); + vkGetPhysicalDeviceSurfacePresentModes2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSurfacePresentModes2EXT)); + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)); + vkCreateHeadlessSurfaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateHeadlessSurfaceEXT)); + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)); + vkGetPhysicalDeviceToolProperties = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceToolProperties)); + vkGetPhysicalDeviceToolPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceToolPropertiesEXT)); + vkGetPhysicalDeviceFragmentShadingRatesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceFragmentShadingRatesKHR)); + vkGetPhysicalDeviceVideoCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoCapabilitiesKHR)); + vkGetPhysicalDeviceVideoFormatPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoFormatPropertiesKHR)); + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)); + vkAcquireDrmDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireDrmDisplayEXT)); + vkGetDrmDisplayEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDrmDisplayEXT)); + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceOpticalFlowImageFormatsNV)); + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)); + vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)); + vkGetPhysicalDeviceCooperativeVectorPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceCooperativeVectorPropertiesNV)); + vkGetPhysicalDeviceExternalTensorPropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceExternalTensorPropertiesARM)); + vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)); + vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)); + vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)); + vkGetDeviceProcAddr = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceProcAddr)); + vkDestroyDevice = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDevice)); + vkGetDeviceQueue = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceQueue)); + vkQueueSubmit = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueSubmit)); + vkQueueWaitIdle = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueWaitIdle)); + vkDeviceWaitIdle = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDeviceWaitIdle)); + vkAllocateMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAllocateMemory)); + vkFreeMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkFreeMemory)); + vkMapMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkMapMemory)); + vkUnmapMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUnmapMemory)); + vkFlushMappedMemoryRanges = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkFlushMappedMemoryRanges)); + vkInvalidateMappedMemoryRanges = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkInvalidateMappedMemoryRanges)); + vkGetDeviceMemoryCommitment = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceMemoryCommitment)); + vkGetBufferMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferMemoryRequirements)); + vkBindBufferMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindBufferMemory)); + vkGetImageMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageMemoryRequirements)); + vkBindImageMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindImageMemory)); + vkGetImageSparseMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSparseMemoryRequirements)); + vkQueueBindSparse = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueBindSparse)); + vkCreateFence = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateFence)); + vkDestroyFence = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyFence)); + vkResetFences = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetFences)); + vkGetFenceStatus = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetFenceStatus)); + vkWaitForFences = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWaitForFences)); + vkCreateSemaphore = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSemaphore)); + vkDestroySemaphore = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySemaphore)); + vkCreateEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateEvent)); + vkDestroyEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyEvent)); + vkGetEventStatus = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetEventStatus)); + vkSetEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetEvent)); + vkResetEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetEvent)); + vkCreateQueryPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateQueryPool)); + vkDestroyQueryPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyQueryPool)); + vkGetQueryPoolResults = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetQueryPoolResults)); + vkResetQueryPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetQueryPool)); + vkResetQueryPoolEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetQueryPoolEXT)); + vkCreateBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateBuffer)); + vkDestroyBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyBuffer)); + vkCreateBufferView = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateBufferView)); + vkDestroyBufferView = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyBufferView)); + vkCreateImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateImage)); + vkDestroyImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyImage)); + vkGetImageSubresourceLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSubresourceLayout)); + vkCreateImageView = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateImageView)); + vkDestroyImageView = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyImageView)); + vkCreateShaderModule = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateShaderModule)); + vkDestroyShaderModule = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyShaderModule)); + vkCreatePipelineCache = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreatePipelineCache)); + vkDestroyPipelineCache = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPipelineCache)); + vkGetPipelineCacheData = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineCacheData)); + vkMergePipelineCaches = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkMergePipelineCaches)); + vkCreatePipelineBinariesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreatePipelineBinariesKHR)); + vkDestroyPipelineBinaryKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPipelineBinaryKHR)); + vkGetPipelineKeyKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineKeyKHR)); + vkGetPipelineBinaryDataKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineBinaryDataKHR)); + vkReleaseCapturedPipelineDataKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseCapturedPipelineDataKHR)); + vkCreateGraphicsPipelines = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateGraphicsPipelines)); + vkCreateComputePipelines = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateComputePipelines)); + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)); + vkDestroyPipeline = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPipeline)); + vkCreatePipelineLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreatePipelineLayout)); + vkDestroyPipelineLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPipelineLayout)); + vkCreateSampler = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSampler)); + vkDestroySampler = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySampler)); + vkCreateDescriptorSetLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDescriptorSetLayout)); + vkDestroyDescriptorSetLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDescriptorSetLayout)); + vkCreateDescriptorPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDescriptorPool)); + vkDestroyDescriptorPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDescriptorPool)); + vkResetDescriptorPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetDescriptorPool)); + vkAllocateDescriptorSets = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAllocateDescriptorSets)); + vkFreeDescriptorSets = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkFreeDescriptorSets)); + vkUpdateDescriptorSets = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateDescriptorSets)); + vkCreateFramebuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateFramebuffer)); + vkDestroyFramebuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyFramebuffer)); + vkCreateRenderPass = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateRenderPass)); + vkDestroyRenderPass = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyRenderPass)); + vkGetRenderAreaGranularity = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRenderAreaGranularity)); + vkGetRenderingAreaGranularity = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRenderingAreaGranularity)); + vkGetRenderingAreaGranularityKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRenderingAreaGranularityKHR)); + vkCreateCommandPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateCommandPool)); + vkDestroyCommandPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyCommandPool)); + vkResetCommandPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetCommandPool)); + vkAllocateCommandBuffers = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAllocateCommandBuffers)); + vkFreeCommandBuffers = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkFreeCommandBuffers)); + vkBeginCommandBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBeginCommandBuffer)); + vkEndCommandBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkEndCommandBuffer)); + vkResetCommandBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkResetCommandBuffer)); + vkCmdBindPipeline = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindPipeline)); + vkCmdSetAttachmentFeedbackLoopEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetAttachmentFeedbackLoopEnableEXT)); + vkCmdSetViewport = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewport)); + vkCmdSetScissor = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetScissor)); + vkCmdSetLineWidth = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineWidth)); + vkCmdSetDepthBias = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBias)); + vkCmdSetBlendConstants = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetBlendConstants)); + vkCmdSetDepthBounds = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBounds)); + vkCmdSetStencilCompareMask = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilCompareMask)); + vkCmdSetStencilWriteMask = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilWriteMask)); + vkCmdSetStencilReference = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilReference)); + vkCmdBindDescriptorSets = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorSets)); + vkCmdBindIndexBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindIndexBuffer)); + vkCmdBindVertexBuffers = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindVertexBuffers)); + vkCmdDraw = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDraw)); + vkCmdDrawIndexed = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndexed)); + vkCmdDrawMultiEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMultiEXT)); + vkCmdDrawMultiIndexedEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMultiIndexedEXT)); + vkCmdDrawIndirect = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndirect)); + vkCmdDrawIndexedIndirect = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndexedIndirect)); + vkCmdDispatch = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatch)); + vkCmdDispatchIndirect = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchIndirect)); + vkCmdSubpassShadingHUAWEI = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSubpassShadingHUAWEI)); + vkCmdDrawClusterHUAWEI = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawClusterHUAWEI)); + vkCmdDrawClusterIndirectHUAWEI = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawClusterIndirectHUAWEI)); + vkCmdUpdatePipelineIndirectBufferNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdUpdatePipelineIndirectBufferNV)); + vkCmdCopyBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBuffer)); + vkCmdCopyImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImage)); + vkCmdBlitImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBlitImage)); + vkCmdCopyBufferToImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBufferToImage)); + vkCmdCopyImageToBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImageToBuffer)); + vkCmdCopyMemoryIndirectNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryIndirectNV)); + vkCmdCopyMemoryIndirectKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryIndirectKHR)); + vkCmdCopyMemoryToImageIndirectNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryToImageIndirectNV)); + vkCmdCopyMemoryToImageIndirectKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryToImageIndirectKHR)); + vkCmdUpdateBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdUpdateBuffer)); + vkCmdFillBuffer = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdFillBuffer)); + vkCmdClearColorImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdClearColorImage)); + vkCmdClearDepthStencilImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdClearDepthStencilImage)); + vkCmdClearAttachments = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdClearAttachments)); + vkCmdResolveImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResolveImage)); + vkCmdSetEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetEvent)); + vkCmdResetEvent = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResetEvent)); + vkCmdWaitEvents = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWaitEvents)); + vkCmdPipelineBarrier = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPipelineBarrier)); + vkCmdBeginQuery = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginQuery)); + vkCmdEndQuery = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndQuery)); + vkCmdBeginConditionalRenderingEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginConditionalRenderingEXT)); + vkCmdEndConditionalRenderingEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndConditionalRenderingEXT)); + vkCmdBeginCustomResolveEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginCustomResolveEXT)); + vkCmdResetQueryPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResetQueryPool)); + vkCmdWriteTimestamp = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteTimestamp)); + vkCmdCopyQueryPoolResults = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyQueryPoolResults)); + vkCmdPushConstants = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushConstants)); + vkCmdBeginRenderPass = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginRenderPass)); + vkCmdNextSubpass = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdNextSubpass)); + vkCmdEndRenderPass = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRenderPass)); + vkCmdExecuteCommands = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdExecuteCommands)); + vkCreateSharedSwapchainsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSharedSwapchainsKHR)); + vkCreateSwapchainKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSwapchainKHR)); + vkDestroySwapchainKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySwapchainKHR)); + vkGetSwapchainImagesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainImagesKHR)); + vkAcquireNextImageKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireNextImageKHR)); + vkQueuePresentKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueuePresentKHR)); + vkDebugMarkerSetObjectNameEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDebugMarkerSetObjectNameEXT)); + vkDebugMarkerSetObjectTagEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDebugMarkerSetObjectTagEXT)); + vkCmdDebugMarkerBeginEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDebugMarkerBeginEXT)); + vkCmdDebugMarkerEndEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDebugMarkerEndEXT)); + vkCmdDebugMarkerInsertEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDebugMarkerInsertEXT)); + vkGetMemoryWin32HandleNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryWin32HandleNV)); + vkCmdExecuteGeneratedCommandsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdExecuteGeneratedCommandsNV)); + vkCmdPreprocessGeneratedCommandsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPreprocessGeneratedCommandsNV)); + vkCmdBindPipelineShaderGroupNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindPipelineShaderGroupNV)); + vkGetGeneratedCommandsMemoryRequirementsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetGeneratedCommandsMemoryRequirementsNV)); + vkCreateIndirectCommandsLayoutNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateIndirectCommandsLayoutNV)); + vkDestroyIndirectCommandsLayoutNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyIndirectCommandsLayoutNV)); + vkCmdExecuteGeneratedCommandsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdExecuteGeneratedCommandsEXT)); + vkCmdPreprocessGeneratedCommandsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPreprocessGeneratedCommandsEXT)); + vkGetGeneratedCommandsMemoryRequirementsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetGeneratedCommandsMemoryRequirementsEXT)); + vkCreateIndirectCommandsLayoutEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateIndirectCommandsLayoutEXT)); + vkDestroyIndirectCommandsLayoutEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyIndirectCommandsLayoutEXT)); + vkCreateIndirectExecutionSetEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateIndirectExecutionSetEXT)); + vkDestroyIndirectExecutionSetEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyIndirectExecutionSetEXT)); + vkUpdateIndirectExecutionSetPipelineEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateIndirectExecutionSetPipelineEXT)); + vkUpdateIndirectExecutionSetShaderEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateIndirectExecutionSetShaderEXT)); + vkCmdPushDescriptorSet = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSet)); + vkCmdPushDescriptorSetKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSetKHR)); + vkTrimCommandPool = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkTrimCommandPool)); + vkTrimCommandPoolKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkTrimCommandPoolKHR)); + vkGetMemoryWin32HandleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryWin32HandleKHR)); + vkGetMemoryWin32HandlePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryWin32HandlePropertiesKHR)); + vkGetMemoryFdKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryFdKHR)); + vkGetMemoryFdPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryFdPropertiesKHR)); + vkGetMemoryZirconHandleFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryZirconHandleFUCHSIA)); + vkGetMemoryZirconHandlePropertiesFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryZirconHandlePropertiesFUCHSIA)); + vkGetMemoryRemoteAddressNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryRemoteAddressNV)); + vkGetSemaphoreWin32HandleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSemaphoreWin32HandleKHR)); + vkImportSemaphoreWin32HandleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkImportSemaphoreWin32HandleKHR)); + vkGetSemaphoreFdKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSemaphoreFdKHR)); + vkImportSemaphoreFdKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkImportSemaphoreFdKHR)); + vkGetSemaphoreZirconHandleFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSemaphoreZirconHandleFUCHSIA)); + vkImportSemaphoreZirconHandleFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkImportSemaphoreZirconHandleFUCHSIA)); + vkGetFenceWin32HandleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetFenceWin32HandleKHR)); + vkImportFenceWin32HandleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkImportFenceWin32HandleKHR)); + vkGetFenceFdKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetFenceFdKHR)); + vkImportFenceFdKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkImportFenceFdKHR)); + vkDisplayPowerControlEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDisplayPowerControlEXT)); + vkRegisterDeviceEventEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkRegisterDeviceEventEXT)); + vkRegisterDisplayEventEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkRegisterDisplayEventEXT)); + vkGetSwapchainCounterEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainCounterEXT)); + vkGetDeviceGroupPeerMemoryFeatures = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceGroupPeerMemoryFeatures)); + vkGetDeviceGroupPeerMemoryFeaturesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceGroupPeerMemoryFeaturesKHR)); + vkBindBufferMemory2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindBufferMemory2)); + vkBindBufferMemory2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindBufferMemory2KHR)); + vkBindImageMemory2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindImageMemory2)); + vkBindImageMemory2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindImageMemory2KHR)); + vkCmdSetDeviceMask = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDeviceMask)); + vkCmdSetDeviceMaskKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDeviceMaskKHR)); + vkGetDeviceGroupPresentCapabilitiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceGroupPresentCapabilitiesKHR)); + vkGetDeviceGroupSurfacePresentModesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceGroupSurfacePresentModesKHR)); + vkAcquireNextImage2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireNextImage2KHR)); + vkCmdDispatchBase = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchBase)); + vkCmdDispatchBaseKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchBaseKHR)); + vkCreateDescriptorUpdateTemplate = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDescriptorUpdateTemplate)); + vkCreateDescriptorUpdateTemplateKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDescriptorUpdateTemplateKHR)); + vkDestroyDescriptorUpdateTemplate = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDescriptorUpdateTemplate)); + vkDestroyDescriptorUpdateTemplateKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDescriptorUpdateTemplateKHR)); + vkUpdateDescriptorSetWithTemplate = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateDescriptorSetWithTemplate)); + vkUpdateDescriptorSetWithTemplateKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateDescriptorSetWithTemplateKHR)); + vkCmdPushDescriptorSetWithTemplate = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSetWithTemplate)); + vkCmdPushDescriptorSetWithTemplateKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSetWithTemplateKHR)); + vkSetHdrMetadataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetHdrMetadataEXT)); + vkGetSwapchainStatusKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainStatusKHR)); + vkGetRefreshCycleDurationGOOGLE = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRefreshCycleDurationGOOGLE)); + vkGetPastPresentationTimingGOOGLE = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPastPresentationTimingGOOGLE)); + vkCmdSetViewportWScalingNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportWScalingNV)); + vkCmdSetDiscardRectangleEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDiscardRectangleEXT)); + vkCmdSetDiscardRectangleEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDiscardRectangleEnableEXT)); + vkCmdSetDiscardRectangleModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDiscardRectangleModeEXT)); + vkCmdSetSampleLocationsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetSampleLocationsEXT)); + vkGetBufferMemoryRequirements2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferMemoryRequirements2)); + vkGetBufferMemoryRequirements2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferMemoryRequirements2KHR)); + vkGetImageMemoryRequirements2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageMemoryRequirements2)); + vkGetImageMemoryRequirements2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageMemoryRequirements2KHR)); + vkGetImageSparseMemoryRequirements2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSparseMemoryRequirements2)); + vkGetImageSparseMemoryRequirements2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSparseMemoryRequirements2KHR)); + vkGetDeviceBufferMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceBufferMemoryRequirements)); + vkGetDeviceBufferMemoryRequirementsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceBufferMemoryRequirementsKHR)); + vkGetDeviceImageMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageMemoryRequirements)); + vkGetDeviceImageMemoryRequirementsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageMemoryRequirementsKHR)); + vkGetDeviceImageSparseMemoryRequirements = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageSparseMemoryRequirements)); + vkGetDeviceImageSparseMemoryRequirementsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageSparseMemoryRequirementsKHR)); + vkCreateSamplerYcbcrConversion = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSamplerYcbcrConversion)); + vkCreateSamplerYcbcrConversionKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateSamplerYcbcrConversionKHR)); + vkDestroySamplerYcbcrConversion = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySamplerYcbcrConversion)); + vkDestroySamplerYcbcrConversionKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroySamplerYcbcrConversionKHR)); + vkGetDeviceQueue2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceQueue2)); + vkCreateValidationCacheEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateValidationCacheEXT)); + vkDestroyValidationCacheEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyValidationCacheEXT)); + vkGetValidationCacheDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetValidationCacheDataEXT)); + vkMergeValidationCachesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkMergeValidationCachesEXT)); + vkGetDescriptorSetLayoutSupport = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetLayoutSupport)); + vkGetDescriptorSetLayoutSupportKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetLayoutSupportKHR)); + vkGetShaderInfoAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetShaderInfoAMD)); + vkSetLocalDimmingAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetLocalDimmingAMD)); + vkGetCalibratedTimestampsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetCalibratedTimestampsKHR)); + vkGetCalibratedTimestampsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetCalibratedTimestampsEXT)); + vkSetDebugUtilsObjectNameEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetDebugUtilsObjectNameEXT)); + vkSetDebugUtilsObjectTagEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetDebugUtilsObjectTagEXT)); + vkQueueBeginDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueBeginDebugUtilsLabelEXT)); + vkQueueEndDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueEndDebugUtilsLabelEXT)); + vkQueueInsertDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueInsertDebugUtilsLabelEXT)); + vkCmdBeginDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginDebugUtilsLabelEXT)); + vkCmdEndDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndDebugUtilsLabelEXT)); + vkCmdInsertDebugUtilsLabelEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdInsertDebugUtilsLabelEXT)); + vkGetMemoryHostPointerPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryHostPointerPropertiesEXT)); + vkCmdWriteBufferMarkerAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteBufferMarkerAMD)); + vkCreateRenderPass2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateRenderPass2)); + vkCreateRenderPass2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateRenderPass2KHR)); + vkCmdBeginRenderPass2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginRenderPass2)); + vkCmdBeginRenderPass2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginRenderPass2KHR)); + vkCmdNextSubpass2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdNextSubpass2)); + vkCmdNextSubpass2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdNextSubpass2KHR)); + vkCmdEndRenderPass2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRenderPass2)); + vkCmdEndRenderPass2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRenderPass2KHR)); + vkGetSemaphoreCounterValue = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSemaphoreCounterValue)); + vkGetSemaphoreCounterValueKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSemaphoreCounterValueKHR)); + vkWaitSemaphores = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWaitSemaphores)); + vkWaitSemaphoresKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWaitSemaphoresKHR)); + vkSignalSemaphore = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSignalSemaphore)); + vkSignalSemaphoreKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSignalSemaphoreKHR)); + vkGetAndroidHardwareBufferPropertiesANDROID = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAndroidHardwareBufferPropertiesANDROID)); + vkGetMemoryAndroidHardwareBufferANDROID = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryAndroidHardwareBufferANDROID)); + vkCmdDrawIndirectCount = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndirectCount)); + vkCmdDrawIndirectCountKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndirectCountKHR)); + vkCmdDrawIndirectCountAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndirectCountAMD)); + vkCmdDrawIndexedIndirectCount = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndexedIndirectCount)); + vkCmdDrawIndexedIndirectCountKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndexedIndirectCountKHR)); + vkCmdDrawIndexedIndirectCountAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndexedIndirectCountAMD)); + vkCmdSetCheckpointNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCheckpointNV)); + vkGetQueueCheckpointDataNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetQueueCheckpointDataNV)); + vkCmdBindTransformFeedbackBuffersEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindTransformFeedbackBuffersEXT)); + vkCmdBeginTransformFeedbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginTransformFeedbackEXT)); + vkCmdEndTransformFeedbackEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndTransformFeedbackEXT)); + vkCmdBeginQueryIndexedEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginQueryIndexedEXT)); + vkCmdEndQueryIndexedEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndQueryIndexedEXT)); + vkCmdDrawIndirectByteCountEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawIndirectByteCountEXT)); + vkCmdSetExclusiveScissorNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetExclusiveScissorNV)); + vkCmdSetExclusiveScissorEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetExclusiveScissorEnableNV)); + vkCmdBindShadingRateImageNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindShadingRateImageNV)); + vkCmdSetViewportShadingRatePaletteNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportShadingRatePaletteNV)); + vkCmdSetCoarseSampleOrderNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoarseSampleOrderNV)); + vkCmdDrawMeshTasksNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksNV)); + vkCmdDrawMeshTasksIndirectNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksIndirectNV)); + vkCmdDrawMeshTasksIndirectCountNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksIndirectCountNV)); + vkCmdDrawMeshTasksEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksEXT)); + vkCmdDrawMeshTasksIndirectEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksIndirectEXT)); + vkCmdDrawMeshTasksIndirectCountEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDrawMeshTasksIndirectCountEXT)); + vkCompileDeferredNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCompileDeferredNV)); + vkCreateAccelerationStructureNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateAccelerationStructureNV)); + vkCmdBindInvocationMaskHUAWEI = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindInvocationMaskHUAWEI)); + vkDestroyAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyAccelerationStructureKHR)); + vkDestroyAccelerationStructureNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyAccelerationStructureNV)); + vkGetAccelerationStructureMemoryRequirementsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAccelerationStructureMemoryRequirementsNV)); + vkBindAccelerationStructureMemoryNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindAccelerationStructureMemoryNV)); + vkCmdCopyAccelerationStructureNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyAccelerationStructureNV)); + vkCmdCopyAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyAccelerationStructureKHR)); + vkCopyAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyAccelerationStructureKHR)); + vkCmdCopyAccelerationStructureToMemoryKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyAccelerationStructureToMemoryKHR)); + vkCopyAccelerationStructureToMemoryKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyAccelerationStructureToMemoryKHR)); + vkCmdCopyMemoryToAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryToAccelerationStructureKHR)); + vkCopyMemoryToAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMemoryToAccelerationStructureKHR)); + vkCmdWriteAccelerationStructuresPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteAccelerationStructuresPropertiesKHR)); + vkCmdWriteAccelerationStructuresPropertiesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteAccelerationStructuresPropertiesNV)); + vkCmdBuildAccelerationStructureNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildAccelerationStructureNV)); + vkWriteAccelerationStructuresPropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWriteAccelerationStructuresPropertiesKHR)); + vkCmdTraceRaysKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdTraceRaysKHR)); + vkCmdTraceRaysNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdTraceRaysNV)); + vkGetRayTracingShaderGroupHandlesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRayTracingShaderGroupHandlesKHR)); + vkGetRayTracingShaderGroupHandlesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRayTracingShaderGroupHandlesNV)); + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)); + vkGetAccelerationStructureHandleNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAccelerationStructureHandleNV)); + vkCreateRayTracingPipelinesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateRayTracingPipelinesNV)); + vkCreateRayTracingPipelinesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateRayTracingPipelinesKHR)); + vkCmdTraceRaysIndirectKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdTraceRaysIndirectKHR)); + vkCmdTraceRaysIndirect2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdTraceRaysIndirect2KHR)); + vkGetClusterAccelerationStructureBuildSizesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetClusterAccelerationStructureBuildSizesNV)); + vkCmdBuildClusterAccelerationStructureIndirectNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildClusterAccelerationStructureIndirectNV)); + vkGetDeviceAccelerationStructureCompatibilityKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceAccelerationStructureCompatibilityKHR)); + vkGetRayTracingShaderGroupStackSizeKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetRayTracingShaderGroupStackSizeKHR)); + vkCmdSetRayTracingPipelineStackSizeKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRayTracingPipelineStackSizeKHR)); + vkGetImageViewHandleNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageViewHandleNVX)); + vkGetImageViewHandle64NVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageViewHandle64NVX)); + vkGetImageViewAddressNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageViewAddressNVX)); + vkGetDeviceGroupSurfacePresentModes2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceGroupSurfacePresentModes2EXT)); + vkAcquireFullScreenExclusiveModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireFullScreenExclusiveModeEXT)); + vkReleaseFullScreenExclusiveModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseFullScreenExclusiveModeEXT)); + vkAcquireProfilingLockKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireProfilingLockKHR)); + vkReleaseProfilingLockKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseProfilingLockKHR)); + vkGetImageDrmFormatModifierPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageDrmFormatModifierPropertiesEXT)); + vkGetBufferOpaqueCaptureAddress = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferOpaqueCaptureAddress)); + vkGetBufferOpaqueCaptureAddressKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferOpaqueCaptureAddressKHR)); + vkGetBufferDeviceAddress = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferDeviceAddress)); + vkGetBufferDeviceAddressKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferDeviceAddressKHR)); + vkGetBufferDeviceAddressEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferDeviceAddressEXT)); + vkInitializePerformanceApiINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkInitializePerformanceApiINTEL)); + vkUninitializePerformanceApiINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUninitializePerformanceApiINTEL)); + vkCmdSetPerformanceMarkerINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPerformanceMarkerINTEL)); + vkCmdSetPerformanceStreamMarkerINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPerformanceStreamMarkerINTEL)); + vkCmdSetPerformanceOverrideINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPerformanceOverrideINTEL)); + vkAcquirePerformanceConfigurationINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquirePerformanceConfigurationINTEL)); + vkReleasePerformanceConfigurationINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleasePerformanceConfigurationINTEL)); + vkQueueSetPerformanceConfigurationINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueSetPerformanceConfigurationINTEL)); + vkGetPerformanceParameterINTEL = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPerformanceParameterINTEL)); + vkGetDeviceMemoryOpaqueCaptureAddress = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceMemoryOpaqueCaptureAddress)); + vkGetDeviceMemoryOpaqueCaptureAddressKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceMemoryOpaqueCaptureAddressKHR)); + vkGetPipelineExecutablePropertiesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineExecutablePropertiesKHR)); + vkGetPipelineExecutableStatisticsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineExecutableStatisticsKHR)); + vkGetPipelineExecutableInternalRepresentationsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineExecutableInternalRepresentationsKHR)); + vkCmdSetLineStipple = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineStipple)); + vkCmdSetLineStippleKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineStippleKHR)); + vkCmdSetLineStippleEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineStippleEXT)); + vkCreateAccelerationStructureKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateAccelerationStructureKHR)); + vkCmdBuildAccelerationStructuresKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildAccelerationStructuresKHR)); + vkCmdBuildAccelerationStructuresIndirectKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildAccelerationStructuresIndirectKHR)); + vkBuildAccelerationStructuresKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBuildAccelerationStructuresKHR)); + vkGetAccelerationStructureDeviceAddressKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAccelerationStructureDeviceAddressKHR)); + vkCreateDeferredOperationKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDeferredOperationKHR)); + vkDestroyDeferredOperationKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDeferredOperationKHR)); + vkGetDeferredOperationMaxConcurrencyKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeferredOperationMaxConcurrencyKHR)); + vkGetDeferredOperationResultKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeferredOperationResultKHR)); + vkDeferredOperationJoinKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDeferredOperationJoinKHR)); + vkGetPipelineIndirectMemoryRequirementsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineIndirectMemoryRequirementsNV)); + vkGetPipelineIndirectDeviceAddressNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelineIndirectDeviceAddressNV)); + vkAntiLagUpdateAMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAntiLagUpdateAMD)); + vkCmdSetCullMode = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCullMode)); + vkCmdSetCullModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCullModeEXT)); + vkCmdSetFrontFace = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetFrontFace)); + vkCmdSetFrontFaceEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetFrontFaceEXT)); + vkCmdSetPrimitiveTopology = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPrimitiveTopology)); + vkCmdSetPrimitiveTopologyEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPrimitiveTopologyEXT)); + vkCmdSetViewportWithCount = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportWithCount)); + vkCmdSetViewportWithCountEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportWithCountEXT)); + vkCmdSetScissorWithCount = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetScissorWithCount)); + vkCmdSetScissorWithCountEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetScissorWithCountEXT)); + vkCmdBindIndexBuffer2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindIndexBuffer2)); + vkCmdBindIndexBuffer2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindIndexBuffer2KHR)); + vkCmdBindVertexBuffers2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindVertexBuffers2)); + vkCmdBindVertexBuffers2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindVertexBuffers2EXT)); + vkCmdSetDepthTestEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthTestEnable)); + vkCmdSetDepthTestEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthTestEnableEXT)); + vkCmdSetDepthWriteEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthWriteEnable)); + vkCmdSetDepthWriteEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthWriteEnableEXT)); + vkCmdSetDepthCompareOp = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthCompareOp)); + vkCmdSetDepthCompareOpEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthCompareOpEXT)); + vkCmdSetDepthBoundsTestEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBoundsTestEnable)); + vkCmdSetDepthBoundsTestEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBoundsTestEnableEXT)); + vkCmdSetStencilTestEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilTestEnable)); + vkCmdSetStencilTestEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilTestEnableEXT)); + vkCmdSetStencilOp = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilOp)); + vkCmdSetStencilOpEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetStencilOpEXT)); + vkCmdSetPatchControlPointsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPatchControlPointsEXT)); + vkCmdSetRasterizerDiscardEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRasterizerDiscardEnable)); + vkCmdSetRasterizerDiscardEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRasterizerDiscardEnableEXT)); + vkCmdSetDepthBiasEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBiasEnable)); + vkCmdSetDepthBiasEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBiasEnableEXT)); + vkCmdSetLogicOpEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLogicOpEXT)); + vkCmdSetPrimitiveRestartEnable = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPrimitiveRestartEnable)); + vkCmdSetPrimitiveRestartEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPrimitiveRestartEnableEXT)); + vkCmdSetTessellationDomainOriginEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetTessellationDomainOriginEXT)); + vkCmdSetDepthClampEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthClampEnableEXT)); + vkCmdSetPolygonModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetPolygonModeEXT)); + vkCmdSetRasterizationSamplesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRasterizationSamplesEXT)); + vkCmdSetSampleMaskEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetSampleMaskEXT)); + vkCmdSetAlphaToCoverageEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetAlphaToCoverageEnableEXT)); + vkCmdSetAlphaToOneEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetAlphaToOneEnableEXT)); + vkCmdSetLogicOpEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLogicOpEnableEXT)); + vkCmdSetColorBlendEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetColorBlendEnableEXT)); + vkCmdSetColorBlendEquationEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetColorBlendEquationEXT)); + vkCmdSetColorWriteMaskEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetColorWriteMaskEXT)); + vkCmdSetRasterizationStreamEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRasterizationStreamEXT)); + vkCmdSetConservativeRasterizationModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetConservativeRasterizationModeEXT)); + vkCmdSetExtraPrimitiveOverestimationSizeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetExtraPrimitiveOverestimationSizeEXT)); + vkCmdSetDepthClipEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthClipEnableEXT)); + vkCmdSetSampleLocationsEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetSampleLocationsEnableEXT)); + vkCmdSetColorBlendAdvancedEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetColorBlendAdvancedEXT)); + vkCmdSetProvokingVertexModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetProvokingVertexModeEXT)); + vkCmdSetLineRasterizationModeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineRasterizationModeEXT)); + vkCmdSetLineStippleEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetLineStippleEnableEXT)); + vkCmdSetDepthClipNegativeOneToOneEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthClipNegativeOneToOneEXT)); + vkCmdSetViewportWScalingEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportWScalingEnableNV)); + vkCmdSetViewportSwizzleNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetViewportSwizzleNV)); + vkCmdSetCoverageToColorEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageToColorEnableNV)); + vkCmdSetCoverageToColorLocationNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageToColorLocationNV)); + vkCmdSetCoverageModulationModeNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageModulationModeNV)); + vkCmdSetCoverageModulationTableEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageModulationTableEnableNV)); + vkCmdSetCoverageModulationTableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageModulationTableNV)); + vkCmdSetShadingRateImageEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetShadingRateImageEnableNV)); + vkCmdSetCoverageReductionModeNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetCoverageReductionModeNV)); + vkCmdSetRepresentativeFragmentTestEnableNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRepresentativeFragmentTestEnableNV)); + vkCreatePrivateDataSlot = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreatePrivateDataSlot)); + vkCreatePrivateDataSlotEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreatePrivateDataSlotEXT)); + vkDestroyPrivateDataSlot = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPrivateDataSlot)); + vkDestroyPrivateDataSlotEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyPrivateDataSlotEXT)); + vkSetPrivateData = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetPrivateData)); + vkSetPrivateDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetPrivateDataEXT)); + vkGetPrivateData = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPrivateData)); + vkGetPrivateDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPrivateDataEXT)); + vkCmdCopyBuffer2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBuffer2)); + vkCmdCopyBuffer2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBuffer2KHR)); + vkCmdCopyImage2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImage2)); + vkCmdCopyImage2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImage2KHR)); + vkCmdBlitImage2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBlitImage2)); + vkCmdBlitImage2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBlitImage2KHR)); + vkCmdCopyBufferToImage2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBufferToImage2)); + vkCmdCopyBufferToImage2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyBufferToImage2KHR)); + vkCmdCopyImageToBuffer2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImageToBuffer2)); + vkCmdCopyImageToBuffer2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyImageToBuffer2KHR)); + vkCmdResolveImage2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResolveImage2)); + vkCmdResolveImage2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResolveImage2KHR)); + vkCmdSetFragmentShadingRateKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetFragmentShadingRateKHR)); + vkCmdSetFragmentShadingRateEnumNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetFragmentShadingRateEnumNV)); + vkGetAccelerationStructureBuildSizesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAccelerationStructureBuildSizesKHR)); + vkCmdSetVertexInputEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetVertexInputEXT)); + vkCmdSetColorWriteEnableEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetColorWriteEnableEXT)); + vkCmdSetEvent2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetEvent2)); + vkCmdSetEvent2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetEvent2KHR)); + vkCmdResetEvent2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResetEvent2)); + vkCmdResetEvent2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdResetEvent2KHR)); + vkCmdWaitEvents2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWaitEvents2)); + vkCmdWaitEvents2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWaitEvents2KHR)); + vkCmdPipelineBarrier2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPipelineBarrier2)); + vkCmdPipelineBarrier2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPipelineBarrier2KHR)); + vkQueueSubmit2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueSubmit2)); + vkQueueSubmit2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueSubmit2KHR)); + vkCmdWriteTimestamp2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteTimestamp2)); + vkCmdWriteTimestamp2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteTimestamp2KHR)); + vkCmdWriteBufferMarker2AMD = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteBufferMarker2AMD)); + vkGetQueueCheckpointData2NV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetQueueCheckpointData2NV)); + vkCopyMemoryToImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMemoryToImage)); + vkCopyMemoryToImageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMemoryToImageEXT)); + vkCopyImageToMemory = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyImageToMemory)); + vkCopyImageToMemoryEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyImageToMemoryEXT)); + vkCopyImageToImage = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyImageToImage)); + vkCopyImageToImageEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyImageToImageEXT)); + vkTransitionImageLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkTransitionImageLayout)); + vkTransitionImageLayoutEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkTransitionImageLayoutEXT)); + vkCreateVideoSessionKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateVideoSessionKHR)); + vkDestroyVideoSessionKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyVideoSessionKHR)); + vkCreateVideoSessionParametersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateVideoSessionParametersKHR)); + vkUpdateVideoSessionParametersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUpdateVideoSessionParametersKHR)); + vkGetEncodedVideoSessionParametersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetEncodedVideoSessionParametersKHR)); + vkDestroyVideoSessionParametersKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyVideoSessionParametersKHR)); + vkGetVideoSessionMemoryRequirementsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetVideoSessionMemoryRequirementsKHR)); + vkBindVideoSessionMemoryKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindVideoSessionMemoryKHR)); + vkCmdDecodeVideoKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDecodeVideoKHR)); + vkCmdBeginVideoCodingKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginVideoCodingKHR)); + vkCmdControlVideoCodingKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdControlVideoCodingKHR)); + vkCmdEndVideoCodingKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndVideoCodingKHR)); + vkCmdEncodeVideoKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEncodeVideoKHR)); + vkCmdDecompressMemoryNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDecompressMemoryNV)); + vkCmdDecompressMemoryIndirectCountNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDecompressMemoryIndirectCountNV)); + vkGetPartitionedAccelerationStructuresBuildSizesNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPartitionedAccelerationStructuresBuildSizesNV)); + vkCmdBuildPartitionedAccelerationStructuresNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildPartitionedAccelerationStructuresNV)); + vkCmdDecompressMemoryEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDecompressMemoryEXT)); + vkCmdDecompressMemoryIndirectCountEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDecompressMemoryIndirectCountEXT)); + vkCreateCuModuleNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateCuModuleNVX)); + vkCreateCuFunctionNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateCuFunctionNVX)); + vkDestroyCuModuleNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyCuModuleNVX)); + vkDestroyCuFunctionNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyCuFunctionNVX)); + vkCmdCuLaunchKernelNVX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCuLaunchKernelNVX)); + vkGetDescriptorSetLayoutSizeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetLayoutSizeEXT)); + vkGetDescriptorSetLayoutBindingOffsetEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetLayoutBindingOffsetEXT)); + vkGetDescriptorEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorEXT)); + vkCmdBindDescriptorBuffersEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorBuffersEXT)); + vkCmdSetDescriptorBufferOffsetsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDescriptorBufferOffsetsEXT)); + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorBufferEmbeddedSamplersEXT)); + vkGetBufferOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferOpaqueCaptureDescriptorDataEXT)); + vkGetImageOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageOpaqueCaptureDescriptorDataEXT)); + vkGetImageViewOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageViewOpaqueCaptureDescriptorDataEXT)); + vkGetSamplerOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSamplerOpaqueCaptureDescriptorDataEXT)); + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)); + vkSetDeviceMemoryPriorityEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetDeviceMemoryPriorityEXT)); + vkWaitForPresent2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWaitForPresent2KHR)); + vkWaitForPresentKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWaitForPresentKHR)); + vkCreateBufferCollectionFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateBufferCollectionFUCHSIA)); + vkSetBufferCollectionBufferConstraintsFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetBufferCollectionBufferConstraintsFUCHSIA)); + vkSetBufferCollectionImageConstraintsFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetBufferCollectionImageConstraintsFUCHSIA)); + vkDestroyBufferCollectionFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyBufferCollectionFUCHSIA)); + vkGetBufferCollectionPropertiesFUCHSIA = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetBufferCollectionPropertiesFUCHSIA)); + vkCreateCudaModuleNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateCudaModuleNV)); + vkGetCudaModuleCacheNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetCudaModuleCacheNV)); + vkCreateCudaFunctionNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateCudaFunctionNV)); + vkDestroyCudaModuleNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyCudaModuleNV)); + vkDestroyCudaFunctionNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyCudaFunctionNV)); + vkCmdCudaLaunchKernelNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCudaLaunchKernelNV)); + vkCmdBeginRendering = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginRendering)); + vkCmdBeginRenderingKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginRenderingKHR)); + vkCmdEndRendering = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRendering)); + vkCmdEndRendering2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRendering2KHR)); + vkCmdEndRendering2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRendering2EXT)); + vkCmdEndRenderingKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndRenderingKHR)); + vkGetDescriptorSetLayoutHostMappingInfoVALVE = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetLayoutHostMappingInfoVALVE)); + vkGetDescriptorSetHostMappingVALVE = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDescriptorSetHostMappingVALVE)); + vkCreateMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateMicromapEXT)); + vkCmdBuildMicromapsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBuildMicromapsEXT)); + vkBuildMicromapsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBuildMicromapsEXT)); + vkDestroyMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyMicromapEXT)); + vkCmdCopyMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMicromapEXT)); + vkCopyMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMicromapEXT)); + vkCmdCopyMicromapToMemoryEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMicromapToMemoryEXT)); + vkCopyMicromapToMemoryEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMicromapToMemoryEXT)); + vkCmdCopyMemoryToMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyMemoryToMicromapEXT)); + vkCopyMemoryToMicromapEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCopyMemoryToMicromapEXT)); + vkCmdWriteMicromapsPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdWriteMicromapsPropertiesEXT)); + vkWriteMicromapsPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkWriteMicromapsPropertiesEXT)); + vkGetDeviceMicromapCompatibilityEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceMicromapCompatibilityEXT)); + vkGetMicromapBuildSizesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMicromapBuildSizesEXT)); + vkGetShaderModuleIdentifierEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetShaderModuleIdentifierEXT)); + vkGetShaderModuleCreateInfoIdentifierEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetShaderModuleCreateInfoIdentifierEXT)); + vkGetImageSubresourceLayout2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSubresourceLayout2)); + vkGetImageSubresourceLayout2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSubresourceLayout2KHR)); + vkGetImageSubresourceLayout2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetImageSubresourceLayout2EXT)); + vkGetPipelinePropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPipelinePropertiesEXT)); + vkExportMetalObjectsEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkExportMetalObjectsEXT)); + vkCmdBindTileMemoryQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindTileMemoryQCOM)); + vkGetFramebufferTilePropertiesQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetFramebufferTilePropertiesQCOM)); + vkGetDynamicRenderingTilePropertiesQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDynamicRenderingTilePropertiesQCOM)); + vkCreateOpticalFlowSessionNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateOpticalFlowSessionNV)); + vkDestroyOpticalFlowSessionNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyOpticalFlowSessionNV)); + vkBindOpticalFlowSessionImageNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindOpticalFlowSessionImageNV)); + vkCmdOpticalFlowExecuteNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdOpticalFlowExecuteNV)); + vkGetDeviceFaultInfoEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceFaultInfoEXT)); + vkCmdSetDepthBias2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthBias2EXT)); + vkReleaseSwapchainImagesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseSwapchainImagesKHR)); + vkReleaseSwapchainImagesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkReleaseSwapchainImagesEXT)); + vkGetDeviceImageSubresourceLayout = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageSubresourceLayout)); + vkGetDeviceImageSubresourceLayoutKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceImageSubresourceLayoutKHR)); + vkMapMemory2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkMapMemory2)); + vkMapMemory2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkMapMemory2KHR)); + vkUnmapMemory2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUnmapMemory2)); + vkUnmapMemory2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkUnmapMemory2KHR)); + vkCreateShadersEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateShadersEXT)); + vkDestroyShaderEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyShaderEXT)); + vkGetShaderBinaryDataEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetShaderBinaryDataEXT)); + vkCmdBindShadersEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindShadersEXT)); + vkSetSwapchainPresentTimingQueueSizeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetSwapchainPresentTimingQueueSizeEXT)); + vkGetSwapchainTimingPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainTimingPropertiesEXT)); + vkGetSwapchainTimeDomainPropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainTimeDomainPropertiesEXT)); + vkGetPastPresentationTimingEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetPastPresentationTimingEXT)); + vkGetScreenBufferPropertiesQNX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetScreenBufferPropertiesQNX)); + vkGetExecutionGraphPipelineScratchSizeAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetExecutionGraphPipelineScratchSizeAMDX)); + vkGetExecutionGraphPipelineNodeIndexAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetExecutionGraphPipelineNodeIndexAMDX)); + vkCreateExecutionGraphPipelinesAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateExecutionGraphPipelinesAMDX)); + vkCmdInitializeGraphScratchMemoryAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdInitializeGraphScratchMemoryAMDX)); + vkCmdDispatchGraphAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchGraphAMDX)); + vkCmdDispatchGraphIndirectAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchGraphIndirectAMDX)); + vkCmdDispatchGraphIndirectCountAMDX = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchGraphIndirectCountAMDX)); + vkCmdBindDescriptorSets2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorSets2)); + vkCmdBindDescriptorSets2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorSets2KHR)); + vkCmdPushConstants2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushConstants2)); + vkCmdPushConstants2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushConstants2KHR)); + vkCmdPushDescriptorSet2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSet2)); + vkCmdPushDescriptorSet2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSet2KHR)); + vkCmdPushDescriptorSetWithTemplate2 = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSetWithTemplate2)); + vkCmdPushDescriptorSetWithTemplate2KHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdPushDescriptorSetWithTemplate2KHR)); + vkCmdSetDescriptorBufferOffsets2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDescriptorBufferOffsets2EXT)); + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)); + vkSetLatencySleepModeNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetLatencySleepModeNV)); + vkLatencySleepNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkLatencySleepNV)); + vkSetLatencyMarkerNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkSetLatencyMarkerNV)); + vkGetLatencyTimingsNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetLatencyTimingsNV)); + vkQueueNotifyOutOfBandNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueNotifyOutOfBandNV)); + vkCmdSetRenderingAttachmentLocations = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRenderingAttachmentLocations)); + vkCmdSetRenderingAttachmentLocationsKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRenderingAttachmentLocationsKHR)); + vkCmdSetRenderingInputAttachmentIndices = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRenderingInputAttachmentIndices)); + vkCmdSetRenderingInputAttachmentIndicesKHR = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetRenderingInputAttachmentIndicesKHR)); + vkCmdSetDepthClampRangeEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdSetDepthClampRangeEXT)); + vkGetMemoryMetalHandleEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryMetalHandleEXT)); + vkGetMemoryMetalHandlePropertiesEXT = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryMetalHandlePropertiesEXT)); + vkConvertCooperativeVectorMatrixNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkConvertCooperativeVectorMatrixNV)); + vkCmdConvertCooperativeVectorMatrixNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdConvertCooperativeVectorMatrixNV)); + vkCmdDispatchTileQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchTileQCOM)); + vkCmdBeginPerTileExecutionQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdBeginPerTileExecutionQCOM)); + vkCmdEndPerTileExecutionQCOM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdEndPerTileExecutionQCOM)); + vkCreateExternalComputeQueueNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateExternalComputeQueueNV)); + vkDestroyExternalComputeQueueNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyExternalComputeQueueNV)); + vkGetExternalComputeQueueDataNV = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetExternalComputeQueueDataNV)); + vkCreateTensorARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateTensorARM)); + vkDestroyTensorARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyTensorARM)); + vkCreateTensorViewARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateTensorViewARM)); + vkDestroyTensorViewARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyTensorViewARM)); + vkGetTensorMemoryRequirementsARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetTensorMemoryRequirementsARM)); + vkBindTensorMemoryARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindTensorMemoryARM)); + vkGetDeviceTensorMemoryRequirementsARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDeviceTensorMemoryRequirementsARM)); + vkCmdCopyTensorARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdCopyTensorARM)); + vkGetTensorOpaqueCaptureDescriptorDataARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetTensorOpaqueCaptureDescriptorDataARM)); + vkGetTensorViewOpaqueCaptureDescriptorDataARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetTensorViewOpaqueCaptureDescriptorDataARM)); + vkCreateDataGraphPipelinesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDataGraphPipelinesARM)); + vkCreateDataGraphPipelineSessionARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCreateDataGraphPipelineSessionARM)); + vkGetDataGraphPipelineSessionBindPointRequirementsARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDataGraphPipelineSessionBindPointRequirementsARM)); + vkGetDataGraphPipelineSessionMemoryRequirementsARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDataGraphPipelineSessionMemoryRequirementsARM)); + vkBindDataGraphPipelineSessionMemoryARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkBindDataGraphPipelineSessionMemoryARM)); + vkDestroyDataGraphPipelineSessionARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkDestroyDataGraphPipelineSessionARM)); + vkCmdDispatchDataGraphARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkCmdDispatchDataGraphARM)); + vkGetDataGraphPipelineAvailablePropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDataGraphPipelineAvailablePropertiesARM)); + vkGetDataGraphPipelinePropertiesARM = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetDataGraphPipelinePropertiesARM)); + vkGetNativeBufferPropertiesOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetNativeBufferPropertiesOHOS)); + vkGetMemoryNativeBufferOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetMemoryNativeBufferOHOS)); + vkGetSwapchainGrallocUsageOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkGetSwapchainGrallocUsageOHOS)); + vkAcquireImageOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkAcquireImageOHOS)); + vkQueueSignalReleaseImageOHOS = (.)(void*)vkGetInstanceProcAddr(instance, nameof(vkQueueSignalReleaseImageOHOS)); + } +} + +static +{ + [Inline] public static VkResult vkCreateInstance(VkInstanceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkInstance pInstance) => VulkanLoadedFunctions.current.vkCreateInstance(pCreateInfo, pAllocator, out pInstance); + [Inline] public static void Destroy(this VkInstance instance, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyInstance(instance, pAllocator); + [Inline] public static VkResult EnumeratePhysicalDevices(this VkInstance instance, out uint32 pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDevices(instance, out pPhysicalDeviceCount, pPhysicalDevices); + [Inline] public static PFN_vkVoidFunction GetProcAddr(this VkDevice device, char8* pName) => VulkanLoadedFunctions.current.vkGetDeviceProcAddr(device, pName); + [Inline] public static PFN_vkVoidFunction GetProcAddr(this VkInstance instance, char8* pName) => VulkanLoadedFunctions.current.vkGetInstanceProcAddr(instance, pName); + [Inline] public static void GetProperties(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceProperties pProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceProperties(physicalDevice, out pProperties); + [Inline] public static void GetQueueFamilyProperties(this VkPhysicalDevice physicalDevice, out uint32 pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, out pQueueFamilyPropertyCount, pQueueFamilyProperties); + [Inline] public static void GetMemoryProperties(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceMemoryProperties pMemoryProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceMemoryProperties(physicalDevice, out pMemoryProperties); + [Inline] public static void GetFeatures(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceFeatures pFeatures) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFeatures(physicalDevice, out pFeatures); + [Inline] public static void GetFormatProperties(this VkPhysicalDevice physicalDevice, VkFormat format, out VkFormatProperties pFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFormatProperties(physicalDevice, format, out pFormatProperties); + [Inline] public static VkResult GetImageFormatProperties(this VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, out VkImageFormatProperties pImageFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, out pImageFormatProperties); + [Inline] public static VkResult CreateDevice(this VkPhysicalDevice physicalDevice, VkDeviceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDevice pDevice) => VulkanLoadedFunctions.current.vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, out pDevice); + [Inline] public static void Destroy(this VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDevice(device, pAllocator); + [Inline] public static VkResult vkEnumerateInstanceVersion(out uint32 pApiVersion) => VulkanLoadedFunctions.current.vkEnumerateInstanceVersion(out pApiVersion); + [Inline] public static VkResult vkEnumerateInstanceLayerProperties(out uint32 pPropertyCount, VkLayerProperties* pProperties = null) => VulkanLoadedFunctions.current.vkEnumerateInstanceLayerProperties(out pPropertyCount, pProperties); + [Inline] public static VkResult vkEnumerateInstanceExtensionProperties(char8* pLayerName, out uint32 pPropertyCount, VkExtensionProperties* pProperties = null) => VulkanLoadedFunctions.current.vkEnumerateInstanceExtensionProperties(pLayerName, out pPropertyCount, pProperties); + [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 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 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); + [Inline] public static void GetMemoryRequirements(this VkImage image, VkDevice device, out VkMemoryRequirements pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetImageMemoryRequirements(device, image, out pMemoryRequirements); + [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 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 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 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); + [Inline] public static void Destroy(this VkEvent event, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyEvent(device, event, pAllocator); + [Inline] public static VkResult GetStatus(this VkEvent event, VkDevice device) => VulkanLoadedFunctions.current.vkGetEventStatus(device, event); + [Inline] public static VkResult Set(this VkEvent event, VkDevice device) => VulkanLoadedFunctions.current.vkSetEvent(device, event); + [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 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); + [Inline] public static void Destroy(this VkBuffer buffer, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyBuffer(device, buffer, pAllocator); + [Inline] public static VkResult CreateBufferView(this VkDevice device, VkBufferViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBufferView pView) => VulkanLoadedFunctions.current.vkCreateBufferView(device, pCreateInfo, pAllocator, out pView); + [Inline] public static void Destroy(this VkBufferView bufferView, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyBufferView(device, bufferView, pAllocator); + [Inline] public static VkResult CreateImage(this VkDevice device, VkImageCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkImage pImage) => VulkanLoadedFunctions.current.vkCreateImage(device, pCreateInfo, pAllocator, out pImage); + [Inline] public static void Destroy(this VkImage image, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyImage(device, image, pAllocator); + [Inline] public static void GetSubresourceLayout(this VkImage image, VkDevice device, VkImageSubresource* pSubresource, out VkSubresourceLayout pLayout) => VulkanLoadedFunctions.current.vkGetImageSubresourceLayout(device, image, pSubresource, out pLayout); + [Inline] public static VkResult CreateImageView(this VkDevice device, VkImageViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkImageView pView) => VulkanLoadedFunctions.current.vkCreateImageView(device, pCreateInfo, pAllocator, out pView); + [Inline] public static void Destroy(this VkImageView imageView, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyImageView(device, imageView, pAllocator); + [Inline] public static VkResult CreateShaderModule(this VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkShaderModule pShaderModule) => VulkanLoadedFunctions.current.vkCreateShaderModule(device, pCreateInfo, pAllocator, out pShaderModule); + [Inline] public static void Destroy(this VkShaderModule shaderModule, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyShaderModule(device, shaderModule, pAllocator); + [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 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); + [Inline] public static VkResult GetPipelineBinaryDataKHR(this VkDevice device, VkPipelineBinaryDataInfoKHR* pInfo, out VkPipelineBinaryKeyKHR pPipelineBinaryKey, out c_size pPipelineBinaryDataSize, void* pPipelineBinaryData = null) => VulkanLoadedFunctions.current.vkGetPipelineBinaryDataKHR(device, pInfo, out pPipelineBinaryKey, out pPipelineBinaryDataSize, pPipelineBinaryData); + [Inline] public static VkResult ReleaseCapturedPipelineDataKHR(this VkDevice device, VkReleaseCapturedPipelineDataInfoKHR* pInfo, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); + [Inline] public static VkResult CreateGraphicsPipelines(this VkPipelineCache pipelineCache, VkDevice device, uint32 createInfoCount, VkGraphicsPipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); + [Inline] public static VkResult CreateComputePipelines(this VkPipelineCache pipelineCache, VkDevice device, uint32 createInfoCount, VkComputePipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); + [Inline] public static VkResult GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(this VkRenderPass renderpass, VkDevice device, out VkExtent2D pMaxWorkgroupSize) => VulkanLoadedFunctions.current.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, out pMaxWorkgroupSize); + [Inline] public static void Destroy(this VkPipeline pipeline, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPipeline(device, pipeline, pAllocator); + [Inline] public static VkResult CreatePipelineLayout(this VkDevice device, VkPipelineLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineLayout pPipelineLayout) => VulkanLoadedFunctions.current.vkCreatePipelineLayout(device, pCreateInfo, pAllocator, out pPipelineLayout); + [Inline] public static void Destroy(this VkPipelineLayout pipelineLayout, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); + [Inline] public static VkResult CreateSampler(this VkDevice device, VkSamplerCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSampler pSampler) => VulkanLoadedFunctions.current.vkCreateSampler(device, pCreateInfo, pAllocator, out pSampler); + [Inline] public static void Destroy(this VkSampler sampler, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySampler(device, sampler, pAllocator); + [Inline] public static VkResult CreateDescriptorSetLayout(this VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorSetLayout pSetLayout) => VulkanLoadedFunctions.current.vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, out pSetLayout); + [Inline] public static void Destroy(this VkDescriptorSetLayout descriptorSetLayout, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); + [Inline] public static VkResult CreateDescriptorPool(this VkDevice device, VkDescriptorPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorPool pDescriptorPool) => VulkanLoadedFunctions.current.vkCreateDescriptorPool(device, pCreateInfo, pAllocator, out pDescriptorPool); + [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 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); + [Inline] public static void Destroy(this VkRenderPass renderPass, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyRenderPass(device, renderPass, pAllocator); + [Inline] public static void GetRenderAreaGranularity(this VkRenderPass renderPass, VkDevice device, out VkExtent2D pGranularity) => VulkanLoadedFunctions.current.vkGetRenderAreaGranularity(device, renderPass, out pGranularity); + [Inline] public static void GetRenderingAreaGranularity(this VkDevice device, VkRenderingAreaInfo* pRenderingAreaInfo, out VkExtent2D pGranularity) => VulkanLoadedFunctions.current.vkGetRenderingAreaGranularity(device, pRenderingAreaInfo, out pGranularity); + [Inline] public static void GetRenderingAreaGranularityKHR(this VkDevice device, VkRenderingAreaInfo* pRenderingAreaInfo, out VkExtent2D pGranularity) => VulkanLoadedFunctions.current.vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, out pGranularity); + [Inline] public static VkResult CreateCommandPool(this VkDevice device, VkCommandPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCommandPool pCommandPool) => VulkanLoadedFunctions.current.vkCreateCommandPool(device, pCreateInfo, pAllocator, out pCommandPool); + [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 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 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); + [Inline] public static void SetDepthBounds(this VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) => VulkanLoadedFunctions.current.vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); + [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 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 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); + [Inline] public static void DispatchIndirect(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) => VulkanLoadedFunctions.current.vkCmdDispatchIndirect(commandBuffer, buffer, offset); + [Inline] public static void SubpassShadingHUAWEI(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdSubpassShadingHUAWEI(commandBuffer); + [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 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 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 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 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); + [Inline] public static void EndConditionalRenderingEXT(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdEndConditionalRenderingEXT(commandBuffer); + [Inline] public static void BeginCustomResolveEXT(this VkCommandBuffer commandBuffer, VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo = null) => VulkanLoadedFunctions.current.vkCmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo); + [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 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 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); + [Inline] public static VkResult GetDisplayPlanePropertiesKHR(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, out pPropertyCount, pProperties); + [Inline] public static VkResult GetDisplayPlaneSupportedDisplaysKHR(this VkPhysicalDevice physicalDevice, uint32 planeIndex, out uint32 pDisplayCount, VkDisplayKHR* pDisplays = null) => VulkanLoadedFunctions.current.vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, out pDisplayCount, pDisplays); + [Inline] public static VkResult GetModePropertiesKHR(this VkDisplayKHR display, VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayModePropertiesKHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetDisplayModePropertiesKHR(physicalDevice, display, out pPropertyCount, pProperties); + [Inline] public static VkResult CreateModeKHR(this VkDisplayKHR display, VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDisplayModeKHR pMode) => VulkanLoadedFunctions.current.vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, out pMode); + [Inline] public static VkResult GetDisplayPlaneCapabilitiesKHR(this VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32 planeIndex, out VkDisplayPlaneCapabilitiesKHR pCapabilities) => VulkanLoadedFunctions.current.vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, out pCapabilities); + [Inline] public static VkResult CreateDisplayPlaneSurfaceKHR(this VkInstance instance, VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkResult CreateSharedSwapchainsKHR(this VkDevice device, uint32 swapchainCount, VkSwapchainCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkSwapchainKHR pSwapchains) => VulkanLoadedFunctions.current.vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, out pSwapchains); + [Inline] public static void DestroyKHR(this VkSurfaceKHR surface, VkInstance instance, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySurfaceKHR(instance, surface, pAllocator); + [Inline] public static VkResult GetSurfaceSupportKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, VkSurfaceKHR surface, out VkBool32 pSupported) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, out pSupported); + [Inline] public static VkResult GetSurfaceCapabilitiesKHR(this VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out VkSurfaceCapabilitiesKHR pSurfaceCapabilities) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, out pSurfaceCapabilities); + [Inline] public static VkResult GetSurfaceFormatsKHR(this VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, out pSurfaceFormatCount, pSurfaceFormats); + [Inline] public static VkResult GetSurfacePresentModesKHR(this VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pPresentModeCount, VkPresentModeKHR* pPresentModes = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, out pPresentModeCount, pPresentModes); + [Inline] public static VkResult CreateSwapchainKHR(this VkDevice device, VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSwapchainKHR pSwapchain) => VulkanLoadedFunctions.current.vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, out pSwapchain); + [Inline] public static void DestroyKHR(this VkSwapchainKHR swapchain, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySwapchainKHR(device, swapchain, pAllocator); + [Inline] public static VkResult GetImagesKHR(this VkSwapchainKHR swapchain, VkDevice device, out uint32 pSwapchainImageCount, VkImage* pSwapchainImages = null) => VulkanLoadedFunctions.current.vkGetSwapchainImagesKHR(device, swapchain, out pSwapchainImageCount, pSwapchainImages); + [Inline] public static VkResult AcquireNextImageKHR(this VkSwapchainKHR swapchain, VkDevice device, uint64 timeout, VkSemaphore semaphore, VkFence fence, out uint32 pImageIndex) => VulkanLoadedFunctions.current.vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, out pImageIndex); + [Inline] public static VkResult PresentKHR(this VkQueue queue, VkPresentInfoKHR* pPresentInfo) => VulkanLoadedFunctions.current.vkQueuePresentKHR(queue, pPresentInfo); + [Inline] public static VkResult CreateViSurfaceNN(this VkInstance instance, VkViSurfaceCreateInfoNN* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkResult CreateWaylandSurfaceKHR(this VkInstance instance, VkWaylandSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetWaylandPresentationSupportKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out wl_display display) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, out display); + [Inline] public static VkResult CreateWin32SurfaceKHR(this VkInstance instance, VkWin32SurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetWin32PresentationSupportKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); + [Inline] public static VkResult CreateXlibSurfaceKHR(this VkInstance instance, VkXlibSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetXlibPresentationSupportKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out Display dpy, VisualID visualID) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, out dpy, visualID); + [Inline] public static VkResult CreateXcbSurfaceKHR(this VkInstance instance, VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetXcbPresentationSupportKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out xcb_connection_t connection, xcb_visualid_t visual_id) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, out connection, visual_id); + [Inline] public static VkResult CreateDirectFBSurfaceEXT(this VkInstance instance, VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetDirectFBPresentationSupportEXT(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out IDirectFB dfb) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, out dfb); + [Inline] public static VkResult CreateImagePipeSurfaceFUCHSIA(this VkInstance instance, VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkResult CreateStreamDescriptorSurfaceGGP(this VkInstance instance, VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkResult CreateScreenSurfaceQNX(this VkInstance instance, VkScreenSurfaceCreateInfoQNX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkBool32 GetScreenPresentationSupportQNX(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out _screen_window window) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, out window); + [Inline] public static VkResult CreateDebugReportCallbackEXT(this VkInstance instance, VkDebugReportCallbackCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDebugReportCallbackEXT pCallback) => VulkanLoadedFunctions.current.vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, out pCallback); + [Inline] public static void DestroyEXT(this VkDebugReportCallbackEXT callback, VkInstance instance, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator); + [Inline] public static void DebugReportMessageEXT(this VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64 object, c_size location, int32 messageCode, char8* pLayerPrefix, char8* pMessage) => VulkanLoadedFunctions.current.vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); + [Inline] public static VkResult DebugMarkerSetObjectNameEXT(this VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo) => VulkanLoadedFunctions.current.vkDebugMarkerSetObjectNameEXT(device, pNameInfo); + [Inline] public static VkResult DebugMarkerSetObjectTagEXT(this VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo) => VulkanLoadedFunctions.current.vkDebugMarkerSetObjectTagEXT(device, pTagInfo); + [Inline] public static void DebugMarkerBeginEXT(this VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) => VulkanLoadedFunctions.current.vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); + [Inline] public static void DebugMarkerEndEXT(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdDebugMarkerEndEXT(commandBuffer); + [Inline] public static void DebugMarkerInsertEXT(this VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) => VulkanLoadedFunctions.current.vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); + [Inline] public static VkResult GetExternalImageFormatPropertiesNV(this VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, out VkExternalImageFormatPropertiesNV pExternalImageFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, out pExternalImageFormatProperties); + [Inline] public static VkResult GetMemoryWin32HandleNV(this VkDeviceMemory memory, VkDevice device, VkExternalMemoryHandleTypeFlagsNV handleType, out HANDLE pHandle) => VulkanLoadedFunctions.current.vkGetMemoryWin32HandleNV(device, memory, handleType, out pHandle); + [Inline] public static void ExecuteGeneratedCommandsNV(this VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) => VulkanLoadedFunctions.current.vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + [Inline] public static void PreprocessGeneratedCommandsNV(this VkCommandBuffer commandBuffer, VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) => VulkanLoadedFunctions.current.vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); + [Inline] public static void BindPipelineShaderGroupNV(this VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32 groupIndex) => VulkanLoadedFunctions.current.vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); + [Inline] public static void GetGeneratedCommandsMemoryRequirementsNV(this VkDevice device, VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, out pMemoryRequirements); + [Inline] public static VkResult CreateIndirectCommandsLayoutNV(this VkDevice device, VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectCommandsLayoutNV pIndirectCommandsLayout) => VulkanLoadedFunctions.current.vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, out pIndirectCommandsLayout); + [Inline] public static void DestroyNV(this VkIndirectCommandsLayoutNV indirectCommandsLayout, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); + [Inline] public static void ExecuteGeneratedCommandsEXT(this VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) => VulkanLoadedFunctions.current.vkCmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + [Inline] public static void PreprocessGeneratedCommandsEXT(this VkCommandBuffer commandBuffer, VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) => VulkanLoadedFunctions.current.vkCmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); + [Inline] public static void GetGeneratedCommandsMemoryRequirementsEXT(this VkDevice device, VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, out pMemoryRequirements); + [Inline] public static VkResult CreateIndirectCommandsLayoutEXT(this VkDevice device, VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectCommandsLayoutEXT pIndirectCommandsLayout) => VulkanLoadedFunctions.current.vkCreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, out pIndirectCommandsLayout); + [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 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); + [Inline] public static void GetProperties2KHR(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceProperties2 pProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceProperties2KHR(physicalDevice, out pProperties); + [Inline] public static void GetFormatProperties2(this VkPhysicalDevice physicalDevice, VkFormat format, out VkFormatProperties2 pFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, out pFormatProperties); + [Inline] public static void GetFormatProperties2KHR(this VkPhysicalDevice physicalDevice, VkFormat format, out VkFormatProperties2 pFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, out pFormatProperties); + [Inline] public static VkResult GetImageFormatProperties2(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, out VkImageFormatProperties2 pImageFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, out pImageFormatProperties); + [Inline] public static VkResult GetImageFormatProperties2KHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, out VkImageFormatProperties2 pImageFormatProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, out pImageFormatProperties); + [Inline] public static void GetQueueFamilyProperties2(this VkPhysicalDevice physicalDevice, out uint32 pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, out pQueueFamilyPropertyCount, pQueueFamilyProperties); + [Inline] public static void GetQueueFamilyProperties2KHR(this VkPhysicalDevice physicalDevice, out uint32 pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, out pQueueFamilyPropertyCount, pQueueFamilyProperties); + [Inline] public static void GetMemoryProperties2(this VkPhysicalDevice physicalDevice, out VkPhysicalDeviceMemoryProperties2 pMemoryProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceMemoryProperties2(physicalDevice, out pMemoryProperties); + [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 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); + [Inline] public static void GetExternalBufferPropertiesKHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, out VkExternalBufferProperties pExternalBufferProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, out pExternalBufferProperties); + [Inline] public static VkResult GetMemoryWin32HandleKHR(this VkDevice device, VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle) => VulkanLoadedFunctions.current.vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, out pHandle); + [Inline] public static VkResult GetMemoryWin32HandlePropertiesKHR(this VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, out VkMemoryWin32HandlePropertiesKHR pMemoryWin32HandleProperties) => VulkanLoadedFunctions.current.vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, out pMemoryWin32HandleProperties); + [Inline] public static VkResult GetMemoryFdKHR(this VkDevice device, VkMemoryGetFdInfoKHR* pGetFdInfo, out c_int pFd) => VulkanLoadedFunctions.current.vkGetMemoryFdKHR(device, pGetFdInfo, out pFd); + [Inline] public static VkResult GetMemoryFdPropertiesKHR(this VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, c_int fd, out VkMemoryFdPropertiesKHR pMemoryFdProperties) => VulkanLoadedFunctions.current.vkGetMemoryFdPropertiesKHR(device, handleType, fd, out pMemoryFdProperties); + [Inline] public static VkResult GetMemoryZirconHandleFUCHSIA(this VkDevice device, VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, out zx_handle_t pZirconHandle) => VulkanLoadedFunctions.current.vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, out pZirconHandle); + [Inline] public static VkResult GetMemoryZirconHandlePropertiesFUCHSIA(this VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, out VkMemoryZirconHandlePropertiesFUCHSIA pMemoryZirconHandleProperties) => VulkanLoadedFunctions.current.vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, out pMemoryZirconHandleProperties); + [Inline] public static VkResult GetMemoryRemoteAddressNV(this VkDevice device, VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, out VkRemoteAddressNV pAddress) => VulkanLoadedFunctions.current.vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, out pAddress); + [Inline] public static void GetExternalSemaphoreProperties(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, out VkExternalSemaphoreProperties pExternalSemaphoreProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, out pExternalSemaphoreProperties); + [Inline] public static void GetExternalSemaphorePropertiesKHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, out VkExternalSemaphoreProperties pExternalSemaphoreProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, out pExternalSemaphoreProperties); + [Inline] public static VkResult GetSemaphoreWin32HandleKHR(this VkDevice device, VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle) => VulkanLoadedFunctions.current.vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, out pHandle); + [Inline] public static VkResult ImportSemaphoreWin32HandleKHR(this VkDevice device, VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) => VulkanLoadedFunctions.current.vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + [Inline] public static VkResult GetSemaphoreFdKHR(this VkDevice device, VkSemaphoreGetFdInfoKHR* pGetFdInfo, out c_int pFd) => VulkanLoadedFunctions.current.vkGetSemaphoreFdKHR(device, pGetFdInfo, out pFd); + [Inline] public static VkResult ImportSemaphoreFdKHR(this VkDevice device, VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) => VulkanLoadedFunctions.current.vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + [Inline] public static VkResult GetSemaphoreZirconHandleFUCHSIA(this VkDevice device, VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, out zx_handle_t pZirconHandle) => VulkanLoadedFunctions.current.vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, out pZirconHandle); + [Inline] public static VkResult ImportSemaphoreZirconHandleFUCHSIA(this VkDevice device, VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) => VulkanLoadedFunctions.current.vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); + [Inline] public static void GetExternalFenceProperties(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, out VkExternalFenceProperties pExternalFenceProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, out pExternalFenceProperties); + [Inline] public static void GetExternalFencePropertiesKHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, out VkExternalFenceProperties pExternalFenceProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, out pExternalFenceProperties); + [Inline] public static VkResult GetFenceWin32HandleKHR(this VkDevice device, VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle) => VulkanLoadedFunctions.current.vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, out pHandle); + [Inline] public static VkResult ImportFenceWin32HandleKHR(this VkDevice device, VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) => VulkanLoadedFunctions.current.vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); + [Inline] public static VkResult GetFenceFdKHR(this VkDevice device, VkFenceGetFdInfoKHR* pGetFdInfo, out c_int pFd) => VulkanLoadedFunctions.current.vkGetFenceFdKHR(device, pGetFdInfo, out pFd); + [Inline] public static VkResult ImportFenceFdKHR(this VkDevice device, VkImportFenceFdInfoKHR* pImportFenceFdInfo) => VulkanLoadedFunctions.current.vkImportFenceFdKHR(device, pImportFenceFdInfo); + [Inline] public static VkResult ReleaseEXT(this VkDisplayKHR display, VkPhysicalDevice physicalDevice) => VulkanLoadedFunctions.current.vkReleaseDisplayEXT(physicalDevice, display); + [Inline] public static VkResult AcquireXlibDisplayEXT(this VkPhysicalDevice physicalDevice, out Display dpy, VkDisplayKHR display) => VulkanLoadedFunctions.current.vkAcquireXlibDisplayEXT(physicalDevice, out dpy, display); + [Inline] public static VkResult GetRandROutputDisplayEXT(this VkPhysicalDevice physicalDevice, out Display dpy, RROutput rrOutput, out VkDisplayKHR pDisplay) => VulkanLoadedFunctions.current.vkGetRandROutputDisplayEXT(physicalDevice, out dpy, rrOutput, out pDisplay); + [Inline] public static VkResult AcquireWinrtNV(this VkDisplayKHR display, VkPhysicalDevice physicalDevice) => VulkanLoadedFunctions.current.vkAcquireWinrtDisplayNV(physicalDevice, display); + [Inline] public static VkResult GetWinrtDisplayNV(this VkPhysicalDevice physicalDevice, uint32 deviceRelativeId, out VkDisplayKHR pDisplay) => VulkanLoadedFunctions.current.vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, out pDisplay); + [Inline] public static VkResult DisplayPowerControlEXT(this VkDevice device, VkDisplayKHR display, VkDisplayPowerInfoEXT* pDisplayPowerInfo) => VulkanLoadedFunctions.current.vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo); + [Inline] public static VkResult RegisterEventEXT(this VkDevice device, VkDeviceEventInfoEXT* pDeviceEventInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence) => VulkanLoadedFunctions.current.vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, out pFence); + [Inline] public static VkResult RegisterDisplayEventEXT(this VkDevice device, VkDisplayKHR display, VkDisplayEventInfoEXT* pDisplayEventInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence) => VulkanLoadedFunctions.current.vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, out pFence); + [Inline] public static VkResult GetCounterEXT(this VkSwapchainKHR swapchain, VkDevice device, VkSurfaceCounterFlagBitsEXT counter, out uint64 pCounterValue) => VulkanLoadedFunctions.current.vkGetSwapchainCounterEXT(device, swapchain, counter, out pCounterValue); + [Inline] public static VkResult GetSurfaceCapabilities2EXT(this VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out VkSurfaceCapabilities2EXT pSurfaceCapabilities) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, out pSurfaceCapabilities); + [Inline] public static VkResult EnumeratePhysicalDeviceGroups(this VkInstance instance, out uint32 pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDeviceGroups(instance, out pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + [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 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); + [Inline] public static VkResult GetGroupSurfacePresentModesKHR(this VkDevice device, VkSurfaceKHR surface, out VkDeviceGroupPresentModeFlagsKHR pModes) => VulkanLoadedFunctions.current.vkGetDeviceGroupSurfacePresentModesKHR(device, surface, out pModes); + [Inline] public static VkResult AcquireNextImage2KHR(this VkDevice device, VkAcquireNextImageInfoKHR* pAcquireInfo, out uint32 pImageIndex) => VulkanLoadedFunctions.current.vkAcquireNextImage2KHR(device, pAcquireInfo, out pImageIndex); + [Inline] public static void DispatchBase(this VkCommandBuffer commandBuffer, uint32 baseGroupX, uint32 baseGroupY, uint32 baseGroupZ, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) => VulkanLoadedFunctions.current.vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + [Inline] public static void DispatchBaseKHR(this VkCommandBuffer commandBuffer, uint32 baseGroupX, uint32 baseGroupY, uint32 baseGroupZ, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) => VulkanLoadedFunctions.current.vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + [Inline] public static VkResult GetPresentRectanglesKHR(this VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pRectCount, VkRect2D* pRects = null) => VulkanLoadedFunctions.current.vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, out pRectCount, pRects); + [Inline] public static VkResult CreateDescriptorUpdateTemplate(this VkDevice device, VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorUpdateTemplate pDescriptorUpdateTemplate) => VulkanLoadedFunctions.current.vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, out pDescriptorUpdateTemplate); + [Inline] public static VkResult CreateDescriptorUpdateTemplateKHR(this VkDevice device, VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorUpdateTemplate pDescriptorUpdateTemplate) => VulkanLoadedFunctions.current.vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, out pDescriptorUpdateTemplate); + [Inline] public static void Destroy(this VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); + [Inline] public static void DestroyKHR(this VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + [Inline] public static void UpdateDescriptorSetWithTemplate(this VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void* pData) => VulkanLoadedFunctions.current.vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); + [Inline] public static void UpdateDescriptorSetWithTemplateKHR(this VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void* pData) => VulkanLoadedFunctions.current.vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + [Inline] public static void PushDescriptorSetWithTemplate(this VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32 set, void* pData) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + [Inline] public static void PushDescriptorSetWithTemplateKHR(this VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32 set, void* pData) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + [Inline] public static void SetHdrMetadataEXT(this VkDevice device, uint32 swapchainCount, VkSwapchainKHR* pSwapchains, VkHdrMetadataEXT* pMetadata) => VulkanLoadedFunctions.current.vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); + [Inline] public static VkResult GetStatusKHR(this VkSwapchainKHR swapchain, VkDevice device) => VulkanLoadedFunctions.current.vkGetSwapchainStatusKHR(device, swapchain); + [Inline] public static VkResult GetRefreshCycleDurationGOOGLE(this VkSwapchainKHR swapchain, VkDevice device, out VkRefreshCycleDurationGOOGLE pDisplayTimingProperties) => VulkanLoadedFunctions.current.vkGetRefreshCycleDurationGOOGLE(device, swapchain, out pDisplayTimingProperties); + [Inline] public static VkResult GetPastPresentationTimingGOOGLE(this VkSwapchainKHR swapchain, VkDevice device, out uint32 pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings = null) => VulkanLoadedFunctions.current.vkGetPastPresentationTimingGOOGLE(device, swapchain, out pPresentationTimingCount, pPresentationTimings); + [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 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); + [Inline] public static void GetMultisamplePropertiesEXT(this VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, out VkMultisamplePropertiesEXT pMultisampleProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, out pMultisampleProperties); + [Inline] public static VkResult GetSurfaceCapabilities2KHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkSurfaceCapabilities2KHR pSurfaceCapabilities) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, out pSurfaceCapabilities); + [Inline] public static VkResult GetSurfaceFormats2KHR(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out uint32 pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, out pSurfaceFormatCount, pSurfaceFormats); + [Inline] public static VkResult GetDisplayProperties2KHR(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayProperties2KHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, out pPropertyCount, pProperties); + [Inline] public static VkResult GetDisplayPlaneProperties2KHR(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, out pPropertyCount, pProperties); + [Inline] public static VkResult GetModeProperties2KHR(this VkDisplayKHR display, VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayModeProperties2KHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetDisplayModeProperties2KHR(physicalDevice, display, out pPropertyCount, pProperties); + [Inline] public static VkResult GetDisplayPlaneCapabilities2KHR(this VkPhysicalDevice physicalDevice, VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, out VkDisplayPlaneCapabilities2KHR pCapabilities) => VulkanLoadedFunctions.current.vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, out pCapabilities); + [Inline] public static void GetBufferMemoryRequirements2(this VkDevice device, VkBufferMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetBufferMemoryRequirements2(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetBufferMemoryRequirements2KHR(this VkDevice device, VkBufferMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetBufferMemoryRequirements2KHR(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageMemoryRequirements2(this VkDevice device, VkImageMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetImageMemoryRequirements2(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageMemoryRequirements2KHR(this VkDevice device, VkImageMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetImageMemoryRequirements2KHR(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageSparseMemoryRequirements2(this VkDevice device, VkImageSparseMemoryRequirementsInfo2* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetImageSparseMemoryRequirements2(device, pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements); + [Inline] public static void GetImageSparseMemoryRequirements2KHR(this VkDevice device, VkImageSparseMemoryRequirementsInfo2* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetImageSparseMemoryRequirements2KHR(device, pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements); + [Inline] public static void GetBufferMemoryRequirements(this VkDevice device, VkDeviceBufferMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDeviceBufferMemoryRequirements(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetBufferMemoryRequirementsKHR(this VkDevice device, VkDeviceBufferMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageMemoryRequirements(this VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDeviceImageMemoryRequirements(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageMemoryRequirementsKHR(this VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, out pMemoryRequirements); + [Inline] public static void GetImageSparseMemoryRequirements(this VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetDeviceImageSparseMemoryRequirements(device, pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements); + [Inline] public static void GetImageSparseMemoryRequirementsKHR(this VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null) => VulkanLoadedFunctions.current.vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements); + [Inline] public static VkResult CreateSamplerYcbcrConversion(this VkDevice device, VkSamplerYcbcrConversionCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSamplerYcbcrConversion pYcbcrConversion) => VulkanLoadedFunctions.current.vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, out pYcbcrConversion); + [Inline] public static VkResult CreateSamplerYcbcrConversionKHR(this VkDevice device, VkSamplerYcbcrConversionCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSamplerYcbcrConversion pYcbcrConversion) => VulkanLoadedFunctions.current.vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, out pYcbcrConversion); + [Inline] public static void Destroy(this VkSamplerYcbcrConversion ycbcrConversion, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); + [Inline] public static void DestroyKHR(this VkSamplerYcbcrConversion ycbcrConversion, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); + [Inline] public static void GetQueue2(this VkDevice device, VkDeviceQueueInfo2* pQueueInfo, out VkQueue pQueue) => VulkanLoadedFunctions.current.vkGetDeviceQueue2(device, pQueueInfo, out pQueue); + [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 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); + [Inline] public static void SetLocalDimmingAMD(this VkSwapchainKHR swapChain, VkDevice device, VkBool32 localDimmingEnable) => VulkanLoadedFunctions.current.vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable); + [Inline] public static VkResult GetCalibrateableTimeDomainsKHR(this VkPhysicalDevice physicalDevice, out uint32 pTimeDomainCount, VkTimeDomainKHR* pTimeDomains = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, out pTimeDomainCount, pTimeDomains); + [Inline] public static VkResult GetCalibrateableTimeDomainsEXT(this VkPhysicalDevice physicalDevice, out uint32 pTimeDomainCount, VkTimeDomainKHR* pTimeDomains = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, out pTimeDomainCount, pTimeDomains); + [Inline] public static VkResult GetCalibratedTimestampsKHR(this VkDevice device, uint32 timestampCount, VkCalibratedTimestampInfoKHR* pTimestampInfos, out uint64 pTimestamps, out uint64 pMaxDeviation) => VulkanLoadedFunctions.current.vkGetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, out pTimestamps, out pMaxDeviation); + [Inline] public static VkResult GetCalibratedTimestampsEXT(this VkDevice device, uint32 timestampCount, VkCalibratedTimestampInfoKHR* pTimestampInfos, out uint64 pTimestamps, out uint64 pMaxDeviation) => VulkanLoadedFunctions.current.vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, out pTimestamps, out pMaxDeviation); + [Inline] public static VkResult SetDebugUtilsObjectNameEXT(this VkDevice device, VkDebugUtilsObjectNameInfoEXT* pNameInfo) => VulkanLoadedFunctions.current.vkSetDebugUtilsObjectNameEXT(device, pNameInfo); + [Inline] public static VkResult SetDebugUtilsObjectTagEXT(this VkDevice device, VkDebugUtilsObjectTagInfoEXT* pTagInfo) => VulkanLoadedFunctions.current.vkSetDebugUtilsObjectTagEXT(device, pTagInfo); + [Inline] public static void BeginDebugUtilsLabelEXT(this VkQueue queue, VkDebugUtilsLabelEXT* pLabelInfo) => VulkanLoadedFunctions.current.vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); + [Inline] public static void EndDebugUtilsLabelEXT(this VkQueue queue) => VulkanLoadedFunctions.current.vkQueueEndDebugUtilsLabelEXT(queue); + [Inline] public static void InsertDebugUtilsLabelEXT(this VkQueue queue, VkDebugUtilsLabelEXT* pLabelInfo) => VulkanLoadedFunctions.current.vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); + [Inline] public static void BeginDebugUtilsLabelEXT(this VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT* pLabelInfo) => VulkanLoadedFunctions.current.vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + [Inline] public static void EndDebugUtilsLabelEXT(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdEndDebugUtilsLabelEXT(commandBuffer); + [Inline] public static void InsertDebugUtilsLabelEXT(this VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT* pLabelInfo) => VulkanLoadedFunctions.current.vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + [Inline] public static VkResult CreateDebugUtilsMessengerEXT(this VkInstance instance, VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDebugUtilsMessengerEXT pMessenger) => VulkanLoadedFunctions.current.vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, out pMessenger); + [Inline] public static void DestroyEXT(this VkDebugUtilsMessengerEXT messenger, VkInstance instance, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); + [Inline] public static void SubmitDebugUtilsMessageEXT(this VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) => VulkanLoadedFunctions.current.vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); + [Inline] public static VkResult GetMemoryHostPointerPropertiesEXT(this VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, void* pHostPointer, out VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties) => VulkanLoadedFunctions.current.vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, out pMemoryHostPointerProperties); + [Inline] public static void WriteBufferMarkerAMD(this VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32 marker) => VulkanLoadedFunctions.current.vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + [Inline] public static VkResult CreateRenderPass2(this VkDevice device, VkRenderPassCreateInfo2* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkRenderPass pRenderPass) => VulkanLoadedFunctions.current.vkCreateRenderPass2(device, pCreateInfo, pAllocator, out pRenderPass); + [Inline] public static VkResult CreateRenderPass2KHR(this VkDevice device, VkRenderPassCreateInfo2* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkRenderPass pRenderPass) => VulkanLoadedFunctions.current.vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, out pRenderPass); + [Inline] public static void BeginRenderPass2(this VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassBeginInfo* pSubpassBeginInfo) => VulkanLoadedFunctions.current.vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + [Inline] public static void BeginRenderPass2KHR(this VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassBeginInfo* pSubpassBeginInfo) => VulkanLoadedFunctions.current.vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + [Inline] public static void NextSubpass2(this VkCommandBuffer commandBuffer, VkSubpassBeginInfo* pSubpassBeginInfo, VkSubpassEndInfo* pSubpassEndInfo) => VulkanLoadedFunctions.current.vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + [Inline] public static void NextSubpass2KHR(this VkCommandBuffer commandBuffer, VkSubpassBeginInfo* pSubpassBeginInfo, VkSubpassEndInfo* pSubpassEndInfo) => VulkanLoadedFunctions.current.vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + [Inline] public static void EndRenderPass2(this VkCommandBuffer commandBuffer, VkSubpassEndInfo* pSubpassEndInfo) => VulkanLoadedFunctions.current.vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); + [Inline] public static void EndRenderPass2KHR(this VkCommandBuffer commandBuffer, VkSubpassEndInfo* pSubpassEndInfo) => VulkanLoadedFunctions.current.vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); + [Inline] public static VkResult GetCounterValue(this VkSemaphore semaphore, VkDevice device, out uint64 pValue) => VulkanLoadedFunctions.current.vkGetSemaphoreCounterValue(device, semaphore, out pValue); + [Inline] public static VkResult GetCounterValueKHR(this VkSemaphore semaphore, VkDevice device, out uint64 pValue) => VulkanLoadedFunctions.current.vkGetSemaphoreCounterValueKHR(device, semaphore, out pValue); + [Inline] public static VkResult WaitSemaphores(this VkDevice device, VkSemaphoreWaitInfo* pWaitInfo, uint64 timeout) => VulkanLoadedFunctions.current.vkWaitSemaphores(device, pWaitInfo, timeout); + [Inline] public static VkResult WaitSemaphoresKHR(this VkDevice device, VkSemaphoreWaitInfo* pWaitInfo, uint64 timeout) => VulkanLoadedFunctions.current.vkWaitSemaphoresKHR(device, pWaitInfo, timeout); + [Inline] public static VkResult SignalSemaphore(this VkDevice device, VkSemaphoreSignalInfo* pSignalInfo) => VulkanLoadedFunctions.current.vkSignalSemaphore(device, pSignalInfo); + [Inline] public static VkResult SignalSemaphoreKHR(this VkDevice device, VkSemaphoreSignalInfo* pSignalInfo) => VulkanLoadedFunctions.current.vkSignalSemaphoreKHR(device, pSignalInfo); + [Inline] public static VkResult GetAndroidHardwareBufferPropertiesANDROID(this VkDevice device, out AHardwareBuffer buffer, out VkAndroidHardwareBufferPropertiesANDROID pProperties) => VulkanLoadedFunctions.current.vkGetAndroidHardwareBufferPropertiesANDROID(device, out buffer, out pProperties); + [Inline] public static VkResult GetMemoryAndroidHardwareBufferANDROID(this VkDevice device, VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, out AHardwareBuffer* pBuffer) => VulkanLoadedFunctions.current.vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, out pBuffer); + [Inline] public static void DrawIndirectCount(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void DrawIndirectCountKHR(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void DrawIndirectCountAMD(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void DrawIndexedIndirectCount(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void DrawIndexedIndirectCountKHR(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void DrawIndexedIndirectCountAMD(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static void SetCheckpointNV(this VkCommandBuffer commandBuffer, void* pCheckpointMarker) => VulkanLoadedFunctions.current.vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); + [Inline] public static void GetCheckpointDataNV(this VkQueue queue, out uint32 pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData = null) => VulkanLoadedFunctions.current.vkGetQueueCheckpointDataNV(queue, out pCheckpointDataCount, pCheckpointData); + [Inline] public static void BindTransformFeedbackBuffersEXT(this VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes = null) => VulkanLoadedFunctions.current.vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + [Inline] public static void BeginTransformFeedbackEXT(this VkCommandBuffer commandBuffer, uint32 firstCounterBuffer, uint32 counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets = null) => VulkanLoadedFunctions.current.vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + [Inline] public static void EndTransformFeedbackEXT(this VkCommandBuffer commandBuffer, uint32 firstCounterBuffer, uint32 counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets = null) => VulkanLoadedFunctions.current.vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + [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 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 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); + [Inline] public static void DrawMeshTasksEXT(this VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); + [Inline] public static void DrawMeshTasksIndirectEXT(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); + [Inline] public static void DrawMeshTasksIndirectCountEXT(this VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + [Inline] public static VkResult CompileDeferredNV(this VkPipeline pipeline, VkDevice device, uint32 shader) => VulkanLoadedFunctions.current.vkCompileDeferredNV(device, pipeline, shader); + [Inline] public static VkResult CreateAccelerationStructureNV(this VkDevice device, VkAccelerationStructureCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkAccelerationStructureNV pAccelerationStructure) => VulkanLoadedFunctions.current.vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, out pAccelerationStructure); + [Inline] public static void BindInvocationMaskHUAWEI(this VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) => VulkanLoadedFunctions.current.vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); + [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 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); + [Inline] public static void CopyAccelerationStructureToMemoryKHR(this VkCommandBuffer commandBuffer, VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + [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 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 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 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); + [Inline] public static void TraceRaysIndirectKHR(this VkCommandBuffer commandBuffer, VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) => VulkanLoadedFunctions.current.vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + [Inline] public static void TraceRaysIndirect2KHR(this VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) => VulkanLoadedFunctions.current.vkCmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); + [Inline] public static void GetClusterAccelerationStructureBuildSizesNV(this VkDevice device, VkClusterAccelerationStructureInputInfoNV* pInfo, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo) => VulkanLoadedFunctions.current.vkGetClusterAccelerationStructureBuildSizesNV(device, pInfo, out pSizeInfo); + [Inline] public static void BuildClusterAccelerationStructureIndirectNV(this VkCommandBuffer commandBuffer, VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) => VulkanLoadedFunctions.current.vkCmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos); + [Inline] public static void GetAccelerationStructureCompatibilityKHR(this VkDevice device, VkAccelerationStructureVersionInfoKHR* pVersionInfo, out VkAccelerationStructureCompatibilityKHR pCompatibility) => VulkanLoadedFunctions.current.vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, out pCompatibility); + [Inline] public static VkDeviceSize GetRayTracingShaderGroupStackSizeKHR(this VkPipeline pipeline, VkDevice device, uint32 group, VkShaderGroupShaderKHR groupShader) => VulkanLoadedFunctions.current.vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); + [Inline] public static void SetRayTracingPipelineStackSizeKHR(this VkCommandBuffer commandBuffer, uint32 pipelineStackSize) => VulkanLoadedFunctions.current.vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); + [Inline] public static uint32 GetImageViewHandleNVX(this VkDevice device, VkImageViewHandleInfoNVX* pInfo) => VulkanLoadedFunctions.current.vkGetImageViewHandleNVX(device, pInfo); + [Inline] public static uint64 GetImageViewHandle64NVX(this VkDevice device, VkImageViewHandleInfoNVX* pInfo) => VulkanLoadedFunctions.current.vkGetImageViewHandle64NVX(device, pInfo); + [Inline] public static VkResult GetAddressNVX(this VkImageView imageView, VkDevice device, out VkImageViewAddressPropertiesNVX pProperties) => VulkanLoadedFunctions.current.vkGetImageViewAddressNVX(device, imageView, out pProperties); + [Inline] public static VkResult GetSurfacePresentModes2EXT(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out uint32 pPresentModeCount, VkPresentModeKHR* pPresentModes = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, out pPresentModeCount, pPresentModes); + [Inline] public static VkResult GetGroupSurfacePresentModes2EXT(this VkDevice device, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkDeviceGroupPresentModeFlagsKHR pModes) => VulkanLoadedFunctions.current.vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, out pModes); + [Inline] public static VkResult AcquireFullScreenExclusiveModeEXT(this VkSwapchainKHR swapchain, VkDevice device) => VulkanLoadedFunctions.current.vkAcquireFullScreenExclusiveModeEXT(device, swapchain); + [Inline] public static VkResult ReleaseFullScreenExclusiveModeEXT(this VkSwapchainKHR swapchain, VkDevice device) => VulkanLoadedFunctions.current.vkReleaseFullScreenExclusiveModeEXT(device, swapchain); + [Inline] public static VkResult EnumerateQueueFamilyPerformanceQueryCountersKHR(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pCounterCount, VkPerformanceCounterKHR* pCounters = null, VkPerformanceCounterDescriptionKHR* pCounterDescriptions = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, out pCounterCount, pCounters, pCounterDescriptions); + [Inline] public static void GetQueueFamilyPerformanceQueryPassesKHR(this VkPhysicalDevice physicalDevice, VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, out uint32 pNumPasses) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, out pNumPasses); + [Inline] public static VkResult AcquireProfilingLockKHR(this VkDevice device, VkAcquireProfilingLockInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkAcquireProfilingLockKHR(device, pInfo); + [Inline] public static void ReleaseProfilingLockKHR(this VkDevice device) => VulkanLoadedFunctions.current.vkReleaseProfilingLockKHR(device); + [Inline] public static VkResult GetDrmFormatModifierPropertiesEXT(this VkImage image, VkDevice device, out VkImageDrmFormatModifierPropertiesEXT pProperties) => VulkanLoadedFunctions.current.vkGetImageDrmFormatModifierPropertiesEXT(device, image, out pProperties); + [Inline] public static uint64 GetBufferOpaqueCaptureAddress(this VkDevice device, VkBufferDeviceAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetBufferOpaqueCaptureAddress(device, pInfo); + [Inline] public static uint64 GetBufferOpaqueCaptureAddressKHR(this VkDevice device, VkBufferDeviceAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetBufferOpaqueCaptureAddressKHR(device, pInfo); + [Inline] public static VkDeviceAddress GetBufferAddress(this VkDevice device, VkBufferDeviceAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetBufferDeviceAddress(device, pInfo); + [Inline] public static VkDeviceAddress GetBufferAddressKHR(this VkDevice device, VkBufferDeviceAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetBufferDeviceAddressKHR(device, pInfo); + [Inline] public static VkDeviceAddress GetBufferAddressEXT(this VkDevice device, VkBufferDeviceAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetBufferDeviceAddressEXT(device, pInfo); + [Inline] public static VkResult CreateHeadlessSurfaceEXT(this VkInstance instance, VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface) => VulkanLoadedFunctions.current.vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, out pSurface); + [Inline] public static VkResult GetSupportedFramebufferMixedSamplesCombinationsNV(this VkPhysicalDevice physicalDevice, out uint32 pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, out pCombinationCount, pCombinations); + [Inline] public static VkResult InitializePerformanceApiINTEL(this VkDevice device, VkInitializePerformanceApiInfoINTEL* pInitializeInfo) => VulkanLoadedFunctions.current.vkInitializePerformanceApiINTEL(device, pInitializeInfo); + [Inline] public static void UninitializePerformanceApiINTEL(this VkDevice device) => VulkanLoadedFunctions.current.vkUninitializePerformanceApiINTEL(device); + [Inline] public static VkResult SetPerformanceMarkerINTEL(this VkCommandBuffer commandBuffer, VkPerformanceMarkerInfoINTEL* pMarkerInfo) => VulkanLoadedFunctions.current.vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + [Inline] public static VkResult SetPerformanceStreamMarkerINTEL(this VkCommandBuffer commandBuffer, VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) => VulkanLoadedFunctions.current.vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + [Inline] public static VkResult SetPerformanceOverrideINTEL(this VkCommandBuffer commandBuffer, VkPerformanceOverrideInfoINTEL* pOverrideInfo) => VulkanLoadedFunctions.current.vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + [Inline] public static VkResult AcquirePerformanceConfigurationINTEL(this VkDevice device, VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, out VkPerformanceConfigurationINTEL pConfiguration) => VulkanLoadedFunctions.current.vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, out pConfiguration); + [Inline] public static VkResult ReleaseINTEL(this VkPerformanceConfigurationINTEL configuration, VkDevice device) => VulkanLoadedFunctions.current.vkReleasePerformanceConfigurationINTEL(device, configuration); + [Inline] public static VkResult SetPerformanceConfigurationINTEL(this VkQueue queue, VkPerformanceConfigurationINTEL configuration) => VulkanLoadedFunctions.current.vkQueueSetPerformanceConfigurationINTEL(queue, configuration); + [Inline] public static VkResult GetPerformanceParameterINTEL(this VkDevice device, VkPerformanceParameterTypeINTEL parameter, out VkPerformanceValueINTEL pValue) => VulkanLoadedFunctions.current.vkGetPerformanceParameterINTEL(device, parameter, out pValue); + [Inline] public static uint64 GetMemoryOpaqueCaptureAddress(this VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + [Inline] public static uint64 GetMemoryOpaqueCaptureAddressKHR(this VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) => VulkanLoadedFunctions.current.vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); + [Inline] public static VkResult GetPipelineExecutablePropertiesKHR(this VkDevice device, VkPipelineInfoKHR* pPipelineInfo, out uint32 pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, out pExecutableCount, pProperties); + [Inline] public static VkResult GetPipelineExecutableStatisticsKHR(this VkDevice device, VkPipelineExecutableInfoKHR* pExecutableInfo, out uint32 pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics = null) => VulkanLoadedFunctions.current.vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, out pStatisticCount, pStatistics); + [Inline] public static VkResult GetPipelineExecutableInternalRepresentationsKHR(this VkDevice device, VkPipelineExecutableInfoKHR* pExecutableInfo, out uint32 pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations = null) => VulkanLoadedFunctions.current.vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, out pInternalRepresentationCount, pInternalRepresentations); + [Inline] public static void SetLineStipple(this VkCommandBuffer commandBuffer, uint32 lineStippleFactor, uint16 lineStipplePattern) => VulkanLoadedFunctions.current.vkCmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern); + [Inline] public static void SetLineStippleKHR(this VkCommandBuffer commandBuffer, uint32 lineStippleFactor, uint16 lineStipplePattern) => VulkanLoadedFunctions.current.vkCmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); + [Inline] public static void SetLineStippleEXT(this VkCommandBuffer commandBuffer, uint32 lineStippleFactor, uint16 lineStipplePattern) => VulkanLoadedFunctions.current.vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); + [Inline] public static VkResult GetToolProperties(this VkPhysicalDevice physicalDevice, out uint32 pToolCount, VkPhysicalDeviceToolProperties* pToolProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceToolProperties(physicalDevice, out pToolCount, pToolProperties); + [Inline] public static VkResult GetToolPropertiesEXT(this VkPhysicalDevice physicalDevice, out uint32 pToolCount, VkPhysicalDeviceToolProperties* pToolProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, out pToolCount, pToolProperties); + [Inline] public static VkResult CreateAccelerationStructureKHR(this VkDevice device, VkAccelerationStructureCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkAccelerationStructureKHR pAccelerationStructure) => VulkanLoadedFunctions.current.vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, out pAccelerationStructure); + [Inline] public static void BuildAccelerationStructuresKHR(this VkCommandBuffer commandBuffer, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkAccelerationStructureBuildRangeInfoKHR** ppBuildRangeInfos) => VulkanLoadedFunctions.current.vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + [Inline] public static void BuildAccelerationStructuresIndirectKHR(this VkCommandBuffer commandBuffer, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkDeviceAddress* pIndirectDeviceAddresses, uint32* pIndirectStrides, uint32** ppMaxPrimitiveCounts) => VulkanLoadedFunctions.current.vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + [Inline] public static VkResult BuildAccelerationStructuresKHR(this VkDeferredOperationKHR deferredOperation, VkDevice device, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkAccelerationStructureBuildRangeInfoKHR** ppBuildRangeInfos) => VulkanLoadedFunctions.current.vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + [Inline] public static VkDeviceAddress GetAccelerationStructureAddressKHR(this VkDevice device, VkAccelerationStructureDeviceAddressInfoKHR* pInfo) => VulkanLoadedFunctions.current.vkGetAccelerationStructureDeviceAddressKHR(device, pInfo); + [Inline] public static VkResult CreateDeferredOperationKHR(this VkDevice device, VkAllocationCallbacks* pAllocator, out VkDeferredOperationKHR pDeferredOperation) => VulkanLoadedFunctions.current.vkCreateDeferredOperationKHR(device, pAllocator, out pDeferredOperation); + [Inline] public static void DestroyKHR(this VkDeferredOperationKHR operation, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyDeferredOperationKHR(device, operation, pAllocator); + [Inline] public static uint32 GetMaxConcurrencyKHR(this VkDeferredOperationKHR operation, VkDevice device) => VulkanLoadedFunctions.current.vkGetDeferredOperationMaxConcurrencyKHR(device, operation); + [Inline] public static VkResult GetResultKHR(this VkDeferredOperationKHR operation, VkDevice device) => VulkanLoadedFunctions.current.vkGetDeferredOperationResultKHR(device, operation); + [Inline] public static VkResult JoinKHR(this VkDeferredOperationKHR operation, VkDevice device) => VulkanLoadedFunctions.current.vkDeferredOperationJoinKHR(device, operation); + [Inline] public static void GetPipelineIndirectMemoryRequirementsNV(this VkDevice device, VkComputePipelineCreateInfo* pCreateInfo, out VkMemoryRequirements2 pMemoryRequirements) => VulkanLoadedFunctions.current.vkGetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, out pMemoryRequirements); + [Inline] public static VkDeviceAddress GetPipelineIndirectAddressNV(this VkDevice device, VkPipelineIndirectDeviceAddressInfoNV* pInfo) => VulkanLoadedFunctions.current.vkGetPipelineIndirectDeviceAddressNV(device, pInfo); + [Inline] public static void AntiLagUpdateAMD(this VkDevice device, VkAntiLagDataAMD* pData) => VulkanLoadedFunctions.current.vkAntiLagUpdateAMD(device, pData); + [Inline] public static void SetCullMode(this VkCommandBuffer commandBuffer, VkCullModeFlags cullMode = default) => VulkanLoadedFunctions.current.vkCmdSetCullMode(commandBuffer, cullMode); + [Inline] public static void SetCullModeEXT(this VkCommandBuffer commandBuffer, VkCullModeFlags cullMode = default) => VulkanLoadedFunctions.current.vkCmdSetCullModeEXT(commandBuffer, cullMode); + [Inline] public static void SetFrontFace(this VkCommandBuffer commandBuffer, VkFrontFace frontFace) => VulkanLoadedFunctions.current.vkCmdSetFrontFace(commandBuffer, frontFace); + [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 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); + [Inline] public static void BindVertexBuffers2EXT(this VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes = null, VkDeviceSize* pStrides = null) => VulkanLoadedFunctions.current.vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + [Inline] public static void SetDepthTestEnable(this VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); + [Inline] public static void SetDepthTestEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); + [Inline] public static void SetDepthWriteEnable(this VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); + [Inline] public static void SetDepthWriteEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); + [Inline] public static void SetDepthCompareOp(this VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) => VulkanLoadedFunctions.current.vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); + [Inline] public static void SetDepthCompareOpEXT(this VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) => VulkanLoadedFunctions.current.vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); + [Inline] public static void SetDepthBoundsTestEnable(this VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); + [Inline] public static void SetDepthBoundsTestEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); + [Inline] public static void SetStencilTestEnable(this VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) => VulkanLoadedFunctions.current.vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); + [Inline] public static void SetStencilTestEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) => VulkanLoadedFunctions.current.vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); + [Inline] public static void SetStencilOp(this VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) => VulkanLoadedFunctions.current.vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + [Inline] public static void SetStencilOpEXT(this VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) => VulkanLoadedFunctions.current.vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + [Inline] public static void SetPatchControlPointsEXT(this VkCommandBuffer commandBuffer, uint32 patchControlPoints) => VulkanLoadedFunctions.current.vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + [Inline] public static void SetRasterizerDiscardEnable(this VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) => VulkanLoadedFunctions.current.vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); + [Inline] public static void SetRasterizerDiscardEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) => VulkanLoadedFunctions.current.vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); + [Inline] public static void SetDepthBiasEnable(this VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); + [Inline] public static void SetDepthBiasEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); + [Inline] public static void SetLogicOpEXT(this VkCommandBuffer commandBuffer, VkLogicOp logicOp) => VulkanLoadedFunctions.current.vkCmdSetLogicOpEXT(commandBuffer, logicOp); + [Inline] public static void SetPrimitiveRestartEnable(this VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) => VulkanLoadedFunctions.current.vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); + [Inline] public static void SetPrimitiveRestartEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) => VulkanLoadedFunctions.current.vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); + [Inline] public static void SetTessellationDomainOriginEXT(this VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) => VulkanLoadedFunctions.current.vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); + [Inline] public static void SetDepthClampEnableEXT(this VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) => VulkanLoadedFunctions.current.vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); + [Inline] public static void SetPolygonModeEXT(this VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) => VulkanLoadedFunctions.current.vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); + [Inline] public static void SetRasterizationSamplesEXT(this VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) => VulkanLoadedFunctions.current.vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); + [Inline] public static void SetSampleMaskEXT(this VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, VkSampleMask* pSampleMask = null) => VulkanLoadedFunctions.current.vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); + [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 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 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 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 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); + [Inline] public static VkResult CreatePrivateDataSlot(this VkDevice device, VkPrivateDataSlotCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPrivateDataSlot pPrivateDataSlot) => VulkanLoadedFunctions.current.vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, out pPrivateDataSlot); + [Inline] public static VkResult CreatePrivateDataSlotEXT(this VkDevice device, VkPrivateDataSlotCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPrivateDataSlot pPrivateDataSlot) => VulkanLoadedFunctions.current.vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, out pPrivateDataSlot); + [Inline] public static void Destroy(this VkPrivateDataSlot privateDataSlot, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator); + [Inline] public static void DestroyEXT(this VkPrivateDataSlot privateDataSlot, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); + [Inline] public static VkResult SetPrivateData(this VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, uint64 data) => VulkanLoadedFunctions.current.vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data); + [Inline] public static VkResult SetPrivateDataEXT(this VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, uint64 data) => VulkanLoadedFunctions.current.vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); + [Inline] public static void GetPrivateData(this VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, out uint64 pData) => VulkanLoadedFunctions.current.vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, out pData); + [Inline] public static void GetPrivateDataEXT(this VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, out uint64 pData) => VulkanLoadedFunctions.current.vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, out pData); + [Inline] public static void CopyBuffer2(this VkCommandBuffer commandBuffer, VkCopyBufferInfo2* pCopyBufferInfo) => VulkanLoadedFunctions.current.vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); + [Inline] public static void CopyBuffer2KHR(this VkCommandBuffer commandBuffer, VkCopyBufferInfo2* pCopyBufferInfo) => VulkanLoadedFunctions.current.vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); + [Inline] public static void CopyImage2(this VkCommandBuffer commandBuffer, VkCopyImageInfo2* pCopyImageInfo) => VulkanLoadedFunctions.current.vkCmdCopyImage2(commandBuffer, pCopyImageInfo); + [Inline] public static void CopyImage2KHR(this VkCommandBuffer commandBuffer, VkCopyImageInfo2* pCopyImageInfo) => VulkanLoadedFunctions.current.vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo); + [Inline] public static void BlitImage2(this VkCommandBuffer commandBuffer, VkBlitImageInfo2* pBlitImageInfo) => VulkanLoadedFunctions.current.vkCmdBlitImage2(commandBuffer, pBlitImageInfo); + [Inline] public static void BlitImage2KHR(this VkCommandBuffer commandBuffer, VkBlitImageInfo2* pBlitImageInfo) => VulkanLoadedFunctions.current.vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo); + [Inline] public static void CopyBufferToImage2(this VkCommandBuffer commandBuffer, VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) => VulkanLoadedFunctions.current.vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); + [Inline] public static void CopyBufferToImage2KHR(this VkCommandBuffer commandBuffer, VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) => VulkanLoadedFunctions.current.vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); + [Inline] public static void CopyImageToBuffer2(this VkCommandBuffer commandBuffer, VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) => VulkanLoadedFunctions.current.vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); + [Inline] public static void CopyImageToBuffer2KHR(this VkCommandBuffer commandBuffer, VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) => VulkanLoadedFunctions.current.vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); + [Inline] public static void ResolveImage2(this VkCommandBuffer commandBuffer, VkResolveImageInfo2* pResolveImageInfo) => VulkanLoadedFunctions.current.vkCmdResolveImage2(commandBuffer, pResolveImageInfo); + [Inline] public static void ResolveImage2KHR(this VkCommandBuffer commandBuffer, VkResolveImageInfo2* pResolveImageInfo) => VulkanLoadedFunctions.current.vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo); + [Inline] public static void SetFragmentShadingRateKHR(this VkCommandBuffer commandBuffer, VkExtent2D* pFragmentSize, VkFragmentShadingRateCombinerOpKHR[2] combinerOps) => VulkanLoadedFunctions.current.vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); + [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 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); + [Inline] public static void ResetEvent2KHR(this VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask = default) => VulkanLoadedFunctions.current.vkCmdResetEvent2KHR(commandBuffer, event, stageMask); + [Inline] public static void WaitEvents2(this VkCommandBuffer commandBuffer, uint32 eventCount, VkEvent* pEvents, VkDependencyInfo* pDependencyInfos) => VulkanLoadedFunctions.current.vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); + [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 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); + [Inline] public static void GetCheckpointData2NV(this VkQueue queue, out uint32 pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData = null) => VulkanLoadedFunctions.current.vkGetQueueCheckpointData2NV(queue, out pCheckpointDataCount, pCheckpointData); + [Inline] public static VkResult CopyMemoryToImage(this VkDevice device, VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) => VulkanLoadedFunctions.current.vkCopyMemoryToImage(device, pCopyMemoryToImageInfo); + [Inline] public static VkResult CopyMemoryToImageEXT(this VkDevice device, VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) => VulkanLoadedFunctions.current.vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); + [Inline] public static VkResult CopyImageToMemory(this VkDevice device, VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) => VulkanLoadedFunctions.current.vkCopyImageToMemory(device, pCopyImageToMemoryInfo); + [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 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); + [Inline] public static VkResult CreateVideoSessionKHR(this VkDevice device, VkVideoSessionCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkVideoSessionKHR pVideoSession) => VulkanLoadedFunctions.current.vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, out pVideoSession); + [Inline] public static void DestroyKHR(this VkVideoSessionKHR videoSession, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyVideoSessionKHR(device, videoSession, pAllocator); + [Inline] public static VkResult CreateVideoSessionParametersKHR(this VkDevice device, VkVideoSessionParametersCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkVideoSessionParametersKHR pVideoSessionParameters) => VulkanLoadedFunctions.current.vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, out pVideoSessionParameters); + [Inline] public static VkResult UpdateVideoSessionParametersKHR(this VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) => VulkanLoadedFunctions.current.vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); + [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 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 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); + [Inline] public static void DecompressMemoryEXT(this VkCommandBuffer commandBuffer, VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) => VulkanLoadedFunctions.current.vkCmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT); + [Inline] public static void DecompressMemoryIndirectCountEXT(this VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32 maxDecompressionCount, uint32 stride) => VulkanLoadedFunctions.current.vkCmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); + [Inline] public static VkResult CreateCuModuleNVX(this VkDevice device, VkCuModuleCreateInfoNVX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCuModuleNVX pModule) => VulkanLoadedFunctions.current.vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, out pModule); + [Inline] public static VkResult CreateCuFunctionNVX(this VkDevice device, VkCuFunctionCreateInfoNVX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCuFunctionNVX pFunction) => VulkanLoadedFunctions.current.vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, out pFunction); + [Inline] public static void DestroyNVX(this VkCuModuleNVX module, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyCuModuleNVX(device, module, pAllocator); + [Inline] public static void DestroyNVX(this VkCuFunctionNVX @function, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyCuFunctionNVX(device, @function, pAllocator); + [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 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); + [Inline] public static VkResult GetImageOpaqueCaptureDescriptorDataEXT(this VkDevice device, VkImageCaptureDescriptorDataInfoEXT* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, out pData); + [Inline] public static VkResult GetImageViewOpaqueCaptureDescriptorDataEXT(this VkDevice device, VkImageViewCaptureDescriptorDataInfoEXT* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, out pData); + [Inline] public static VkResult GetSamplerOpaqueCaptureDescriptorDataEXT(this VkDevice device, VkSamplerCaptureDescriptorDataInfoEXT* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, out pData); + [Inline] public static VkResult GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(this VkDevice device, VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, out pData); + [Inline] public static void SetPriorityEXT(this VkDeviceMemory memory, VkDevice device, float priority) => VulkanLoadedFunctions.current.vkSetDeviceMemoryPriorityEXT(device, memory, priority); + [Inline] public static VkResult AcquireDrmDisplayEXT(this VkPhysicalDevice physicalDevice, int32 drmFd, VkDisplayKHR display) => VulkanLoadedFunctions.current.vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display); + [Inline] public static VkResult GetDrmDisplayEXT(this VkPhysicalDevice physicalDevice, int32 drmFd, uint32 connectorId, out VkDisplayKHR display) => VulkanLoadedFunctions.current.vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, out display); + [Inline] public static VkResult WaitForPresent2KHR(this VkSwapchainKHR swapchain, VkDevice device, VkPresentWait2InfoKHR* pPresentWait2Info) => VulkanLoadedFunctions.current.vkWaitForPresent2KHR(device, swapchain, pPresentWait2Info); + [Inline] public static VkResult WaitForPresentKHR(this VkSwapchainKHR swapchain, VkDevice device, uint64 presentId, uint64 timeout) => VulkanLoadedFunctions.current.vkWaitForPresentKHR(device, swapchain, presentId, timeout); + [Inline] public static VkResult CreateBufferCollectionFUCHSIA(this VkDevice device, VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBufferCollectionFUCHSIA pCollection) => VulkanLoadedFunctions.current.vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, out pCollection); + [Inline] public static VkResult SetBufferConstraintsFUCHSIA(this VkBufferCollectionFUCHSIA collection, VkDevice device, VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) => VulkanLoadedFunctions.current.vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); + [Inline] public static VkResult SetImageConstraintsFUCHSIA(this VkBufferCollectionFUCHSIA collection, VkDevice device, VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) => VulkanLoadedFunctions.current.vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); + [Inline] public static void DestroyFUCHSIA(this VkBufferCollectionFUCHSIA collection, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator); + [Inline] public static VkResult GetPropertiesFUCHSIA(this VkBufferCollectionFUCHSIA collection, VkDevice device, out VkBufferCollectionPropertiesFUCHSIA pProperties) => VulkanLoadedFunctions.current.vkGetBufferCollectionPropertiesFUCHSIA(device, collection, out pProperties); + [Inline] public static VkResult CreateCudaModuleNV(this VkDevice device, VkCudaModuleCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCudaModuleNV pModule) => VulkanLoadedFunctions.current.vkCreateCudaModuleNV(device, pCreateInfo, pAllocator, out pModule); + [Inline] public static VkResult GetCacheNV(this VkCudaModuleNV module, VkDevice device, out c_size pCacheSize, void* pCacheData = null) => VulkanLoadedFunctions.current.vkGetCudaModuleCacheNV(device, module, out pCacheSize, pCacheData); + [Inline] public static VkResult CreateCudaFunctionNV(this VkDevice device, VkCudaFunctionCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCudaFunctionNV pFunction) => VulkanLoadedFunctions.current.vkCreateCudaFunctionNV(device, pCreateInfo, pAllocator, out pFunction); + [Inline] public static void DestroyNV(this VkCudaModuleNV module, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyCudaModuleNV(device, module, pAllocator); + [Inline] public static void DestroyNV(this VkCudaFunctionNV @function, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyCudaFunctionNV(device, @function, pAllocator); + [Inline] public static void CudaLaunchKernelNV(this VkCommandBuffer commandBuffer, VkCudaLaunchInfoNV* pLaunchInfo) => VulkanLoadedFunctions.current.vkCmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); + [Inline] public static void BeginRendering(this VkCommandBuffer commandBuffer, VkRenderingInfo* pRenderingInfo) => VulkanLoadedFunctions.current.vkCmdBeginRendering(commandBuffer, pRenderingInfo); + [Inline] public static void BeginRenderingKHR(this VkCommandBuffer commandBuffer, VkRenderingInfo* pRenderingInfo) => VulkanLoadedFunctions.current.vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo); + [Inline] public static void EndRendering(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdEndRendering(commandBuffer); + [Inline] public static void EndRendering2KHR(this VkCommandBuffer commandBuffer, VkRenderingEndInfoKHR* pRenderingEndInfo = null) => VulkanLoadedFunctions.current.vkCmdEndRendering2KHR(commandBuffer, pRenderingEndInfo); + [Inline] public static void EndRendering2EXT(this VkCommandBuffer commandBuffer, VkRenderingEndInfoKHR* pRenderingEndInfo = null) => VulkanLoadedFunctions.current.vkCmdEndRendering2EXT(commandBuffer, pRenderingEndInfo); + [Inline] public static void EndRenderingKHR(this VkCommandBuffer commandBuffer) => VulkanLoadedFunctions.current.vkCmdEndRenderingKHR(commandBuffer); + [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 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); + [Inline] public static void CopyMicromapToMemoryEXT(this VkCommandBuffer commandBuffer, VkCopyMicromapToMemoryInfoEXT* pInfo) => VulkanLoadedFunctions.current.vkCmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); + [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 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); + [Inline] public static void GetShaderModuleCreateInfoIdentifierEXT(this VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, out VkShaderModuleIdentifierEXT pIdentifier) => VulkanLoadedFunctions.current.vkGetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, out pIdentifier); + [Inline] public static void GetSubresourceLayout2(this VkImage image, VkDevice device, VkImageSubresource2* pSubresource, out VkSubresourceLayout2 pLayout) => VulkanLoadedFunctions.current.vkGetImageSubresourceLayout2(device, image, pSubresource, out pLayout); + [Inline] public static void GetSubresourceLayout2KHR(this VkImage image, VkDevice device, VkImageSubresource2* pSubresource, out VkSubresourceLayout2 pLayout) => VulkanLoadedFunctions.current.vkGetImageSubresourceLayout2KHR(device, image, pSubresource, out pLayout); + [Inline] public static void GetSubresourceLayout2EXT(this VkImage image, VkDevice device, VkImageSubresource2* pSubresource, out VkSubresourceLayout2 pLayout) => VulkanLoadedFunctions.current.vkGetImageSubresourceLayout2EXT(device, image, pSubresource, out pLayout); + [Inline] public static VkResult GetPipelinePropertiesEXT(this VkDevice device, VkPipelineInfoEXT* pPipelineInfo, out VkBaseOutStructure pPipelineProperties) => VulkanLoadedFunctions.current.vkGetPipelinePropertiesEXT(device, pPipelineInfo, out pPipelineProperties); + [Inline] public static void ExportMetalObjectsEXT(this VkDevice device, out VkExportMetalObjectsInfoEXT pMetalObjectsInfo) => VulkanLoadedFunctions.current.vkExportMetalObjectsEXT(device, out pMetalObjectsInfo); + [Inline] public static void BindTileMemoryQCOM(this VkCommandBuffer commandBuffer, VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo = null) => VulkanLoadedFunctions.current.vkCmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo); + [Inline] public static VkResult GetTilePropertiesQCOM(this VkFramebuffer framebuffer, VkDevice device, out uint32 pPropertiesCount, VkTilePropertiesQCOM* pProperties = null) => VulkanLoadedFunctions.current.vkGetFramebufferTilePropertiesQCOM(device, framebuffer, out pPropertiesCount, pProperties); + [Inline] public static VkResult GetDynamicRenderingTilePropertiesQCOM(this VkDevice device, VkRenderingInfo* pRenderingInfo, out VkTilePropertiesQCOM pProperties) => VulkanLoadedFunctions.current.vkGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, out pProperties); + [Inline] public static VkResult GetOpticalFlowImageFormatsNV(this VkPhysicalDevice physicalDevice, VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, out uint32 pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, out pFormatCount, pImageFormatProperties); + [Inline] public static VkResult CreateOpticalFlowSessionNV(this VkDevice device, VkOpticalFlowSessionCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkOpticalFlowSessionNV pSession) => VulkanLoadedFunctions.current.vkCreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, out pSession); + [Inline] public static void DestroyNV(this VkOpticalFlowSessionNV session, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyOpticalFlowSessionNV(device, session, pAllocator); + [Inline] public static VkResult BindImageNV(this VkOpticalFlowSessionNV session, VkDevice device, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) => VulkanLoadedFunctions.current.vkBindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); + [Inline] public static void OpticalFlowExecuteNV(this VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, VkOpticalFlowExecuteInfoNV* pExecuteInfo) => VulkanLoadedFunctions.current.vkCmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); + [Inline] public static VkResult GetFaultInfoEXT(this VkDevice device, out VkDeviceFaultCountsEXT pFaultCounts, out VkDeviceFaultInfoEXT pFaultInfo) => VulkanLoadedFunctions.current.vkGetDeviceFaultInfoEXT(device, out pFaultCounts, out pFaultInfo); + [Inline] public static void SetDepthBias2EXT(this VkCommandBuffer commandBuffer, VkDepthBiasInfoEXT* pDepthBiasInfo) => VulkanLoadedFunctions.current.vkCmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); + [Inline] public static VkResult ReleaseSwapchainImagesKHR(this VkDevice device, VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) => VulkanLoadedFunctions.current.vkReleaseSwapchainImagesKHR(device, pReleaseInfo); + [Inline] public static VkResult ReleaseSwapchainImagesEXT(this VkDevice device, VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) => VulkanLoadedFunctions.current.vkReleaseSwapchainImagesEXT(device, pReleaseInfo); + [Inline] public static void GetImageSubresourceLayout(this VkDevice device, VkDeviceImageSubresourceInfo* pInfo, out VkSubresourceLayout2 pLayout) => VulkanLoadedFunctions.current.vkGetDeviceImageSubresourceLayout(device, pInfo, out pLayout); + [Inline] public static void GetImageSubresourceLayoutKHR(this VkDevice device, VkDeviceImageSubresourceInfo* pInfo, out VkSubresourceLayout2 pLayout) => VulkanLoadedFunctions.current.vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, out pLayout); + [Inline] public static VkResult MapMemory2(this VkDevice device, VkMemoryMapInfo* pMemoryMapInfo, out void* ppData) => VulkanLoadedFunctions.current.vkMapMemory2(device, pMemoryMapInfo, out ppData); + [Inline] public static VkResult MapMemory2KHR(this VkDevice device, VkMemoryMapInfo* pMemoryMapInfo, out void* ppData) => VulkanLoadedFunctions.current.vkMapMemory2KHR(device, pMemoryMapInfo, out ppData); + [Inline] public static VkResult UnmapMemory2(this VkDevice device, VkMemoryUnmapInfo* pMemoryUnmapInfo) => VulkanLoadedFunctions.current.vkUnmapMemory2(device, pMemoryUnmapInfo); + [Inline] public static VkResult UnmapMemory2KHR(this VkDevice device, VkMemoryUnmapInfo* pMemoryUnmapInfo) => VulkanLoadedFunctions.current.vkUnmapMemory2KHR(device, pMemoryUnmapInfo); + [Inline] public static VkResult CreateShadersEXT(this VkDevice device, uint32 createInfoCount, VkShaderCreateInfoEXT* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkShaderEXT pShaders) => VulkanLoadedFunctions.current.vkCreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, out pShaders); + [Inline] public static void DestroyEXT(this VkShaderEXT shader, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyShaderEXT(device, shader, pAllocator); + [Inline] public static VkResult GetBinaryDataEXT(this VkShaderEXT shader, VkDevice device, out c_size pDataSize, void* pData = null) => VulkanLoadedFunctions.current.vkGetShaderBinaryDataEXT(device, shader, out pDataSize, pData); + [Inline] public static void BindShadersEXT(this VkCommandBuffer commandBuffer, uint32 stageCount, VkShaderStageFlagBits* pStages, VkShaderEXT* pShaders) => VulkanLoadedFunctions.current.vkCmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); + [Inline] public static VkResult SetPresentTimingQueueSizeEXT(this VkSwapchainKHR swapchain, VkDevice device, uint32 size) => VulkanLoadedFunctions.current.vkSetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size); + [Inline] public static VkResult GetTimingPropertiesEXT(this VkSwapchainKHR swapchain, VkDevice device, out VkSwapchainTimingPropertiesEXT pSwapchainTimingProperties, out uint64 pSwapchainTimingPropertiesCounter) => VulkanLoadedFunctions.current.vkGetSwapchainTimingPropertiesEXT(device, swapchain, out pSwapchainTimingProperties, out pSwapchainTimingPropertiesCounter); + [Inline] public static VkResult GetTimeDomainPropertiesEXT(this VkSwapchainKHR swapchain, VkDevice device, out VkSwapchainTimeDomainPropertiesEXT pSwapchainTimeDomainProperties, out uint64 pTimeDomainsCounter) => VulkanLoadedFunctions.current.vkGetSwapchainTimeDomainPropertiesEXT(device, swapchain, out pSwapchainTimeDomainProperties, out pTimeDomainsCounter); + [Inline] public static VkResult GetPastPresentationTimingEXT(this VkDevice device, VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, out VkPastPresentationTimingPropertiesEXT pPastPresentationTimingProperties) => VulkanLoadedFunctions.current.vkGetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, out pPastPresentationTimingProperties); + [Inline] public static VkResult GetScreenBufferPropertiesQNX(this VkDevice device, out _screen_buffer buffer, out VkScreenBufferPropertiesQNX pProperties) => VulkanLoadedFunctions.current.vkGetScreenBufferPropertiesQNX(device, out buffer, out pProperties); + [Inline] public static VkResult GetCooperativeMatrixPropertiesKHR(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, out pPropertyCount, pProperties); + [Inline] public static VkResult GetExecutionGraphScratchSizeAMDX(this VkPipeline executionGraph, VkDevice device, out VkExecutionGraphPipelineScratchSizeAMDX pSizeInfo) => VulkanLoadedFunctions.current.vkGetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, out pSizeInfo); + [Inline] public static VkResult GetExecutionGraphNodeIndexAMDX(this VkPipeline executionGraph, VkDevice device, VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, out uint32 pNodeIndex) => VulkanLoadedFunctions.current.vkGetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, out pNodeIndex); + [Inline] public static VkResult CreateExecutionGraphPipelinesAMDX(this VkPipelineCache pipelineCache, VkDevice device, uint32 createInfoCount, VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); + [Inline] public static void InitializeGraphScratchMemoryAMDX(this VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) => VulkanLoadedFunctions.current.vkCmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize); + [Inline] public static void DispatchGraphAMDX(this VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDispatchGraphCountInfoAMDX* pCountInfo) => VulkanLoadedFunctions.current.vkCmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo); + [Inline] public static void DispatchGraphIndirectAMDX(this VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDispatchGraphCountInfoAMDX* pCountInfo) => VulkanLoadedFunctions.current.vkCmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo); + [Inline] public static void DispatchGraphIndirectCountAMDX(this VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) => VulkanLoadedFunctions.current.vkCmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo); + [Inline] public static void BindDescriptorSets2(this VkCommandBuffer commandBuffer, VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) => VulkanLoadedFunctions.current.vkCmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo); + [Inline] public static void BindDescriptorSets2KHR(this VkCommandBuffer commandBuffer, VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) => VulkanLoadedFunctions.current.vkCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); + [Inline] public static void PushConstants2(this VkCommandBuffer commandBuffer, VkPushConstantsInfo* pPushConstantsInfo) => VulkanLoadedFunctions.current.vkCmdPushConstants2(commandBuffer, pPushConstantsInfo); + [Inline] public static void PushConstants2KHR(this VkCommandBuffer commandBuffer, VkPushConstantsInfo* pPushConstantsInfo) => VulkanLoadedFunctions.current.vkCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); + [Inline] public static void PushDescriptorSet2(this VkCommandBuffer commandBuffer, VkPushDescriptorSetInfo* pPushDescriptorSetInfo) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo); + [Inline] public static void PushDescriptorSet2KHR(this VkCommandBuffer commandBuffer, VkPushDescriptorSetInfo* pPushDescriptorSetInfo) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); + [Inline] public static void PushDescriptorSetWithTemplate2(this VkCommandBuffer commandBuffer, VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo); + [Inline] public static void PushDescriptorSetWithTemplate2KHR(this VkCommandBuffer commandBuffer, VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) => VulkanLoadedFunctions.current.vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); + [Inline] public static void SetDescriptorBufferOffsets2EXT(this VkCommandBuffer commandBuffer, VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) => VulkanLoadedFunctions.current.vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); + [Inline] public static void BindDescriptorBufferEmbeddedSamplers2EXT(this VkCommandBuffer commandBuffer, VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) => VulkanLoadedFunctions.current.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + [Inline] public static VkResult SetLatencySleepModeNV(this VkSwapchainKHR swapchain, VkDevice device, VkLatencySleepModeInfoNV* pSleepModeInfo) => VulkanLoadedFunctions.current.vkSetLatencySleepModeNV(device, swapchain, pSleepModeInfo); + [Inline] public static VkResult LatencySleepNV(this VkSwapchainKHR swapchain, VkDevice device, VkLatencySleepInfoNV* pSleepInfo) => VulkanLoadedFunctions.current.vkLatencySleepNV(device, swapchain, pSleepInfo); + [Inline] public static void SetLatencyMarkerNV(this VkSwapchainKHR swapchain, VkDevice device, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) => VulkanLoadedFunctions.current.vkSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); + [Inline] public static void GetLatencyTimingsNV(this VkSwapchainKHR swapchain, VkDevice device, out VkGetLatencyMarkerInfoNV pLatencyMarkerInfo) => VulkanLoadedFunctions.current.vkGetLatencyTimingsNV(device, swapchain, out pLatencyMarkerInfo); + [Inline] public static void NotifyOutOfBandNV(this VkQueue queue, VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) => VulkanLoadedFunctions.current.vkQueueNotifyOutOfBandNV(queue, pQueueTypeInfo); + [Inline] public static void SetRenderingAttachmentLocations(this VkCommandBuffer commandBuffer, VkRenderingAttachmentLocationInfo* pLocationInfo) => VulkanLoadedFunctions.current.vkCmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo); + [Inline] public static void SetRenderingAttachmentLocationsKHR(this VkCommandBuffer commandBuffer, VkRenderingAttachmentLocationInfo* pLocationInfo) => VulkanLoadedFunctions.current.vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); + [Inline] public static void SetRenderingInputAttachmentIndices(this VkCommandBuffer commandBuffer, VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) => VulkanLoadedFunctions.current.vkCmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo); + [Inline] public static void SetRenderingInputAttachmentIndicesKHR(this VkCommandBuffer commandBuffer, VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) => VulkanLoadedFunctions.current.vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); + [Inline] public static void SetDepthClampRangeEXT(this VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, VkDepthClampRangeEXT* pDepthClampRange = null) => VulkanLoadedFunctions.current.vkCmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); + [Inline] public static VkResult GetCooperativeMatrixFlexibleDimensionsPropertiesNV(this VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties = null) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, out pPropertyCount, pProperties); + [Inline] public static VkResult GetMemoryMetalHandleEXT(this VkDevice device, VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, out void* pHandle) => VulkanLoadedFunctions.current.vkGetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, out pHandle); + [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 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); + [Inline] public static VkResult CreateExternalComputeQueueNV(this VkDevice device, VkExternalComputeQueueCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkExternalComputeQueueNV pExternalQueue) => VulkanLoadedFunctions.current.vkCreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, out pExternalQueue); + [Inline] public static void DestroyNV(this VkExternalComputeQueueNV externalQueue, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyExternalComputeQueueNV(device, externalQueue, pAllocator); + [Inline] public static void GetDataNV(this VkExternalComputeQueueNV externalQueue, out VkExternalComputeQueueDataParamsNV @params, out void pData) => VulkanLoadedFunctions.current.vkGetExternalComputeQueueDataNV(externalQueue, out @params, out pData); + [Inline] public static VkResult CreateTensorARM(this VkDevice device, VkTensorCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkTensorARM pTensor) => VulkanLoadedFunctions.current.vkCreateTensorARM(device, pCreateInfo, pAllocator, out pTensor); + [Inline] public static void DestroyARM(this VkTensorARM tensor, VkDevice device, VkAllocationCallbacks* pAllocator = null) => VulkanLoadedFunctions.current.vkDestroyTensorARM(device, tensor, pAllocator); + [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 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); + [Inline] public static VkResult GetTensorViewOpaqueCaptureDescriptorDataARM(this VkDevice device, VkTensorViewCaptureDescriptorDataInfoARM* pInfo, out void pData) => VulkanLoadedFunctions.current.vkGetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, out pData); + [Inline] public static void GetExternalTensorPropertiesARM(this VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, out VkExternalTensorPropertiesARM pExternalTensorProperties) => VulkanLoadedFunctions.current.vkGetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, out pExternalTensorProperties); + [Inline] public static VkResult CreateDataGraphPipelinesARM(this VkDeferredOperationKHR deferredOperation, VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkDataGraphPipelineCreateInfoARM* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines) => VulkanLoadedFunctions.current.vkCreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, out pPipelines); + [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 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 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 EnumerateQueueFamilyPerformanceCountersByRegionARM(this VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pCounterCount, VkPerformanceCounterARM* pCounters = null, VkPerformanceCounterDescriptionARM* pCounterDescriptions = null) => VulkanLoadedFunctions.current.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, out pCounterCount, pCounters, pCounterDescriptions); +} + +namespace Vulkan; + +extension VkInstance +{ + public mixin EnumeratePhysicalDevices_Scope(out VkPhysicalDevice[] pPhysicalDevices) + { + VkResult result = this.EnumeratePhysicalDevices(var pPhysicalDeviceCount, null); + if (result == .VkSuccess) + { + pPhysicalDevices = scope:mixin .[pPhysicalDeviceCount]; + result = this.EnumeratePhysicalDevices(out pPhysicalDeviceCount, pPhysicalDevices.Ptr); + } + else + { + pPhysicalDevices = null; + } + result + } + public mixin EnumeratePhysicalDevices_New(out VkPhysicalDevice[] pPhysicalDevices) + { + VkResult result = this.EnumeratePhysicalDevices(var pPhysicalDeviceCount, null); + if (result == .VkSuccess) + { + pPhysicalDevices = new .[pPhysicalDeviceCount]; + result = this.EnumeratePhysicalDevices(out pPhysicalDeviceCount, pPhysicalDevices.Ptr); + } + else + { + pPhysicalDevices = null; + } + result + } + public mixin EnumeratePhysicalDevices_New(out VkPhysicalDevice[] pPhysicalDevices, IRawAllocator alloc) + { + VkResult result = this.EnumeratePhysicalDevices(var pPhysicalDeviceCount, null); + if (result == .VkSuccess) + { + pPhysicalDevices = new:alloc .[pPhysicalDeviceCount]; + result = this.EnumeratePhysicalDevices(out pPhysicalDeviceCount, pPhysicalDevices.Ptr); + } + else + { + pPhysicalDevices = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetQueueFamilyProperties_Scope(out VkQueueFamilyProperties[] pQueueFamilyProperties) + { + this.GetQueueFamilyProperties(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = scope:mixin .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } + public mixin GetQueueFamilyProperties_New(out VkQueueFamilyProperties[] pQueueFamilyProperties) + { + this.GetQueueFamilyProperties(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = new .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } + public mixin GetQueueFamilyProperties_New(out VkQueueFamilyProperties[] pQueueFamilyProperties, IRawAllocator alloc) + { + this.GetQueueFamilyProperties(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = new:alloc .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } +} + +static +{ + public static mixin vkEnumerateInstanceLayerProperties_Scope(out VkLayerProperties[] pProperties) + { + VkResult result = vkEnumerateInstanceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = vkEnumerateInstanceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public static mixin vkEnumerateInstanceLayerProperties_New(out VkLayerProperties[] pProperties) + { + VkResult result = vkEnumerateInstanceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = vkEnumerateInstanceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public static mixin vkEnumerateInstanceLayerProperties_New(out VkLayerProperties[] pProperties, IRawAllocator alloc) + { + VkResult result = vkEnumerateInstanceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = vkEnumerateInstanceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public static mixin vkEnumerateInstanceExtensionProperties_Scope(char8* pLayerName, out VkExtensionProperties[] pProperties) + { + VkResult result = vkEnumerateInstanceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = vkEnumerateInstanceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public static mixin vkEnumerateInstanceExtensionProperties_New(char8* pLayerName, out VkExtensionProperties[] pProperties) + { + VkResult result = vkEnumerateInstanceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = vkEnumerateInstanceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public static mixin vkEnumerateInstanceExtensionProperties_New(char8* pLayerName, out VkExtensionProperties[] pProperties, IRawAllocator alloc) + { + VkResult result = vkEnumerateInstanceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = vkEnumerateInstanceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin EnumerateDeviceLayerProperties_Scope(out VkLayerProperties[] pProperties) + { + VkResult result = this.EnumerateDeviceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.EnumerateDeviceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin EnumerateDeviceLayerProperties_New(out VkLayerProperties[] pProperties) + { + VkResult result = this.EnumerateDeviceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.EnumerateDeviceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin EnumerateDeviceLayerProperties_New(out VkLayerProperties[] pProperties, IRawAllocator alloc) + { + VkResult result = this.EnumerateDeviceLayerProperties(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.EnumerateDeviceLayerProperties(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin EnumerateDeviceExtensionProperties_Scope(char8* pLayerName, out VkExtensionProperties[] pProperties) + { + VkResult result = this.EnumerateDeviceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.EnumerateDeviceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin EnumerateDeviceExtensionProperties_New(char8* pLayerName, out VkExtensionProperties[] pProperties) + { + VkResult result = this.EnumerateDeviceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.EnumerateDeviceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin EnumerateDeviceExtensionProperties_New(char8* pLayerName, out VkExtensionProperties[] pProperties, IRawAllocator alloc) + { + VkResult result = this.EnumerateDeviceExtensionProperties(pLayerName, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.EnumerateDeviceExtensionProperties(pLayerName, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkImage +{ + public mixin GetSparseMemoryRequirements_Scope(VkDevice device, out VkSparseImageMemoryRequirements[] pSparseMemoryRequirements) + { + this.GetSparseMemoryRequirements(device, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = scope:mixin .[pSparseMemoryRequirementCount]; + this.GetSparseMemoryRequirements(device, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetSparseMemoryRequirements_New(VkDevice device, out VkSparseImageMemoryRequirements[] pSparseMemoryRequirements) + { + this.GetSparseMemoryRequirements(device, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new .[pSparseMemoryRequirementCount]; + this.GetSparseMemoryRequirements(device, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetSparseMemoryRequirements_New(VkDevice device, out VkSparseImageMemoryRequirements[] pSparseMemoryRequirements, IRawAllocator alloc) + { + this.GetSparseMemoryRequirements(device, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new:alloc .[pSparseMemoryRequirementCount]; + this.GetSparseMemoryRequirements(device, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } +} + +extension VkPhysicalDevice +{ + public mixin GetSparseImageFormatProperties_Scope(VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out VkSparseImageFormatProperties[] pProperties) + { + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, var pPropertyCount, null); + pProperties = scope:mixin .[pPropertyCount]; + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, out pPropertyCount, pProperties.Ptr); + } + public mixin GetSparseImageFormatProperties_New(VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out VkSparseImageFormatProperties[] pProperties) + { + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, var pPropertyCount, null); + pProperties = new .[pPropertyCount]; + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, out pPropertyCount, pProperties.Ptr); + } + public mixin GetSparseImageFormatProperties_New(VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out VkSparseImageFormatProperties[] pProperties, IRawAllocator alloc) + { + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, var pPropertyCount, null); + pProperties = new:alloc .[pPropertyCount]; + this.GetSparseImageFormatProperties(format, type, samples, usage, tiling, out pPropertyCount, pProperties.Ptr); + } +} + +extension VkPipelineCache +{ + public mixin GetData_Scope(VkDevice device, out void[] pData) + { + VkResult result = this.GetData(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = scope:mixin .[pDataSize]; + result = this.GetData(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetData_New(VkDevice device, out void[] pData) + { + VkResult result = this.GetData(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new .[pDataSize]; + result = this.GetData(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetData_New(VkDevice device, out void[] pData, IRawAllocator alloc) + { + VkResult result = this.GetData(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new:alloc .[pDataSize]; + result = this.GetData(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } +} + +extension VkDevice +{ + public mixin GetPipelineBinaryDataKHR_Scope(VkPipelineBinaryDataInfoKHR* pInfo, out VkPipelineBinaryKeyKHR pPipelineBinaryKey, out void[] pPipelineBinaryData) + { + VkResult result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, var pPipelineBinaryDataSize, null); + if (result == .VkSuccess) + { + pPipelineBinaryData = scope:mixin .[pPipelineBinaryDataSize]; + result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, out pPipelineBinaryDataSize, pPipelineBinaryData.Ptr); + } + else + { + pPipelineBinaryData = null; + } + result + } + public mixin GetPipelineBinaryDataKHR_New(VkPipelineBinaryDataInfoKHR* pInfo, out VkPipelineBinaryKeyKHR pPipelineBinaryKey, out void[] pPipelineBinaryData) + { + VkResult result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, var pPipelineBinaryDataSize, null); + if (result == .VkSuccess) + { + pPipelineBinaryData = new .[pPipelineBinaryDataSize]; + result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, out pPipelineBinaryDataSize, pPipelineBinaryData.Ptr); + } + else + { + pPipelineBinaryData = null; + } + result + } + public mixin GetPipelineBinaryDataKHR_New(VkPipelineBinaryDataInfoKHR* pInfo, out VkPipelineBinaryKeyKHR pPipelineBinaryKey, out void[] pPipelineBinaryData, IRawAllocator alloc) + { + VkResult result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, var pPipelineBinaryDataSize, null); + if (result == .VkSuccess) + { + pPipelineBinaryData = new:alloc .[pPipelineBinaryDataSize]; + result = this.GetPipelineBinaryDataKHR(pInfo, out pPipelineBinaryKey, out pPipelineBinaryDataSize, pPipelineBinaryData.Ptr); + } + else + { + pPipelineBinaryData = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetDisplayPropertiesKHR_Scope(out VkDisplayPropertiesKHR[] pProperties) + { + VkResult result = this.GetDisplayPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetDisplayPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPropertiesKHR_New(out VkDisplayPropertiesKHR[] pProperties) + { + VkResult result = this.GetDisplayPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetDisplayPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPropertiesKHR_New(out VkDisplayPropertiesKHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetDisplayPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetDisplayPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetDisplayPlanePropertiesKHR_Scope(out VkDisplayPlanePropertiesKHR[] pProperties) + { + VkResult result = this.GetDisplayPlanePropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetDisplayPlanePropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPlanePropertiesKHR_New(out VkDisplayPlanePropertiesKHR[] pProperties) + { + VkResult result = this.GetDisplayPlanePropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetDisplayPlanePropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPlanePropertiesKHR_New(out VkDisplayPlanePropertiesKHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetDisplayPlanePropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetDisplayPlanePropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetDisplayPlaneSupportedDisplaysKHR_Scope(uint32 planeIndex, out VkDisplayKHR[] pDisplays) + { + VkResult result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, var pDisplayCount, null); + if (result == .VkSuccess) + { + pDisplays = scope:mixin .[pDisplayCount]; + result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, out pDisplayCount, pDisplays.Ptr); + } + else + { + pDisplays = null; + } + result + } + public mixin GetDisplayPlaneSupportedDisplaysKHR_New(uint32 planeIndex, out VkDisplayKHR[] pDisplays) + { + VkResult result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, var pDisplayCount, null); + if (result == .VkSuccess) + { + pDisplays = new .[pDisplayCount]; + result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, out pDisplayCount, pDisplays.Ptr); + } + else + { + pDisplays = null; + } + result + } + public mixin GetDisplayPlaneSupportedDisplaysKHR_New(uint32 planeIndex, out VkDisplayKHR[] pDisplays, IRawAllocator alloc) + { + VkResult result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, var pDisplayCount, null); + if (result == .VkSuccess) + { + pDisplays = new:alloc .[pDisplayCount]; + result = this.GetDisplayPlaneSupportedDisplaysKHR(planeIndex, out pDisplayCount, pDisplays.Ptr); + } + else + { + pDisplays = null; + } + result + } +} + +extension VkDisplayKHR +{ + public mixin GetModePropertiesKHR_Scope(VkPhysicalDevice physicalDevice, out VkDisplayModePropertiesKHR[] pProperties) + { + VkResult result = this.GetModePropertiesKHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetModePropertiesKHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetModePropertiesKHR_New(VkPhysicalDevice physicalDevice, out VkDisplayModePropertiesKHR[] pProperties) + { + VkResult result = this.GetModePropertiesKHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetModePropertiesKHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetModePropertiesKHR_New(VkPhysicalDevice physicalDevice, out VkDisplayModePropertiesKHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetModePropertiesKHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetModePropertiesKHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetSurfaceFormatsKHR_Scope(VkSurfaceKHR surface, out VkSurfaceFormatKHR[] pSurfaceFormats) + { + VkResult result = this.GetSurfaceFormatsKHR(surface, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = scope:mixin .[pSurfaceFormatCount]; + result = this.GetSurfaceFormatsKHR(surface, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + public mixin GetSurfaceFormatsKHR_New(VkSurfaceKHR surface, out VkSurfaceFormatKHR[] pSurfaceFormats) + { + VkResult result = this.GetSurfaceFormatsKHR(surface, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = new .[pSurfaceFormatCount]; + result = this.GetSurfaceFormatsKHR(surface, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + public mixin GetSurfaceFormatsKHR_New(VkSurfaceKHR surface, out VkSurfaceFormatKHR[] pSurfaceFormats, IRawAllocator alloc) + { + VkResult result = this.GetSurfaceFormatsKHR(surface, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = new:alloc .[pSurfaceFormatCount]; + result = this.GetSurfaceFormatsKHR(surface, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + + public mixin GetSurfacePresentModesKHR_Scope(VkSurfaceKHR surface, out VkPresentModeKHR[] pPresentModes) + { + VkResult result = this.GetSurfacePresentModesKHR(surface, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = scope:mixin .[pPresentModeCount]; + result = this.GetSurfacePresentModesKHR(surface, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } + public mixin GetSurfacePresentModesKHR_New(VkSurfaceKHR surface, out VkPresentModeKHR[] pPresentModes) + { + VkResult result = this.GetSurfacePresentModesKHR(surface, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = new .[pPresentModeCount]; + result = this.GetSurfacePresentModesKHR(surface, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } + public mixin GetSurfacePresentModesKHR_New(VkSurfaceKHR surface, out VkPresentModeKHR[] pPresentModes, IRawAllocator alloc) + { + VkResult result = this.GetSurfacePresentModesKHR(surface, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = new:alloc .[pPresentModeCount]; + result = this.GetSurfacePresentModesKHR(surface, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } +} + +extension VkSwapchainKHR +{ + public mixin GetImagesKHR_Scope(VkDevice device, out VkImage[] pSwapchainImages) + { + VkResult result = this.GetImagesKHR(device, var pSwapchainImageCount, null); + if (result == .VkSuccess) + { + pSwapchainImages = scope:mixin .[pSwapchainImageCount]; + result = this.GetImagesKHR(device, out pSwapchainImageCount, pSwapchainImages.Ptr); + } + else + { + pSwapchainImages = null; + } + result + } + public mixin GetImagesKHR_New(VkDevice device, out VkImage[] pSwapchainImages) + { + VkResult result = this.GetImagesKHR(device, var pSwapchainImageCount, null); + if (result == .VkSuccess) + { + pSwapchainImages = new .[pSwapchainImageCount]; + result = this.GetImagesKHR(device, out pSwapchainImageCount, pSwapchainImages.Ptr); + } + else + { + pSwapchainImages = null; + } + result + } + public mixin GetImagesKHR_New(VkDevice device, out VkImage[] pSwapchainImages, IRawAllocator alloc) + { + VkResult result = this.GetImagesKHR(device, var pSwapchainImageCount, null); + if (result == .VkSuccess) + { + pSwapchainImages = new:alloc .[pSwapchainImageCount]; + result = this.GetImagesKHR(device, out pSwapchainImageCount, pSwapchainImages.Ptr); + } + else + { + pSwapchainImages = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetQueueFamilyProperties2_Scope(out VkQueueFamilyProperties2[] pQueueFamilyProperties) + { + this.GetQueueFamilyProperties2(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = scope:mixin .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties2(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } + public mixin GetQueueFamilyProperties2_New(out VkQueueFamilyProperties2[] pQueueFamilyProperties) + { + this.GetQueueFamilyProperties2(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = new .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties2(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } + public mixin GetQueueFamilyProperties2_New(out VkQueueFamilyProperties2[] pQueueFamilyProperties, IRawAllocator alloc) + { + this.GetQueueFamilyProperties2(var pQueueFamilyPropertyCount, null); + pQueueFamilyProperties = new:alloc .[pQueueFamilyPropertyCount]; + this.GetQueueFamilyProperties2(out pQueueFamilyPropertyCount, pQueueFamilyProperties.Ptr); + } + + public mixin GetSparseImageFormatProperties2_Scope(VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out VkSparseImageFormatProperties2[] pProperties) + { + this.GetSparseImageFormatProperties2(pFormatInfo, var pPropertyCount, null); + pProperties = scope:mixin .[pPropertyCount]; + this.GetSparseImageFormatProperties2(pFormatInfo, out pPropertyCount, pProperties.Ptr); + } + public mixin GetSparseImageFormatProperties2_New(VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out VkSparseImageFormatProperties2[] pProperties) + { + this.GetSparseImageFormatProperties2(pFormatInfo, var pPropertyCount, null); + pProperties = new .[pPropertyCount]; + this.GetSparseImageFormatProperties2(pFormatInfo, out pPropertyCount, pProperties.Ptr); + } + public mixin GetSparseImageFormatProperties2_New(VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out VkSparseImageFormatProperties2[] pProperties, IRawAllocator alloc) + { + this.GetSparseImageFormatProperties2(pFormatInfo, var pPropertyCount, null); + pProperties = new:alloc .[pPropertyCount]; + this.GetSparseImageFormatProperties2(pFormatInfo, out pPropertyCount, pProperties.Ptr); + } +} + +extension VkInstance +{ + public mixin EnumeratePhysicalDeviceGroups_Scope(out VkPhysicalDeviceGroupProperties[] pPhysicalDeviceGroupProperties) + { + VkResult result = this.EnumeratePhysicalDeviceGroups(var pPhysicalDeviceGroupCount, null); + if (result == .VkSuccess) + { + pPhysicalDeviceGroupProperties = scope:mixin .[pPhysicalDeviceGroupCount]; + result = this.EnumeratePhysicalDeviceGroups(out pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties.Ptr); + } + else + { + pPhysicalDeviceGroupProperties = null; + } + result + } + public mixin EnumeratePhysicalDeviceGroups_New(out VkPhysicalDeviceGroupProperties[] pPhysicalDeviceGroupProperties) + { + VkResult result = this.EnumeratePhysicalDeviceGroups(var pPhysicalDeviceGroupCount, null); + if (result == .VkSuccess) + { + pPhysicalDeviceGroupProperties = new .[pPhysicalDeviceGroupCount]; + result = this.EnumeratePhysicalDeviceGroups(out pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties.Ptr); + } + else + { + pPhysicalDeviceGroupProperties = null; + } + result + } + public mixin EnumeratePhysicalDeviceGroups_New(out VkPhysicalDeviceGroupProperties[] pPhysicalDeviceGroupProperties, IRawAllocator alloc) + { + VkResult result = this.EnumeratePhysicalDeviceGroups(var pPhysicalDeviceGroupCount, null); + if (result == .VkSuccess) + { + pPhysicalDeviceGroupProperties = new:alloc .[pPhysicalDeviceGroupCount]; + result = this.EnumeratePhysicalDeviceGroups(out pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties.Ptr); + } + else + { + pPhysicalDeviceGroupProperties = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetPresentRectanglesKHR_Scope(VkSurfaceKHR surface, out VkRect2D[] pRects) + { + VkResult result = this.GetPresentRectanglesKHR(surface, var pRectCount, null); + if (result == .VkSuccess) + { + pRects = scope:mixin .[pRectCount]; + result = this.GetPresentRectanglesKHR(surface, out pRectCount, pRects.Ptr); + } + else + { + pRects = null; + } + result + } + public mixin GetPresentRectanglesKHR_New(VkSurfaceKHR surface, out VkRect2D[] pRects) + { + VkResult result = this.GetPresentRectanglesKHR(surface, var pRectCount, null); + if (result == .VkSuccess) + { + pRects = new .[pRectCount]; + result = this.GetPresentRectanglesKHR(surface, out pRectCount, pRects.Ptr); + } + else + { + pRects = null; + } + result + } + public mixin GetPresentRectanglesKHR_New(VkSurfaceKHR surface, out VkRect2D[] pRects, IRawAllocator alloc) + { + VkResult result = this.GetPresentRectanglesKHR(surface, var pRectCount, null); + if (result == .VkSuccess) + { + pRects = new:alloc .[pRectCount]; + result = this.GetPresentRectanglesKHR(surface, out pRectCount, pRects.Ptr); + } + else + { + pRects = null; + } + result + } +} + +extension VkSwapchainKHR +{ + public mixin GetPastPresentationTimingGOOGLE_Scope(VkDevice device, out VkPastPresentationTimingGOOGLE[] pPresentationTimings) + { + VkResult result = this.GetPastPresentationTimingGOOGLE(device, var pPresentationTimingCount, null); + if (result == .VkSuccess) + { + pPresentationTimings = scope:mixin .[pPresentationTimingCount]; + result = this.GetPastPresentationTimingGOOGLE(device, out pPresentationTimingCount, pPresentationTimings.Ptr); + } + else + { + pPresentationTimings = null; + } + result + } + public mixin GetPastPresentationTimingGOOGLE_New(VkDevice device, out VkPastPresentationTimingGOOGLE[] pPresentationTimings) + { + VkResult result = this.GetPastPresentationTimingGOOGLE(device, var pPresentationTimingCount, null); + if (result == .VkSuccess) + { + pPresentationTimings = new .[pPresentationTimingCount]; + result = this.GetPastPresentationTimingGOOGLE(device, out pPresentationTimingCount, pPresentationTimings.Ptr); + } + else + { + pPresentationTimings = null; + } + result + } + public mixin GetPastPresentationTimingGOOGLE_New(VkDevice device, out VkPastPresentationTimingGOOGLE[] pPresentationTimings, IRawAllocator alloc) + { + VkResult result = this.GetPastPresentationTimingGOOGLE(device, var pPresentationTimingCount, null); + if (result == .VkSuccess) + { + pPresentationTimings = new:alloc .[pPresentationTimingCount]; + result = this.GetPastPresentationTimingGOOGLE(device, out pPresentationTimingCount, pPresentationTimings.Ptr); + } + else + { + pPresentationTimings = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetSurfaceFormats2KHR_Scope(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkSurfaceFormat2KHR[] pSurfaceFormats) + { + VkResult result = this.GetSurfaceFormats2KHR(pSurfaceInfo, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = scope:mixin .[pSurfaceFormatCount]; + result = this.GetSurfaceFormats2KHR(pSurfaceInfo, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + public mixin GetSurfaceFormats2KHR_New(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkSurfaceFormat2KHR[] pSurfaceFormats) + { + VkResult result = this.GetSurfaceFormats2KHR(pSurfaceInfo, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = new .[pSurfaceFormatCount]; + result = this.GetSurfaceFormats2KHR(pSurfaceInfo, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + public mixin GetSurfaceFormats2KHR_New(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkSurfaceFormat2KHR[] pSurfaceFormats, IRawAllocator alloc) + { + VkResult result = this.GetSurfaceFormats2KHR(pSurfaceInfo, var pSurfaceFormatCount, null); + if (result == .VkSuccess) + { + pSurfaceFormats = new:alloc .[pSurfaceFormatCount]; + result = this.GetSurfaceFormats2KHR(pSurfaceInfo, out pSurfaceFormatCount, pSurfaceFormats.Ptr); + } + else + { + pSurfaceFormats = null; + } + result + } + + public mixin GetDisplayProperties2KHR_Scope(out VkDisplayProperties2KHR[] pProperties) + { + VkResult result = this.GetDisplayProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetDisplayProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayProperties2KHR_New(out VkDisplayProperties2KHR[] pProperties) + { + VkResult result = this.GetDisplayProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetDisplayProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayProperties2KHR_New(out VkDisplayProperties2KHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetDisplayProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetDisplayProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetDisplayPlaneProperties2KHR_Scope(out VkDisplayPlaneProperties2KHR[] pProperties) + { + VkResult result = this.GetDisplayPlaneProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetDisplayPlaneProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPlaneProperties2KHR_New(out VkDisplayPlaneProperties2KHR[] pProperties) + { + VkResult result = this.GetDisplayPlaneProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetDisplayPlaneProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDisplayPlaneProperties2KHR_New(out VkDisplayPlaneProperties2KHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetDisplayPlaneProperties2KHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetDisplayPlaneProperties2KHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkDisplayKHR +{ + public mixin GetModeProperties2KHR_Scope(VkPhysicalDevice physicalDevice, out VkDisplayModeProperties2KHR[] pProperties) + { + VkResult result = this.GetModeProperties2KHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetModeProperties2KHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetModeProperties2KHR_New(VkPhysicalDevice physicalDevice, out VkDisplayModeProperties2KHR[] pProperties) + { + VkResult result = this.GetModeProperties2KHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetModeProperties2KHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetModeProperties2KHR_New(VkPhysicalDevice physicalDevice, out VkDisplayModeProperties2KHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetModeProperties2KHR(physicalDevice, var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetModeProperties2KHR(physicalDevice, out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkDevice +{ + public mixin GetImageSparseMemoryRequirements2_Scope(VkImageSparseMemoryRequirementsInfo2* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements) + { + this.GetImageSparseMemoryRequirements2(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = scope:mixin .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements2(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetImageSparseMemoryRequirements2_New(VkImageSparseMemoryRequirementsInfo2* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements) + { + this.GetImageSparseMemoryRequirements2(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements2(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetImageSparseMemoryRequirements2_New(VkImageSparseMemoryRequirementsInfo2* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements, IRawAllocator alloc) + { + this.GetImageSparseMemoryRequirements2(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new:alloc .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements2(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + + public mixin GetImageSparseMemoryRequirements_Scope(VkDeviceImageMemoryRequirements* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements) + { + this.GetImageSparseMemoryRequirements(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = scope:mixin .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetImageSparseMemoryRequirements_New(VkDeviceImageMemoryRequirements* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements) + { + this.GetImageSparseMemoryRequirements(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } + public mixin GetImageSparseMemoryRequirements_New(VkDeviceImageMemoryRequirements* pInfo, out VkSparseImageMemoryRequirements2[] pSparseMemoryRequirements, IRawAllocator alloc) + { + this.GetImageSparseMemoryRequirements(pInfo, var pSparseMemoryRequirementCount, null); + pSparseMemoryRequirements = new:alloc .[pSparseMemoryRequirementCount]; + this.GetImageSparseMemoryRequirements(pInfo, out pSparseMemoryRequirementCount, pSparseMemoryRequirements.Ptr); + } +} + +extension VkValidationCacheEXT +{ + public mixin GetDataEXT_Scope(VkDevice device, out void[] pData) + { + VkResult result = this.GetDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = scope:mixin .[pDataSize]; + result = this.GetDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetDataEXT_New(VkDevice device, out void[] pData) + { + VkResult result = this.GetDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new .[pDataSize]; + result = this.GetDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetDataEXT_New(VkDevice device, out void[] pData, IRawAllocator alloc) + { + VkResult result = this.GetDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new:alloc .[pDataSize]; + result = this.GetDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } +} + +extension VkPipeline +{ + public mixin GetShaderInfoAMD_Scope(VkDevice device, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out void[] pInfo) + { + VkResult result = this.GetShaderInfoAMD(device, shaderStage, infoType, var pInfoSize, null); + if (result == .VkSuccess) + { + pInfo = scope:mixin .[pInfoSize]; + result = this.GetShaderInfoAMD(device, shaderStage, infoType, out pInfoSize, pInfo.Ptr); + } + else + { + pInfo = null; + } + result + } + public mixin GetShaderInfoAMD_New(VkDevice device, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out void[] pInfo) + { + VkResult result = this.GetShaderInfoAMD(device, shaderStage, infoType, var pInfoSize, null); + if (result == .VkSuccess) + { + pInfo = new .[pInfoSize]; + result = this.GetShaderInfoAMD(device, shaderStage, infoType, out pInfoSize, pInfo.Ptr); + } + else + { + pInfo = null; + } + result + } + public mixin GetShaderInfoAMD_New(VkDevice device, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out void[] pInfo, IRawAllocator alloc) + { + VkResult result = this.GetShaderInfoAMD(device, shaderStage, infoType, var pInfoSize, null); + if (result == .VkSuccess) + { + pInfo = new:alloc .[pInfoSize]; + result = this.GetShaderInfoAMD(device, shaderStage, infoType, out pInfoSize, pInfo.Ptr); + } + else + { + pInfo = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetCalibrateableTimeDomainsKHR_Scope(out VkTimeDomainKHR[] pTimeDomains) + { + VkResult result = this.GetCalibrateableTimeDomainsKHR(var pTimeDomainCount, null); + if (result == .VkSuccess) + { + pTimeDomains = scope:mixin .[pTimeDomainCount]; + result = this.GetCalibrateableTimeDomainsKHR(out pTimeDomainCount, pTimeDomains.Ptr); + } + else + { + pTimeDomains = null; + } + result + } + public mixin GetCalibrateableTimeDomainsKHR_New(out VkTimeDomainKHR[] pTimeDomains) + { + VkResult result = this.GetCalibrateableTimeDomainsKHR(var pTimeDomainCount, null); + if (result == .VkSuccess) + { + pTimeDomains = new .[pTimeDomainCount]; + result = this.GetCalibrateableTimeDomainsKHR(out pTimeDomainCount, pTimeDomains.Ptr); + } + else + { + pTimeDomains = null; + } + result + } + public mixin GetCalibrateableTimeDomainsKHR_New(out VkTimeDomainKHR[] pTimeDomains, IRawAllocator alloc) + { + VkResult result = this.GetCalibrateableTimeDomainsKHR(var pTimeDomainCount, null); + if (result == .VkSuccess) + { + pTimeDomains = new:alloc .[pTimeDomainCount]; + result = this.GetCalibrateableTimeDomainsKHR(out pTimeDomainCount, pTimeDomains.Ptr); + } + else + { + pTimeDomains = null; + } + result + } +} + +extension VkQueue +{ + public mixin GetCheckpointDataNV_Scope(out VkCheckpointDataNV[] pCheckpointData) + { + this.GetCheckpointDataNV(var pCheckpointDataCount, null); + pCheckpointData = scope:mixin .[pCheckpointDataCount]; + this.GetCheckpointDataNV(out pCheckpointDataCount, pCheckpointData.Ptr); + } + public mixin GetCheckpointDataNV_New(out VkCheckpointDataNV[] pCheckpointData) + { + this.GetCheckpointDataNV(var pCheckpointDataCount, null); + pCheckpointData = new .[pCheckpointDataCount]; + this.GetCheckpointDataNV(out pCheckpointDataCount, pCheckpointData.Ptr); + } + public mixin GetCheckpointDataNV_New(out VkCheckpointDataNV[] pCheckpointData, IRawAllocator alloc) + { + this.GetCheckpointDataNV(var pCheckpointDataCount, null); + pCheckpointData = new:alloc .[pCheckpointDataCount]; + this.GetCheckpointDataNV(out pCheckpointDataCount, pCheckpointData.Ptr); + } +} + +extension VkPhysicalDevice +{ + public mixin GetCooperativeMatrixPropertiesNV_Scope(out VkCooperativeMatrixPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeMatrixPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixPropertiesNV_New(out VkCooperativeMatrixPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeMatrixPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixPropertiesNV_New(out VkCooperativeMatrixPropertiesNV[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetCooperativeMatrixPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetSurfacePresentModes2EXT_Scope(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkPresentModeKHR[] pPresentModes) + { + VkResult result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = scope:mixin .[pPresentModeCount]; + result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } + public mixin GetSurfacePresentModes2EXT_New(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkPresentModeKHR[] pPresentModes) + { + VkResult result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = new .[pPresentModeCount]; + result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } + public mixin GetSurfacePresentModes2EXT_New(VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkPresentModeKHR[] pPresentModes, IRawAllocator alloc) + { + VkResult result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, var pPresentModeCount, null); + if (result == .VkSuccess) + { + pPresentModes = new:alloc .[pPresentModeCount]; + result = this.GetSurfacePresentModes2EXT(pSurfaceInfo, out pPresentModeCount, pPresentModes.Ptr); + } + else + { + pPresentModes = null; + } + result + } + + public mixin EnumerateQueueFamilyPerformanceQueryCountersKHR_Scope(uint32 queueFamilyIndex, out VkPerformanceCounterKHR[] pCounters, out VkPerformanceCounterDescriptionKHR[] pCounterDescriptions) + { + VkResult result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = scope:mixin .[pCounterCount]; + pCounterDescriptions = scope:mixin .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } + public mixin EnumerateQueueFamilyPerformanceQueryCountersKHR_New(uint32 queueFamilyIndex, out VkPerformanceCounterKHR[] pCounters, out VkPerformanceCounterDescriptionKHR[] pCounterDescriptions) + { + VkResult result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = new .[pCounterCount]; + pCounterDescriptions = new .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } + public mixin EnumerateQueueFamilyPerformanceQueryCountersKHR_New(uint32 queueFamilyIndex, out VkPerformanceCounterKHR[] pCounters, out VkPerformanceCounterDescriptionKHR[] pCounterDescriptions, IRawAllocator alloc) + { + VkResult result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = new:alloc .[pCounterCount]; + pCounterDescriptions = new:alloc .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceQueryCountersKHR(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } + + public mixin GetSupportedFramebufferMixedSamplesCombinationsNV_Scope(out VkFramebufferMixedSamplesCombinationNV[] pCombinations) + { + VkResult result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(var pCombinationCount, null); + if (result == .VkSuccess) + { + pCombinations = scope:mixin .[pCombinationCount]; + result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(out pCombinationCount, pCombinations.Ptr); + } + else + { + pCombinations = null; + } + result + } + public mixin GetSupportedFramebufferMixedSamplesCombinationsNV_New(out VkFramebufferMixedSamplesCombinationNV[] pCombinations) + { + VkResult result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(var pCombinationCount, null); + if (result == .VkSuccess) + { + pCombinations = new .[pCombinationCount]; + result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(out pCombinationCount, pCombinations.Ptr); + } + else + { + pCombinations = null; + } + result + } + public mixin GetSupportedFramebufferMixedSamplesCombinationsNV_New(out VkFramebufferMixedSamplesCombinationNV[] pCombinations, IRawAllocator alloc) + { + VkResult result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(var pCombinationCount, null); + if (result == .VkSuccess) + { + pCombinations = new:alloc .[pCombinationCount]; + result = this.GetSupportedFramebufferMixedSamplesCombinationsNV(out pCombinationCount, pCombinations.Ptr); + } + else + { + pCombinations = null; + } + result + } +} + +extension VkDevice +{ + public mixin GetPipelineExecutablePropertiesKHR_Scope(VkPipelineInfoKHR* pPipelineInfo, out VkPipelineExecutablePropertiesKHR[] pProperties) + { + VkResult result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, var pExecutableCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pExecutableCount]; + result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, out pExecutableCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetPipelineExecutablePropertiesKHR_New(VkPipelineInfoKHR* pPipelineInfo, out VkPipelineExecutablePropertiesKHR[] pProperties) + { + VkResult result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, var pExecutableCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pExecutableCount]; + result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, out pExecutableCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetPipelineExecutablePropertiesKHR_New(VkPipelineInfoKHR* pPipelineInfo, out VkPipelineExecutablePropertiesKHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, var pExecutableCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pExecutableCount]; + result = this.GetPipelineExecutablePropertiesKHR(pPipelineInfo, out pExecutableCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetPipelineExecutableStatisticsKHR_Scope(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableStatisticKHR[] pStatistics) + { + VkResult result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, var pStatisticCount, null); + if (result == .VkSuccess) + { + pStatistics = scope:mixin .[pStatisticCount]; + result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, out pStatisticCount, pStatistics.Ptr); + } + else + { + pStatistics = null; + } + result + } + public mixin GetPipelineExecutableStatisticsKHR_New(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableStatisticKHR[] pStatistics) + { + VkResult result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, var pStatisticCount, null); + if (result == .VkSuccess) + { + pStatistics = new .[pStatisticCount]; + result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, out pStatisticCount, pStatistics.Ptr); + } + else + { + pStatistics = null; + } + result + } + public mixin GetPipelineExecutableStatisticsKHR_New(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableStatisticKHR[] pStatistics, IRawAllocator alloc) + { + VkResult result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, var pStatisticCount, null); + if (result == .VkSuccess) + { + pStatistics = new:alloc .[pStatisticCount]; + result = this.GetPipelineExecutableStatisticsKHR(pExecutableInfo, out pStatisticCount, pStatistics.Ptr); + } + else + { + pStatistics = null; + } + result + } + + public mixin GetPipelineExecutableInternalRepresentationsKHR_Scope(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableInternalRepresentationKHR[] pInternalRepresentations) + { + VkResult result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, var pInternalRepresentationCount, null); + if (result == .VkSuccess) + { + pInternalRepresentations = scope:mixin .[pInternalRepresentationCount]; + result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, out pInternalRepresentationCount, pInternalRepresentations.Ptr); + } + else + { + pInternalRepresentations = null; + } + result + } + public mixin GetPipelineExecutableInternalRepresentationsKHR_New(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableInternalRepresentationKHR[] pInternalRepresentations) + { + VkResult result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, var pInternalRepresentationCount, null); + if (result == .VkSuccess) + { + pInternalRepresentations = new .[pInternalRepresentationCount]; + result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, out pInternalRepresentationCount, pInternalRepresentations.Ptr); + } + else + { + pInternalRepresentations = null; + } + result + } + public mixin GetPipelineExecutableInternalRepresentationsKHR_New(VkPipelineExecutableInfoKHR* pExecutableInfo, out VkPipelineExecutableInternalRepresentationKHR[] pInternalRepresentations, IRawAllocator alloc) + { + VkResult result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, var pInternalRepresentationCount, null); + if (result == .VkSuccess) + { + pInternalRepresentations = new:alloc .[pInternalRepresentationCount]; + result = this.GetPipelineExecutableInternalRepresentationsKHR(pExecutableInfo, out pInternalRepresentationCount, pInternalRepresentations.Ptr); + } + else + { + pInternalRepresentations = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetToolProperties_Scope(out VkPhysicalDeviceToolProperties[] pToolProperties) + { + VkResult result = this.GetToolProperties(var pToolCount, null); + if (result == .VkSuccess) + { + pToolProperties = scope:mixin .[pToolCount]; + result = this.GetToolProperties(out pToolCount, pToolProperties.Ptr); + } + else + { + pToolProperties = null; + } + result + } + public mixin GetToolProperties_New(out VkPhysicalDeviceToolProperties[] pToolProperties) + { + VkResult result = this.GetToolProperties(var pToolCount, null); + if (result == .VkSuccess) + { + pToolProperties = new .[pToolCount]; + result = this.GetToolProperties(out pToolCount, pToolProperties.Ptr); + } + else + { + pToolProperties = null; + } + result + } + public mixin GetToolProperties_New(out VkPhysicalDeviceToolProperties[] pToolProperties, IRawAllocator alloc) + { + VkResult result = this.GetToolProperties(var pToolCount, null); + if (result == .VkSuccess) + { + pToolProperties = new:alloc .[pToolCount]; + result = this.GetToolProperties(out pToolCount, pToolProperties.Ptr); + } + else + { + pToolProperties = null; + } + result + } + + public mixin GetFragmentShadingRatesKHR_Scope(out VkPhysicalDeviceFragmentShadingRateKHR[] pFragmentShadingRates) + { + VkResult result = this.GetFragmentShadingRatesKHR(var pFragmentShadingRateCount, null); + if (result == .VkSuccess) + { + pFragmentShadingRates = scope:mixin .[pFragmentShadingRateCount]; + result = this.GetFragmentShadingRatesKHR(out pFragmentShadingRateCount, pFragmentShadingRates.Ptr); + } + else + { + pFragmentShadingRates = null; + } + result + } + public mixin GetFragmentShadingRatesKHR_New(out VkPhysicalDeviceFragmentShadingRateKHR[] pFragmentShadingRates) + { + VkResult result = this.GetFragmentShadingRatesKHR(var pFragmentShadingRateCount, null); + if (result == .VkSuccess) + { + pFragmentShadingRates = new .[pFragmentShadingRateCount]; + result = this.GetFragmentShadingRatesKHR(out pFragmentShadingRateCount, pFragmentShadingRates.Ptr); + } + else + { + pFragmentShadingRates = null; + } + result + } + public mixin GetFragmentShadingRatesKHR_New(out VkPhysicalDeviceFragmentShadingRateKHR[] pFragmentShadingRates, IRawAllocator alloc) + { + VkResult result = this.GetFragmentShadingRatesKHR(var pFragmentShadingRateCount, null); + if (result == .VkSuccess) + { + pFragmentShadingRates = new:alloc .[pFragmentShadingRateCount]; + result = this.GetFragmentShadingRatesKHR(out pFragmentShadingRateCount, pFragmentShadingRates.Ptr); + } + else + { + pFragmentShadingRates = null; + } + result + } +} + +extension VkQueue +{ + public mixin GetCheckpointData2NV_Scope(out VkCheckpointData2NV[] pCheckpointData) + { + this.GetCheckpointData2NV(var pCheckpointDataCount, null); + pCheckpointData = scope:mixin .[pCheckpointDataCount]; + this.GetCheckpointData2NV(out pCheckpointDataCount, pCheckpointData.Ptr); + } + public mixin GetCheckpointData2NV_New(out VkCheckpointData2NV[] pCheckpointData) + { + this.GetCheckpointData2NV(var pCheckpointDataCount, null); + pCheckpointData = new .[pCheckpointDataCount]; + this.GetCheckpointData2NV(out pCheckpointDataCount, pCheckpointData.Ptr); + } + public mixin GetCheckpointData2NV_New(out VkCheckpointData2NV[] pCheckpointData, IRawAllocator alloc) + { + this.GetCheckpointData2NV(var pCheckpointDataCount, null); + pCheckpointData = new:alloc .[pCheckpointDataCount]; + this.GetCheckpointData2NV(out pCheckpointDataCount, pCheckpointData.Ptr); + } +} + +extension VkPhysicalDevice +{ + public mixin GetVideoFormatPropertiesKHR_Scope(VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, out VkVideoFormatPropertiesKHR[] pVideoFormatProperties) + { + VkResult result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, var pVideoFormatPropertyCount, null); + if (result == .VkSuccess) + { + pVideoFormatProperties = scope:mixin .[pVideoFormatPropertyCount]; + result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, out pVideoFormatPropertyCount, pVideoFormatProperties.Ptr); + } + else + { + pVideoFormatProperties = null; + } + result + } + public mixin GetVideoFormatPropertiesKHR_New(VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, out VkVideoFormatPropertiesKHR[] pVideoFormatProperties) + { + VkResult result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, var pVideoFormatPropertyCount, null); + if (result == .VkSuccess) + { + pVideoFormatProperties = new .[pVideoFormatPropertyCount]; + result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, out pVideoFormatPropertyCount, pVideoFormatProperties.Ptr); + } + else + { + pVideoFormatProperties = null; + } + result + } + public mixin GetVideoFormatPropertiesKHR_New(VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, out VkVideoFormatPropertiesKHR[] pVideoFormatProperties, IRawAllocator alloc) + { + VkResult result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, var pVideoFormatPropertyCount, null); + if (result == .VkSuccess) + { + pVideoFormatProperties = new:alloc .[pVideoFormatPropertyCount]; + result = this.GetVideoFormatPropertiesKHR(pVideoFormatInfo, out pVideoFormatPropertyCount, pVideoFormatProperties.Ptr); + } + else + { + pVideoFormatProperties = null; + } + result + } +} + +extension VkDevice +{ + public mixin GetEncodedVideoSessionParametersKHR_Scope(VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, out VkVideoEncodeSessionParametersFeedbackInfoKHR pFeedbackInfo, out void[] pData) + { + VkResult result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, var pDataSize, null); + if (result == .VkSuccess) + { + pData = scope:mixin .[pDataSize]; + result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetEncodedVideoSessionParametersKHR_New(VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, out VkVideoEncodeSessionParametersFeedbackInfoKHR pFeedbackInfo, out void[] pData) + { + VkResult result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new .[pDataSize]; + result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetEncodedVideoSessionParametersKHR_New(VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, out VkVideoEncodeSessionParametersFeedbackInfoKHR pFeedbackInfo, out void[] pData, IRawAllocator alloc) + { + VkResult result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new:alloc .[pDataSize]; + result = this.GetEncodedVideoSessionParametersKHR(pVideoSessionParametersInfo, out pFeedbackInfo, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } +} + +extension VkVideoSessionKHR +{ + public mixin GetMemoryRequirementsKHR_Scope(VkDevice device, out VkVideoSessionMemoryRequirementsKHR[] pMemoryRequirements) + { + VkResult result = this.GetMemoryRequirementsKHR(device, var pMemoryRequirementsCount, null); + if (result == .VkSuccess) + { + pMemoryRequirements = scope:mixin .[pMemoryRequirementsCount]; + result = this.GetMemoryRequirementsKHR(device, out pMemoryRequirementsCount, pMemoryRequirements.Ptr); + } + else + { + pMemoryRequirements = null; + } + result + } + public mixin GetMemoryRequirementsKHR_New(VkDevice device, out VkVideoSessionMemoryRequirementsKHR[] pMemoryRequirements) + { + VkResult result = this.GetMemoryRequirementsKHR(device, var pMemoryRequirementsCount, null); + if (result == .VkSuccess) + { + pMemoryRequirements = new .[pMemoryRequirementsCount]; + result = this.GetMemoryRequirementsKHR(device, out pMemoryRequirementsCount, pMemoryRequirements.Ptr); + } + else + { + pMemoryRequirements = null; + } + result + } + public mixin GetMemoryRequirementsKHR_New(VkDevice device, out VkVideoSessionMemoryRequirementsKHR[] pMemoryRequirements, IRawAllocator alloc) + { + VkResult result = this.GetMemoryRequirementsKHR(device, var pMemoryRequirementsCount, null); + if (result == .VkSuccess) + { + pMemoryRequirements = new:alloc .[pMemoryRequirementsCount]; + result = this.GetMemoryRequirementsKHR(device, out pMemoryRequirementsCount, pMemoryRequirements.Ptr); + } + else + { + pMemoryRequirements = null; + } + result + } +} + +extension VkCudaModuleNV +{ + public mixin GetCacheNV_Scope(VkDevice device, out void[] pCacheData) + { + VkResult result = this.GetCacheNV(device, var pCacheSize, null); + if (result == .VkSuccess) + { + pCacheData = scope:mixin .[pCacheSize]; + result = this.GetCacheNV(device, out pCacheSize, pCacheData.Ptr); + } + else + { + pCacheData = null; + } + result + } + public mixin GetCacheNV_New(VkDevice device, out void[] pCacheData) + { + VkResult result = this.GetCacheNV(device, var pCacheSize, null); + if (result == .VkSuccess) + { + pCacheData = new .[pCacheSize]; + result = this.GetCacheNV(device, out pCacheSize, pCacheData.Ptr); + } + else + { + pCacheData = null; + } + result + } + public mixin GetCacheNV_New(VkDevice device, out void[] pCacheData, IRawAllocator alloc) + { + VkResult result = this.GetCacheNV(device, var pCacheSize, null); + if (result == .VkSuccess) + { + pCacheData = new:alloc .[pCacheSize]; + result = this.GetCacheNV(device, out pCacheSize, pCacheData.Ptr); + } + else + { + pCacheData = null; + } + result + } +} + +extension VkFramebuffer +{ + public mixin GetTilePropertiesQCOM_Scope(VkDevice device, out VkTilePropertiesQCOM[] pProperties) + { + VkResult result = this.GetTilePropertiesQCOM(device, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertiesCount]; + result = this.GetTilePropertiesQCOM(device, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetTilePropertiesQCOM_New(VkDevice device, out VkTilePropertiesQCOM[] pProperties) + { + VkResult result = this.GetTilePropertiesQCOM(device, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertiesCount]; + result = this.GetTilePropertiesQCOM(device, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetTilePropertiesQCOM_New(VkDevice device, out VkTilePropertiesQCOM[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetTilePropertiesQCOM(device, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertiesCount]; + result = this.GetTilePropertiesQCOM(device, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetOpticalFlowImageFormatsNV_Scope(VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, out VkOpticalFlowImageFormatPropertiesNV[] pImageFormatProperties) + { + VkResult result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, var pFormatCount, null); + if (result == .VkSuccess) + { + pImageFormatProperties = scope:mixin .[pFormatCount]; + result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, out pFormatCount, pImageFormatProperties.Ptr); + } + else + { + pImageFormatProperties = null; + } + result + } + public mixin GetOpticalFlowImageFormatsNV_New(VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, out VkOpticalFlowImageFormatPropertiesNV[] pImageFormatProperties) + { + VkResult result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, var pFormatCount, null); + if (result == .VkSuccess) + { + pImageFormatProperties = new .[pFormatCount]; + result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, out pFormatCount, pImageFormatProperties.Ptr); + } + else + { + pImageFormatProperties = null; + } + result + } + public mixin GetOpticalFlowImageFormatsNV_New(VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, out VkOpticalFlowImageFormatPropertiesNV[] pImageFormatProperties, IRawAllocator alloc) + { + VkResult result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, var pFormatCount, null); + if (result == .VkSuccess) + { + pImageFormatProperties = new:alloc .[pFormatCount]; + result = this.GetOpticalFlowImageFormatsNV(pOpticalFlowImageFormatInfo, out pFormatCount, pImageFormatProperties.Ptr); + } + else + { + pImageFormatProperties = null; + } + result + } +} + +extension VkShaderEXT +{ + public mixin GetBinaryDataEXT_Scope(VkDevice device, out void[] pData) + { + VkResult result = this.GetBinaryDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = scope:mixin .[pDataSize]; + result = this.GetBinaryDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetBinaryDataEXT_New(VkDevice device, out void[] pData) + { + VkResult result = this.GetBinaryDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new .[pDataSize]; + result = this.GetBinaryDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } + public mixin GetBinaryDataEXT_New(VkDevice device, out void[] pData, IRawAllocator alloc) + { + VkResult result = this.GetBinaryDataEXT(device, var pDataSize, null); + if (result == .VkSuccess) + { + pData = new:alloc .[pDataSize]; + result = this.GetBinaryDataEXT(device, out pDataSize, pData.Ptr); + } + else + { + pData = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetCooperativeMatrixPropertiesKHR_Scope(out VkCooperativeMatrixPropertiesKHR[] pProperties) + { + VkResult result = this.GetCooperativeMatrixPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixPropertiesKHR_New(out VkCooperativeMatrixPropertiesKHR[] pProperties) + { + VkResult result = this.GetCooperativeMatrixPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixPropertiesKHR_New(out VkCooperativeMatrixPropertiesKHR[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetCooperativeMatrixPropertiesKHR(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetCooperativeMatrixPropertiesKHR(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetCooperativeMatrixFlexibleDimensionsPropertiesNV_Scope(out VkCooperativeMatrixFlexibleDimensionsPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixFlexibleDimensionsPropertiesNV_New(out VkCooperativeMatrixFlexibleDimensionsPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeMatrixFlexibleDimensionsPropertiesNV_New(out VkCooperativeMatrixFlexibleDimensionsPropertiesNV[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetCooperativeMatrixFlexibleDimensionsPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + + public mixin GetCooperativeVectorPropertiesNV_Scope(out VkCooperativeVectorPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeVectorPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertyCount]; + result = this.GetCooperativeVectorPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeVectorPropertiesNV_New(out VkCooperativeVectorPropertiesNV[] pProperties) + { + VkResult result = this.GetCooperativeVectorPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertyCount]; + result = this.GetCooperativeVectorPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetCooperativeVectorPropertiesNV_New(out VkCooperativeVectorPropertiesNV[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetCooperativeVectorPropertiesNV(var pPropertyCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertyCount]; + result = this.GetCooperativeVectorPropertiesNV(out pPropertyCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkDevice +{ + public mixin GetDataGraphPipelineSessionBindPointRequirementsARM_Scope(VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, out VkDataGraphPipelineSessionBindPointRequirementARM[] pBindPointRequirements) + { + VkResult result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, var pBindPointRequirementCount, null); + if (result == .VkSuccess) + { + pBindPointRequirements = scope:mixin .[pBindPointRequirementCount]; + result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, out pBindPointRequirementCount, pBindPointRequirements.Ptr); + } + else + { + pBindPointRequirements = null; + } + result + } + public mixin GetDataGraphPipelineSessionBindPointRequirementsARM_New(VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, out VkDataGraphPipelineSessionBindPointRequirementARM[] pBindPointRequirements) + { + VkResult result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, var pBindPointRequirementCount, null); + if (result == .VkSuccess) + { + pBindPointRequirements = new .[pBindPointRequirementCount]; + result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, out pBindPointRequirementCount, pBindPointRequirements.Ptr); + } + else + { + pBindPointRequirements = null; + } + result + } + public mixin GetDataGraphPipelineSessionBindPointRequirementsARM_New(VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, out VkDataGraphPipelineSessionBindPointRequirementARM[] pBindPointRequirements, IRawAllocator alloc) + { + VkResult result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, var pBindPointRequirementCount, null); + if (result == .VkSuccess) + { + pBindPointRequirements = new:alloc .[pBindPointRequirementCount]; + result = this.GetDataGraphPipelineSessionBindPointRequirementsARM(pInfo, out pBindPointRequirementCount, pBindPointRequirements.Ptr); + } + else + { + pBindPointRequirements = null; + } + result + } + + public mixin GetDataGraphPipelineAvailablePropertiesARM_Scope(VkDataGraphPipelineInfoARM* pPipelineInfo, out VkDataGraphPipelinePropertyARM[] pProperties) + { + VkResult result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = scope:mixin .[pPropertiesCount]; + result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDataGraphPipelineAvailablePropertiesARM_New(VkDataGraphPipelineInfoARM* pPipelineInfo, out VkDataGraphPipelinePropertyARM[] pProperties) + { + VkResult result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = new .[pPropertiesCount]; + result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } + public mixin GetDataGraphPipelineAvailablePropertiesARM_New(VkDataGraphPipelineInfoARM* pPipelineInfo, out VkDataGraphPipelinePropertyARM[] pProperties, IRawAllocator alloc) + { + VkResult result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, var pPropertiesCount, null); + if (result == .VkSuccess) + { + pProperties = new:alloc .[pPropertiesCount]; + result = this.GetDataGraphPipelineAvailablePropertiesARM(pPipelineInfo, out pPropertiesCount, pProperties.Ptr); + } + else + { + pProperties = null; + } + result + } +} + +extension VkPhysicalDevice +{ + public mixin GetQueueFamilyDataGraphPropertiesARM_Scope(uint32 queueFamilyIndex, out VkQueueFamilyDataGraphPropertiesARM[] pQueueFamilyDataGraphProperties) + { + VkResult result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, var pQueueFamilyDataGraphPropertyCount, null); + if (result == .VkSuccess) + { + pQueueFamilyDataGraphProperties = scope:mixin .[pQueueFamilyDataGraphPropertyCount]; + result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, out pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties.Ptr); + } + else + { + pQueueFamilyDataGraphProperties = null; + } + result + } + public mixin GetQueueFamilyDataGraphPropertiesARM_New(uint32 queueFamilyIndex, out VkQueueFamilyDataGraphPropertiesARM[] pQueueFamilyDataGraphProperties) + { + VkResult result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, var pQueueFamilyDataGraphPropertyCount, null); + if (result == .VkSuccess) + { + pQueueFamilyDataGraphProperties = new .[pQueueFamilyDataGraphPropertyCount]; + result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, out pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties.Ptr); + } + else + { + pQueueFamilyDataGraphProperties = null; + } + result + } + public mixin GetQueueFamilyDataGraphPropertiesARM_New(uint32 queueFamilyIndex, out VkQueueFamilyDataGraphPropertiesARM[] pQueueFamilyDataGraphProperties, IRawAllocator alloc) + { + VkResult result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, var pQueueFamilyDataGraphPropertyCount, null); + if (result == .VkSuccess) + { + pQueueFamilyDataGraphProperties = new:alloc .[pQueueFamilyDataGraphPropertyCount]; + result = this.GetQueueFamilyDataGraphPropertiesARM(queueFamilyIndex, out pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties.Ptr); + } + else + { + pQueueFamilyDataGraphProperties = null; + } + result + } + + public mixin EnumerateQueueFamilyPerformanceCountersByRegionARM_Scope(uint32 queueFamilyIndex, out VkPerformanceCounterARM[] pCounters, out VkPerformanceCounterDescriptionARM[] pCounterDescriptions) + { + VkResult result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = scope:mixin .[pCounterCount]; + pCounterDescriptions = scope:mixin .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } + public mixin EnumerateQueueFamilyPerformanceCountersByRegionARM_New(uint32 queueFamilyIndex, out VkPerformanceCounterARM[] pCounters, out VkPerformanceCounterDescriptionARM[] pCounterDescriptions) + { + VkResult result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = new .[pCounterCount]; + pCounterDescriptions = new .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } + public mixin EnumerateQueueFamilyPerformanceCountersByRegionARM_New(uint32 queueFamilyIndex, out VkPerformanceCounterARM[] pCounters, out VkPerformanceCounterDescriptionARM[] pCounterDescriptions, IRawAllocator alloc) + { + VkResult result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, var pCounterCount, null, null); + if (result == .VkSuccess) + { + pCounters = new:alloc .[pCounterCount]; + pCounterDescriptions = new:alloc .[pCounterCount]; + result = this.EnumerateQueueFamilyPerformanceCountersByRegionARM(queueFamilyIndex, out pCounterCount, pCounters.Ptr, pCounterDescriptions.Ptr); + } + else + { + pCounters = null; + pCounterDescriptions = null; + } + result + } +} diff --git a/src/Metadata.bf b/src/Metadata.bf new file mode 100644 index 0000000..9a10436 --- /dev/null +++ b/src/Metadata.bf @@ -0,0 +1,3927 @@ +// This file was generated by Setup/Program.bf + +using System; +using System.Interop; + +using Vulkan; + +namespace Vulkan.Metadata; + +enum VulkanApiVersion +{ + case VK_VERSION_1_0 = VK_API_VERSION_1_0; + case VK_VERSION_1_1 = VK_API_VERSION_1_1; + case VK_VERSION_1_2 = VK_API_VERSION_1_2; + case VK_VERSION_1_3 = VK_API_VERSION_1_3; + case VK_VERSION_1_4 = VK_API_VERSION_1_4; +} + +enum VulkanExtension +{ + case VK_KHR_surface = 1; + case VK_KHR_swapchain = 2; + case VK_KHR_display = 3; + case VK_KHR_display_swapchain = 4; + case VK_KHR_xlib_surface = 5; + case VK_KHR_xcb_surface = 6; + case VK_KHR_wayland_surface = 7; + case VK_KHR_android_surface = 9; + case VK_KHR_win32_surface = 10; + case VK_EXT_debug_report = 12; + case VK_NV_glsl_shader = 13; + case VK_EXT_depth_range_unrestricted = 14; + case VK_KHR_sampler_mirror_clamp_to_edge = 15; + case VK_IMG_filter_cubic = 16; + case VK_AMD_rasterization_order = 19; + case VK_AMD_shader_trinary_minmax = 21; + case VK_AMD_shader_explicit_vertex_parameter = 22; + case VK_EXT_debug_marker = 23; + case VK_KHR_video_queue = 24; + case VK_KHR_video_decode_queue = 25; + case VK_AMD_gcn_shader = 26; + case VK_NV_dedicated_allocation = 27; + case VK_EXT_transform_feedback = 29; + case VK_NVX_binary_import = 30; + case VK_NVX_image_view_handle = 31; + case VK_AMD_draw_indirect_count = 34; + case VK_AMD_negative_viewport_height = 36; + case VK_AMD_gpu_shader_half_float = 37; + case VK_AMD_shader_ballot = 38; + case VK_KHR_video_encode_h264 = 39; + case VK_KHR_video_encode_h265 = 40; + case VK_KHR_video_decode_h264 = 41; + case VK_AMD_texture_gather_bias_lod = 42; + case VK_AMD_shader_info = 43; + case VK_KHR_dynamic_rendering = 45; + case VK_AMD_shader_image_load_store_lod = 47; + case VK_GGP_stream_descriptor_surface = 50; + case VK_NV_corner_sampled_image = 51; + case VK_KHR_multiview = 54; + case VK_IMG_format_pvrtc = 55; + case VK_NV_external_memory_capabilities = 56; + case VK_NV_external_memory = 57; + case VK_NV_external_memory_win32 = 58; + case VK_NV_win32_keyed_mutex = 59; + case VK_KHR_get_physical_device_properties2 = 60; + case VK_KHR_device_group = 61; + case VK_EXT_validation_flags = 62; + case VK_NN_vi_surface = 63; + case VK_KHR_shader_draw_parameters = 64; + case VK_EXT_shader_subgroup_ballot = 65; + case VK_EXT_shader_subgroup_vote = 66; + case VK_EXT_texture_compression_astc_hdr = 67; + case VK_EXT_astc_decode_mode = 68; + case VK_EXT_pipeline_robustness = 69; + case VK_KHR_maintenance1 = 70; + case VK_KHR_device_group_creation = 71; + case VK_KHR_external_memory_capabilities = 72; + case VK_KHR_external_memory = 73; + case VK_KHR_external_memory_win32 = 74; + case VK_KHR_external_memory_fd = 75; + case VK_KHR_win32_keyed_mutex = 76; + case VK_KHR_external_semaphore_capabilities = 77; + case VK_KHR_external_semaphore = 78; + case VK_KHR_external_semaphore_win32 = 79; + case VK_KHR_external_semaphore_fd = 80; + case VK_KHR_push_descriptor = 81; + case VK_EXT_conditional_rendering = 82; + case VK_KHR_shader_float16_int8 = 83; + case VK_KHR_16bit_storage = 84; + case VK_KHR_incremental_present = 85; + case VK_KHR_descriptor_update_template = 86; + case VK_NV_clip_space_w_scaling = 88; + case VK_EXT_direct_mode_display = 89; + case VK_EXT_acquire_xlib_display = 90; + case VK_EXT_display_surface_counter = 91; + case VK_EXT_display_control = 92; + case VK_GOOGLE_display_timing = 93; + case VK_NV_sample_mask_override_coverage = 95; + case VK_NV_geometry_shader_passthrough = 96; + case VK_NV_viewport_array2 = 97; + case VK_NVX_multiview_per_view_attributes = 98; + case VK_NV_viewport_swizzle = 99; + case VK_EXT_discard_rectangles = 100; + case VK_EXT_conservative_rasterization = 102; + case VK_EXT_depth_clip_enable = 103; + case VK_EXT_swapchain_colorspace = 105; + case VK_EXT_hdr_metadata = 106; + case VK_KHR_imageless_framebuffer = 109; + case VK_KHR_create_renderpass2 = 110; + case VK_IMG_relaxed_line_rasterization = 111; + case VK_KHR_shared_presentable_image = 112; + case VK_KHR_external_fence_capabilities = 113; + case VK_KHR_external_fence = 114; + case VK_KHR_external_fence_win32 = 115; + case VK_KHR_external_fence_fd = 116; + case VK_KHR_performance_query = 117; + case VK_KHR_maintenance2 = 118; + case VK_KHR_get_surface_capabilities2 = 120; + case VK_KHR_variable_pointers = 121; + case VK_KHR_get_display_properties2 = 122; + case VK_MVK_ios_surface = 123; + case VK_MVK_macos_surface = 124; + case VK_EXT_external_memory_dma_buf = 126; + case VK_EXT_queue_family_foreign = 127; + case VK_KHR_dedicated_allocation = 128; + case VK_EXT_debug_utils = 129; + case VK_ANDROID_external_memory_android_hardware_buffer = 130; + case VK_EXT_sampler_filter_minmax = 131; + case VK_KHR_storage_buffer_storage_class = 132; + case VK_AMD_gpu_shader_int16 = 133; + case VK_AMDX_shader_enqueue = 135; + case VK_AMD_mixed_attachment_samples = 137; + case VK_AMD_shader_fragment_mask = 138; + case VK_EXT_inline_uniform_block = 139; + case VK_EXT_shader_stencil_export = 141; + case VK_KHR_shader_bfloat16 = 142; + case VK_EXT_sample_locations = 144; + case VK_KHR_relaxed_block_layout = 145; + case VK_KHR_get_memory_requirements2 = 147; + case VK_KHR_image_format_list = 148; + case VK_EXT_blend_operation_advanced = 149; + case VK_NV_fragment_coverage_to_color = 150; + case VK_KHR_acceleration_structure = 151; + case VK_KHR_ray_tracing_pipeline = 348; + case VK_KHR_ray_query = 349; + case VK_NV_framebuffer_mixed_samples = 153; + case VK_NV_fill_rectangle = 154; + case VK_NV_shader_sm_builtins = 155; + case VK_EXT_post_depth_coverage = 156; + case VK_KHR_sampler_ycbcr_conversion = 157; + case VK_KHR_bind_memory2 = 158; + case VK_EXT_image_drm_format_modifier = 159; + case VK_EXT_validation_cache = 161; + case VK_EXT_descriptor_indexing = 162; + case VK_EXT_shader_viewport_index_layer = 163; + case VK_KHR_portability_subset = 164; + case VK_NV_shading_rate_image = 165; + case VK_NV_ray_tracing = 166; + case VK_NV_representative_fragment_test = 167; + case VK_KHR_maintenance3 = 169; + case VK_KHR_draw_indirect_count = 170; + case VK_EXT_filter_cubic = 171; + case VK_QCOM_render_pass_shader_resolve = 172; + case VK_EXT_global_priority = 175; + case VK_KHR_shader_subgroup_extended_types = 176; + case VK_KHR_8bit_storage = 178; + case VK_EXT_external_memory_host = 179; + case VK_AMD_buffer_marker = 180; + case VK_KHR_shader_atomic_int64 = 181; + case VK_KHR_shader_clock = 182; + case VK_AMD_pipeline_compiler_control = 184; + case VK_EXT_calibrated_timestamps = 185; + case VK_AMD_shader_core_properties = 186; + case VK_KHR_video_decode_h265 = 188; + case VK_KHR_global_priority = 189; + case VK_AMD_memory_overallocation_behavior = 190; + case VK_EXT_vertex_attribute_divisor = 191; + case VK_GGP_frame_token = 192; + case VK_EXT_pipeline_creation_feedback = 193; + case VK_KHR_driver_properties = 197; + case VK_KHR_shader_float_controls = 198; + case VK_NV_shader_subgroup_partitioned = 199; + case VK_KHR_depth_stencil_resolve = 200; + case VK_KHR_swapchain_mutable_format = 201; + case VK_NV_compute_shader_derivatives = 202; + case VK_NV_mesh_shader = 203; + case VK_NV_fragment_shader_barycentric = 204; + case VK_NV_shader_image_footprint = 205; + case VK_NV_scissor_exclusive = 206; + case VK_NV_device_diagnostic_checkpoints = 207; + case VK_KHR_timeline_semaphore = 208; + case VK_EXT_present_timing = 209; + case VK_INTEL_shader_integer_functions2 = 210; + case VK_INTEL_performance_query = 211; + case VK_KHR_vulkan_memory_model = 212; + case VK_EXT_pci_bus_info = 213; + case VK_AMD_display_native_hdr = 214; + case VK_FUCHSIA_imagepipe_surface = 215; + case VK_KHR_shader_terminate_invocation = 216; + case VK_EXT_metal_surface = 218; + case VK_EXT_fragment_density_map = 219; + case VK_EXT_scalar_block_layout = 222; + case VK_GOOGLE_hlsl_functionality1 = 224; + case VK_GOOGLE_decorate_string = 225; + case VK_EXT_subgroup_size_control = 226; + case VK_KHR_fragment_shading_rate = 227; + case VK_AMD_shader_core_properties2 = 228; + case VK_AMD_device_coherent_memory = 230; + case VK_KHR_dynamic_rendering_local_read = 233; + case VK_EXT_shader_image_atomic_int64 = 235; + case VK_KHR_shader_quad_control = 236; + case VK_KHR_spirv_1_4 = 237; + case VK_EXT_memory_budget = 238; + case VK_EXT_memory_priority = 239; + case VK_KHR_surface_protected_capabilities = 240; + case VK_NV_dedicated_allocation_image_aliasing = 241; + case VK_KHR_separate_depth_stencil_layouts = 242; + case VK_EXT_buffer_device_address = 245; + case VK_EXT_tooling_info = 246; + case VK_EXT_separate_stencil_usage = 247; + case VK_EXT_validation_features = 248; + case VK_KHR_present_wait = 249; + case VK_NV_cooperative_matrix = 250; + case VK_NV_coverage_reduction_mode = 251; + case VK_EXT_fragment_shader_interlock = 252; + case VK_EXT_ycbcr_image_arrays = 253; + case VK_KHR_uniform_buffer_standard_layout = 254; + case VK_EXT_provoking_vertex = 255; + case VK_EXT_full_screen_exclusive = 256; + case VK_EXT_headless_surface = 257; + case VK_KHR_buffer_device_address = 258; + case VK_EXT_line_rasterization = 260; + case VK_EXT_shader_atomic_float = 261; + case VK_EXT_host_query_reset = 262; + case VK_EXT_index_type_uint8 = 266; + case VK_EXT_extended_dynamic_state = 268; + case VK_KHR_deferred_host_operations = 269; + case VK_KHR_pipeline_executable_properties = 270; + case VK_EXT_host_image_copy = 271; + case VK_KHR_map_memory2 = 272; + case VK_EXT_map_memory_placed = 273; + case VK_EXT_shader_atomic_float2 = 274; + case VK_EXT_surface_maintenance1 = 275; + case VK_EXT_swapchain_maintenance1 = 276; + case VK_EXT_shader_demote_to_helper_invocation = 277; + case VK_NV_device_generated_commands = 278; + case VK_NV_inherited_viewport_scissor = 279; + case VK_KHR_shader_integer_dot_product = 281; + case VK_EXT_texel_buffer_alignment = 282; + case VK_QCOM_render_pass_transform = 283; + case VK_EXT_depth_bias_control = 284; + case VK_EXT_device_memory_report = 285; + case VK_EXT_acquire_drm_display = 286; + case VK_EXT_robustness2 = 287; + case VK_EXT_custom_border_color = 288; + case VK_GOOGLE_user_type = 290; + case VK_KHR_pipeline_library = 291; + case VK_NV_present_barrier = 293; + case VK_KHR_shader_non_semantic_info = 294; + case VK_KHR_present_id = 295; + case VK_EXT_private_data = 296; + case VK_EXT_pipeline_creation_cache_control = 298; + case VK_KHR_video_encode_queue = 300; + case VK_NV_device_diagnostics_config = 301; + case VK_QCOM_render_pass_store_ops = 302; + case VK_NV_cuda_kernel_launch = 308; + case VK_QCOM_tile_shading = 310; + case VK_NV_low_latency = 311; + case VK_EXT_metal_objects = 312; + case VK_KHR_synchronization2 = 315; + case VK_EXT_descriptor_buffer = 317; + case VK_EXT_graphics_pipeline_library = 321; + case VK_AMD_shader_early_and_late_fragment_tests = 322; + case VK_KHR_fragment_shader_barycentric = 323; + case VK_KHR_shader_subgroup_uniform_control_flow = 324; + case VK_KHR_zero_initialize_workgroup_memory = 326; + case VK_NV_fragment_shading_rate_enums = 327; + case VK_NV_ray_tracing_motion_blur = 328; + case VK_EXT_mesh_shader = 329; + case VK_EXT_ycbcr_2plane_444_formats = 331; + case VK_EXT_fragment_density_map2 = 333; + case VK_QCOM_rotated_copy_commands = 334; + case VK_EXT_image_robustness = 336; + case VK_KHR_workgroup_memory_explicit_layout = 337; + case VK_KHR_copy_commands2 = 338; + case VK_EXT_image_compression_control = 339; + case VK_EXT_attachment_feedback_loop_layout = 340; + case VK_EXT_4444_formats = 341; + case VK_EXT_device_fault = 342; + case VK_ARM_rasterization_order_attachment_access = 343; + case VK_EXT_rgba10x6_formats = 345; + case VK_NV_acquire_winrt_display = 346; + case VK_EXT_directfb_surface = 347; + case VK_VALVE_mutable_descriptor_type = 352; + case VK_EXT_vertex_input_dynamic_state = 353; + case VK_EXT_physical_device_drm = 354; + case VK_EXT_device_address_binding_report = 355; + case VK_EXT_depth_clip_control = 356; + case VK_EXT_primitive_topology_list_restart = 357; + case VK_KHR_format_feature_flags2 = 361; + case VK_EXT_present_mode_fifo_latest_ready = 362; + case VK_FUCHSIA_external_memory = 365; + case VK_FUCHSIA_external_semaphore = 366; + case VK_FUCHSIA_buffer_collection = 367; + case VK_HUAWEI_subpass_shading = 370; + case VK_HUAWEI_invocation_mask = 371; + case VK_NV_external_memory_rdma = 372; + case VK_EXT_pipeline_properties = 373; + case VK_EXT_frame_boundary = 376; + case VK_EXT_multisampled_render_to_single_sampled = 377; + case VK_EXT_extended_dynamic_state2 = 378; + case VK_QNX_screen_surface = 379; + case VK_EXT_color_write_enable = 382; + case VK_EXT_primitives_generated_query = 383; + case VK_KHR_ray_tracing_maintenance1 = 387; + case VK_KHR_shader_untyped_pointers = 388; + case VK_EXT_global_priority_query = 389; + case VK_VALVE_video_encode_rgb_conversion = 391; + case VK_EXT_image_view_min_lod = 392; + case VK_EXT_multi_draw = 393; + case VK_EXT_image_2d_view_of_3d = 394; + case VK_KHR_portability_enumeration = 395; + case VK_EXT_shader_tile_image = 396; + case VK_EXT_opacity_micromap = 397; + case VK_NV_displacement_micromap = 398; + case VK_EXT_load_store_op_none = 401; + case VK_HUAWEI_cluster_culling_shader = 405; + case VK_EXT_border_color_swizzle = 412; + case VK_EXT_pageable_device_local_memory = 413; + case VK_KHR_maintenance4 = 414; + case VK_ARM_shader_core_properties = 416; + case VK_KHR_shader_subgroup_rotate = 417; + case VK_ARM_scheduling_controls = 418; + case VK_EXT_image_sliced_view_of_3d = 419; + case VK_VALVE_descriptor_set_host_mapping = 421; + case VK_EXT_depth_clamp_zero_one = 422; + case VK_EXT_non_seamless_cube_map = 423; + case VK_ARM_render_pass_striped = 425; + case VK_QCOM_fragment_density_map_offset = 426; + case VK_NV_copy_memory_indirect = 427; + case VK_NV_memory_decompression = 428; + case VK_NV_device_generated_commands_compute = 429; + case VK_NV_ray_tracing_linear_swept_spheres = 430; + case VK_NV_linear_color_attachment = 431; + case VK_GOOGLE_surfaceless_query = 434; + case VK_KHR_shader_maximal_reconvergence = 435; + case VK_EXT_image_compression_control_swapchain = 438; + case VK_QCOM_image_processing = 441; + case VK_EXT_nested_command_buffer = 452; + case VK_OHOS_external_memory = 453; + case VK_EXT_external_memory_acquire_unmodified = 454; + case VK_EXT_extended_dynamic_state3 = 456; + case VK_EXT_subpass_merge_feedback = 459; + case VK_LUNARG_direct_driver_loading = 460; + case VK_ARM_tensors = 461; + case VK_EXT_shader_module_identifier = 463; + case VK_EXT_rasterization_order_attachment_access = 464; + case VK_NV_optical_flow = 465; + case VK_EXT_legacy_dithering = 466; + case VK_EXT_pipeline_protected_access = 467; + case VK_ANDROID_external_format_resolve = 469; + case VK_KHR_maintenance5 = 471; + case VK_AMD_anti_lag = 477; + case VK_AMDX_dense_geometry_format = 479; + case VK_KHR_present_id2 = 480; + case VK_KHR_present_wait2 = 481; + case VK_KHR_ray_tracing_position_fetch = 482; + case VK_EXT_shader_object = 483; + case VK_KHR_pipeline_binary = 484; + case VK_QCOM_tile_properties = 485; + case VK_SEC_amigo_profiling = 486; + case VK_KHR_surface_maintenance1 = 487; + case VK_KHR_swapchain_maintenance1 = 488; + case VK_QCOM_multiview_per_view_viewports = 489; + case VK_NV_ray_tracing_invocation_reorder = 491; + case VK_NV_cooperative_vector = 492; + case VK_NV_extended_sparse_address_space = 493; + case VK_EXT_mutable_descriptor_type = 495; + case VK_EXT_legacy_vertex_attributes = 496; + case VK_EXT_layer_settings = 497; + case VK_ARM_shader_core_builtins = 498; + case VK_EXT_pipeline_library_group_handles = 499; + case VK_EXT_dynamic_rendering_unused_attachments = 500; + case VK_NV_low_latency2 = 506; + case VK_KHR_cooperative_matrix = 507; + case VK_ARM_data_graph = 508; + case VK_QCOM_multiview_per_view_render_areas = 511; + case VK_KHR_compute_shader_derivatives = 512; + case VK_KHR_video_decode_av1 = 513; + case VK_KHR_video_encode_av1 = 514; + case VK_KHR_video_decode_vp9 = 515; + case VK_KHR_video_maintenance1 = 516; + case VK_NV_per_stage_descriptor_set = 517; + case VK_QCOM_image_processing2 = 519; + case VK_QCOM_filter_cubic_weights = 520; + case VK_QCOM_ycbcr_degamma = 521; + case VK_QCOM_filter_cubic_clamp = 522; + case VK_EXT_attachment_feedback_loop_dynamic_state = 525; + case VK_KHR_vertex_attribute_divisor = 526; + case VK_KHR_load_store_op_none = 527; + case VK_KHR_unified_image_layouts = 528; + case VK_KHR_shader_float_controls2 = 529; + case VK_QNX_external_memory_screen_buffer = 530; + case VK_MSFT_layered_driver = 531; + case VK_KHR_index_type_uint8 = 534; + case VK_KHR_line_rasterization = 535; + case VK_KHR_calibrated_timestamps = 544; + case VK_KHR_shader_expect_assume = 545; + case VK_KHR_maintenance6 = 546; + case VK_NV_descriptor_pool_overallocation = 547; + case VK_QCOM_tile_memory_heap = 548; + case VK_KHR_copy_memory_indirect = 550; + case VK_EXT_memory_decompression = 551; + case VK_NV_display_stereo = 552; + case VK_KHR_video_encode_intra_refresh = 553; + case VK_KHR_video_encode_quantization_map = 554; + case VK_NV_raw_access_chains = 556; + case VK_NV_external_compute_queue = 557; + case VK_KHR_shader_relaxed_extended_instruction = 559; + case VK_NV_command_buffer_inheritance = 560; + case VK_KHR_maintenance7 = 563; + case VK_NV_shader_atomic_float16_vector = 564; + case VK_EXT_shader_replicated_composites = 565; + case VK_EXT_shader_float8 = 568; + case VK_NV_ray_tracing_validation = 569; + case VK_NV_cluster_acceleration_structure = 570; + case VK_NV_partitioned_acceleration_structure = 571; + case VK_EXT_device_generated_commands = 573; + case VK_KHR_maintenance8 = 575; + case VK_MESA_image_alignment_control = 576; + case VK_KHR_shader_fma = 580; + case VK_EXT_ray_tracing_invocation_reorder = 582; + case VK_EXT_depth_clamp_control = 583; + case VK_KHR_maintenance9 = 585; + case VK_KHR_video_maintenance2 = 587; + case VK_OHOS_surface = 588; + case VK_OHOS_native_buffer = 589; + case VK_HUAWEI_hdr_vivid = 591; + case VK_NV_cooperative_matrix2 = 594; + case VK_ARM_pipeline_opacity_micromap = 597; + case VK_EXT_external_memory_metal = 603; + case VK_KHR_depth_clamp_zero_one = 605; + case VK_ARM_performance_counters_by_region = 606; + case VK_EXT_vertex_attribute_robustness = 609; + case VK_ARM_format_pack = 610; + case VK_VALVE_fragment_density_map_layered = 612; + case VK_KHR_robustness2 = 613; + case VK_NV_present_metering = 614; + case VK_EXT_fragment_density_map_offset = 620; + case VK_EXT_zero_initialize_device_memory = 621; + case VK_KHR_present_mode_fifo_latest_ready = 622; + case VK_EXT_shader_64bit_indexing = 628; + case VK_EXT_custom_resolve = 629; + case VK_QCOM_data_graph_model = 630; + case VK_KHR_maintenance10 = 631; + case VK_SEC_pipeline_cache_incremental_mode = 638; + case VK_EXT_shader_uniform_buffer_unsized_array = 643; + + public String Name + { + get + { + switch (this) + { + case VK_KHR_surface: return nameof(VK_KHR_surface); + case VK_KHR_swapchain: return nameof(VK_KHR_swapchain); + case VK_KHR_display: return nameof(VK_KHR_display); + case VK_KHR_display_swapchain: return nameof(VK_KHR_display_swapchain); + case VK_KHR_xlib_surface: return nameof(VK_KHR_xlib_surface); + case VK_KHR_xcb_surface: return nameof(VK_KHR_xcb_surface); + case VK_KHR_wayland_surface: return nameof(VK_KHR_wayland_surface); + case VK_KHR_android_surface: return nameof(VK_KHR_android_surface); + case VK_KHR_win32_surface: return nameof(VK_KHR_win32_surface); + case VK_EXT_debug_report: return nameof(VK_EXT_debug_report); + case VK_NV_glsl_shader: return nameof(VK_NV_glsl_shader); + case VK_EXT_depth_range_unrestricted: return nameof(VK_EXT_depth_range_unrestricted); + case VK_KHR_sampler_mirror_clamp_to_edge: return nameof(VK_KHR_sampler_mirror_clamp_to_edge); + case VK_IMG_filter_cubic: return nameof(VK_IMG_filter_cubic); + case VK_AMD_rasterization_order: return nameof(VK_AMD_rasterization_order); + case VK_AMD_shader_trinary_minmax: return nameof(VK_AMD_shader_trinary_minmax); + case VK_AMD_shader_explicit_vertex_parameter: return nameof(VK_AMD_shader_explicit_vertex_parameter); + case VK_EXT_debug_marker: return nameof(VK_EXT_debug_marker); + case VK_KHR_video_queue: return nameof(VK_KHR_video_queue); + case VK_KHR_video_decode_queue: return nameof(VK_KHR_video_decode_queue); + case VK_AMD_gcn_shader: return nameof(VK_AMD_gcn_shader); + case VK_NV_dedicated_allocation: return nameof(VK_NV_dedicated_allocation); + case VK_EXT_transform_feedback: return nameof(VK_EXT_transform_feedback); + case VK_NVX_binary_import: return nameof(VK_NVX_binary_import); + case VK_NVX_image_view_handle: return nameof(VK_NVX_image_view_handle); + case VK_AMD_draw_indirect_count: return nameof(VK_AMD_draw_indirect_count); + case VK_AMD_negative_viewport_height: return nameof(VK_AMD_negative_viewport_height); + case VK_AMD_gpu_shader_half_float: return nameof(VK_AMD_gpu_shader_half_float); + case VK_AMD_shader_ballot: return nameof(VK_AMD_shader_ballot); + case VK_KHR_video_encode_h264: return nameof(VK_KHR_video_encode_h264); + case VK_KHR_video_encode_h265: return nameof(VK_KHR_video_encode_h265); + case VK_KHR_video_decode_h264: return nameof(VK_KHR_video_decode_h264); + case VK_AMD_texture_gather_bias_lod: return nameof(VK_AMD_texture_gather_bias_lod); + case VK_AMD_shader_info: return nameof(VK_AMD_shader_info); + case VK_KHR_dynamic_rendering: return nameof(VK_KHR_dynamic_rendering); + case VK_AMD_shader_image_load_store_lod: return nameof(VK_AMD_shader_image_load_store_lod); + case VK_GGP_stream_descriptor_surface: return nameof(VK_GGP_stream_descriptor_surface); + case VK_NV_corner_sampled_image: return nameof(VK_NV_corner_sampled_image); + case VK_KHR_multiview: return nameof(VK_KHR_multiview); + case VK_IMG_format_pvrtc: return nameof(VK_IMG_format_pvrtc); + case VK_NV_external_memory_capabilities: return nameof(VK_NV_external_memory_capabilities); + case VK_NV_external_memory: return nameof(VK_NV_external_memory); + case VK_NV_external_memory_win32: return nameof(VK_NV_external_memory_win32); + case VK_NV_win32_keyed_mutex: return nameof(VK_NV_win32_keyed_mutex); + case VK_KHR_get_physical_device_properties2: return nameof(VK_KHR_get_physical_device_properties2); + case VK_KHR_device_group: return nameof(VK_KHR_device_group); + case VK_EXT_validation_flags: return nameof(VK_EXT_validation_flags); + case VK_NN_vi_surface: return nameof(VK_NN_vi_surface); + case VK_KHR_shader_draw_parameters: return nameof(VK_KHR_shader_draw_parameters); + case VK_EXT_shader_subgroup_ballot: return nameof(VK_EXT_shader_subgroup_ballot); + case VK_EXT_shader_subgroup_vote: return nameof(VK_EXT_shader_subgroup_vote); + case VK_EXT_texture_compression_astc_hdr: return nameof(VK_EXT_texture_compression_astc_hdr); + case VK_EXT_astc_decode_mode: return nameof(VK_EXT_astc_decode_mode); + case VK_EXT_pipeline_robustness: return nameof(VK_EXT_pipeline_robustness); + case VK_KHR_maintenance1: return nameof(VK_KHR_maintenance1); + case VK_KHR_device_group_creation: return nameof(VK_KHR_device_group_creation); + case VK_KHR_external_memory_capabilities: return nameof(VK_KHR_external_memory_capabilities); + case VK_KHR_external_memory: return nameof(VK_KHR_external_memory); + case VK_KHR_external_memory_win32: return nameof(VK_KHR_external_memory_win32); + case VK_KHR_external_memory_fd: return nameof(VK_KHR_external_memory_fd); + case VK_KHR_win32_keyed_mutex: return nameof(VK_KHR_win32_keyed_mutex); + case VK_KHR_external_semaphore_capabilities: return nameof(VK_KHR_external_semaphore_capabilities); + case VK_KHR_external_semaphore: return nameof(VK_KHR_external_semaphore); + case VK_KHR_external_semaphore_win32: return nameof(VK_KHR_external_semaphore_win32); + case VK_KHR_external_semaphore_fd: return nameof(VK_KHR_external_semaphore_fd); + case VK_KHR_push_descriptor: return nameof(VK_KHR_push_descriptor); + case VK_EXT_conditional_rendering: return nameof(VK_EXT_conditional_rendering); + case VK_KHR_shader_float16_int8: return nameof(VK_KHR_shader_float16_int8); + case VK_KHR_16bit_storage: return nameof(VK_KHR_16bit_storage); + case VK_KHR_incremental_present: return nameof(VK_KHR_incremental_present); + case VK_KHR_descriptor_update_template: return nameof(VK_KHR_descriptor_update_template); + case VK_NV_clip_space_w_scaling: return nameof(VK_NV_clip_space_w_scaling); + case VK_EXT_direct_mode_display: return nameof(VK_EXT_direct_mode_display); + case VK_EXT_acquire_xlib_display: return nameof(VK_EXT_acquire_xlib_display); + case VK_EXT_display_surface_counter: return nameof(VK_EXT_display_surface_counter); + case VK_EXT_display_control: return nameof(VK_EXT_display_control); + case VK_GOOGLE_display_timing: return nameof(VK_GOOGLE_display_timing); + case VK_NV_sample_mask_override_coverage: return nameof(VK_NV_sample_mask_override_coverage); + case VK_NV_geometry_shader_passthrough: return nameof(VK_NV_geometry_shader_passthrough); + case VK_NV_viewport_array2: return nameof(VK_NV_viewport_array2); + case VK_NVX_multiview_per_view_attributes: return nameof(VK_NVX_multiview_per_view_attributes); + case VK_NV_viewport_swizzle: return nameof(VK_NV_viewport_swizzle); + case VK_EXT_discard_rectangles: return nameof(VK_EXT_discard_rectangles); + case VK_EXT_conservative_rasterization: return nameof(VK_EXT_conservative_rasterization); + case VK_EXT_depth_clip_enable: return nameof(VK_EXT_depth_clip_enable); + case VK_EXT_swapchain_colorspace: return nameof(VK_EXT_swapchain_colorspace); + case VK_EXT_hdr_metadata: return nameof(VK_EXT_hdr_metadata); + case VK_KHR_imageless_framebuffer: return nameof(VK_KHR_imageless_framebuffer); + case VK_KHR_create_renderpass2: return nameof(VK_KHR_create_renderpass2); + case VK_IMG_relaxed_line_rasterization: return nameof(VK_IMG_relaxed_line_rasterization); + case VK_KHR_shared_presentable_image: return nameof(VK_KHR_shared_presentable_image); + case VK_KHR_external_fence_capabilities: return nameof(VK_KHR_external_fence_capabilities); + case VK_KHR_external_fence: return nameof(VK_KHR_external_fence); + case VK_KHR_external_fence_win32: return nameof(VK_KHR_external_fence_win32); + case VK_KHR_external_fence_fd: return nameof(VK_KHR_external_fence_fd); + case VK_KHR_performance_query: return nameof(VK_KHR_performance_query); + case VK_KHR_maintenance2: return nameof(VK_KHR_maintenance2); + case VK_KHR_get_surface_capabilities2: return nameof(VK_KHR_get_surface_capabilities2); + case VK_KHR_variable_pointers: return nameof(VK_KHR_variable_pointers); + case VK_KHR_get_display_properties2: return nameof(VK_KHR_get_display_properties2); + case VK_MVK_ios_surface: return nameof(VK_MVK_ios_surface); + case VK_MVK_macos_surface: return nameof(VK_MVK_macos_surface); + case VK_EXT_external_memory_dma_buf: return nameof(VK_EXT_external_memory_dma_buf); + case VK_EXT_queue_family_foreign: return nameof(VK_EXT_queue_family_foreign); + case VK_KHR_dedicated_allocation: return nameof(VK_KHR_dedicated_allocation); + case VK_EXT_debug_utils: return nameof(VK_EXT_debug_utils); + case VK_ANDROID_external_memory_android_hardware_buffer: return nameof(VK_ANDROID_external_memory_android_hardware_buffer); + case VK_EXT_sampler_filter_minmax: return nameof(VK_EXT_sampler_filter_minmax); + case VK_KHR_storage_buffer_storage_class: return nameof(VK_KHR_storage_buffer_storage_class); + case VK_AMD_gpu_shader_int16: return nameof(VK_AMD_gpu_shader_int16); + case VK_AMDX_shader_enqueue: return nameof(VK_AMDX_shader_enqueue); + case VK_AMD_mixed_attachment_samples: return nameof(VK_AMD_mixed_attachment_samples); + case VK_AMD_shader_fragment_mask: return nameof(VK_AMD_shader_fragment_mask); + case VK_EXT_inline_uniform_block: return nameof(VK_EXT_inline_uniform_block); + case VK_EXT_shader_stencil_export: return nameof(VK_EXT_shader_stencil_export); + case VK_KHR_shader_bfloat16: return nameof(VK_KHR_shader_bfloat16); + case VK_EXT_sample_locations: return nameof(VK_EXT_sample_locations); + case VK_KHR_relaxed_block_layout: return nameof(VK_KHR_relaxed_block_layout); + case VK_KHR_get_memory_requirements2: return nameof(VK_KHR_get_memory_requirements2); + case VK_KHR_image_format_list: return nameof(VK_KHR_image_format_list); + case VK_EXT_blend_operation_advanced: return nameof(VK_EXT_blend_operation_advanced); + case VK_NV_fragment_coverage_to_color: return nameof(VK_NV_fragment_coverage_to_color); + case VK_KHR_acceleration_structure: return nameof(VK_KHR_acceleration_structure); + case VK_KHR_ray_tracing_pipeline: return nameof(VK_KHR_ray_tracing_pipeline); + case VK_KHR_ray_query: return nameof(VK_KHR_ray_query); + case VK_NV_framebuffer_mixed_samples: return nameof(VK_NV_framebuffer_mixed_samples); + case VK_NV_fill_rectangle: return nameof(VK_NV_fill_rectangle); + case VK_NV_shader_sm_builtins: return nameof(VK_NV_shader_sm_builtins); + case VK_EXT_post_depth_coverage: return nameof(VK_EXT_post_depth_coverage); + case VK_KHR_sampler_ycbcr_conversion: return nameof(VK_KHR_sampler_ycbcr_conversion); + case VK_KHR_bind_memory2: return nameof(VK_KHR_bind_memory2); + case VK_EXT_image_drm_format_modifier: return nameof(VK_EXT_image_drm_format_modifier); + case VK_EXT_validation_cache: return nameof(VK_EXT_validation_cache); + case VK_EXT_descriptor_indexing: return nameof(VK_EXT_descriptor_indexing); + case VK_EXT_shader_viewport_index_layer: return nameof(VK_EXT_shader_viewport_index_layer); + case VK_KHR_portability_subset: return nameof(VK_KHR_portability_subset); + case VK_NV_shading_rate_image: return nameof(VK_NV_shading_rate_image); + case VK_NV_ray_tracing: return nameof(VK_NV_ray_tracing); + case VK_NV_representative_fragment_test: return nameof(VK_NV_representative_fragment_test); + case VK_KHR_maintenance3: return nameof(VK_KHR_maintenance3); + case VK_KHR_draw_indirect_count: return nameof(VK_KHR_draw_indirect_count); + case VK_EXT_filter_cubic: return nameof(VK_EXT_filter_cubic); + case VK_QCOM_render_pass_shader_resolve: return nameof(VK_QCOM_render_pass_shader_resolve); + case VK_EXT_global_priority: return nameof(VK_EXT_global_priority); + case VK_KHR_shader_subgroup_extended_types: return nameof(VK_KHR_shader_subgroup_extended_types); + case VK_KHR_8bit_storage: return nameof(VK_KHR_8bit_storage); + case VK_EXT_external_memory_host: return nameof(VK_EXT_external_memory_host); + case VK_AMD_buffer_marker: return nameof(VK_AMD_buffer_marker); + case VK_KHR_shader_atomic_int64: return nameof(VK_KHR_shader_atomic_int64); + case VK_KHR_shader_clock: return nameof(VK_KHR_shader_clock); + case VK_AMD_pipeline_compiler_control: return nameof(VK_AMD_pipeline_compiler_control); + case VK_EXT_calibrated_timestamps: return nameof(VK_EXT_calibrated_timestamps); + case VK_AMD_shader_core_properties: return nameof(VK_AMD_shader_core_properties); + case VK_KHR_video_decode_h265: return nameof(VK_KHR_video_decode_h265); + case VK_KHR_global_priority: return nameof(VK_KHR_global_priority); + case VK_AMD_memory_overallocation_behavior: return nameof(VK_AMD_memory_overallocation_behavior); + case VK_EXT_vertex_attribute_divisor: return nameof(VK_EXT_vertex_attribute_divisor); + case VK_GGP_frame_token: return nameof(VK_GGP_frame_token); + case VK_EXT_pipeline_creation_feedback: return nameof(VK_EXT_pipeline_creation_feedback); + case VK_KHR_driver_properties: return nameof(VK_KHR_driver_properties); + case VK_KHR_shader_float_controls: return nameof(VK_KHR_shader_float_controls); + case VK_NV_shader_subgroup_partitioned: return nameof(VK_NV_shader_subgroup_partitioned); + case VK_KHR_depth_stencil_resolve: return nameof(VK_KHR_depth_stencil_resolve); + case VK_KHR_swapchain_mutable_format: return nameof(VK_KHR_swapchain_mutable_format); + case VK_NV_compute_shader_derivatives: return nameof(VK_NV_compute_shader_derivatives); + case VK_NV_mesh_shader: return nameof(VK_NV_mesh_shader); + case VK_NV_fragment_shader_barycentric: return nameof(VK_NV_fragment_shader_barycentric); + case VK_NV_shader_image_footprint: return nameof(VK_NV_shader_image_footprint); + case VK_NV_scissor_exclusive: return nameof(VK_NV_scissor_exclusive); + case VK_NV_device_diagnostic_checkpoints: return nameof(VK_NV_device_diagnostic_checkpoints); + case VK_KHR_timeline_semaphore: return nameof(VK_KHR_timeline_semaphore); + case VK_EXT_present_timing: return nameof(VK_EXT_present_timing); + case VK_INTEL_shader_integer_functions2: return nameof(VK_INTEL_shader_integer_functions2); + case VK_INTEL_performance_query: return nameof(VK_INTEL_performance_query); + case VK_KHR_vulkan_memory_model: return nameof(VK_KHR_vulkan_memory_model); + case VK_EXT_pci_bus_info: return nameof(VK_EXT_pci_bus_info); + case VK_AMD_display_native_hdr: return nameof(VK_AMD_display_native_hdr); + case VK_FUCHSIA_imagepipe_surface: return nameof(VK_FUCHSIA_imagepipe_surface); + case VK_KHR_shader_terminate_invocation: return nameof(VK_KHR_shader_terminate_invocation); + case VK_EXT_metal_surface: return nameof(VK_EXT_metal_surface); + case VK_EXT_fragment_density_map: return nameof(VK_EXT_fragment_density_map); + case VK_EXT_scalar_block_layout: return nameof(VK_EXT_scalar_block_layout); + case VK_GOOGLE_hlsl_functionality1: return nameof(VK_GOOGLE_hlsl_functionality1); + case VK_GOOGLE_decorate_string: return nameof(VK_GOOGLE_decorate_string); + case VK_EXT_subgroup_size_control: return nameof(VK_EXT_subgroup_size_control); + case VK_KHR_fragment_shading_rate: return nameof(VK_KHR_fragment_shading_rate); + case VK_AMD_shader_core_properties2: return nameof(VK_AMD_shader_core_properties2); + case VK_AMD_device_coherent_memory: return nameof(VK_AMD_device_coherent_memory); + case VK_KHR_dynamic_rendering_local_read: return nameof(VK_KHR_dynamic_rendering_local_read); + case VK_EXT_shader_image_atomic_int64: return nameof(VK_EXT_shader_image_atomic_int64); + case VK_KHR_shader_quad_control: return nameof(VK_KHR_shader_quad_control); + case VK_KHR_spirv_1_4: return nameof(VK_KHR_spirv_1_4); + case VK_EXT_memory_budget: return nameof(VK_EXT_memory_budget); + case VK_EXT_memory_priority: return nameof(VK_EXT_memory_priority); + case VK_KHR_surface_protected_capabilities: return nameof(VK_KHR_surface_protected_capabilities); + case VK_NV_dedicated_allocation_image_aliasing: return nameof(VK_NV_dedicated_allocation_image_aliasing); + case VK_KHR_separate_depth_stencil_layouts: return nameof(VK_KHR_separate_depth_stencil_layouts); + case VK_EXT_buffer_device_address: return nameof(VK_EXT_buffer_device_address); + case VK_EXT_tooling_info: return nameof(VK_EXT_tooling_info); + case VK_EXT_separate_stencil_usage: return nameof(VK_EXT_separate_stencil_usage); + case VK_EXT_validation_features: return nameof(VK_EXT_validation_features); + case VK_KHR_present_wait: return nameof(VK_KHR_present_wait); + case VK_NV_cooperative_matrix: return nameof(VK_NV_cooperative_matrix); + case VK_NV_coverage_reduction_mode: return nameof(VK_NV_coverage_reduction_mode); + case VK_EXT_fragment_shader_interlock: return nameof(VK_EXT_fragment_shader_interlock); + case VK_EXT_ycbcr_image_arrays: return nameof(VK_EXT_ycbcr_image_arrays); + case VK_KHR_uniform_buffer_standard_layout: return nameof(VK_KHR_uniform_buffer_standard_layout); + case VK_EXT_provoking_vertex: return nameof(VK_EXT_provoking_vertex); + case VK_EXT_full_screen_exclusive: return nameof(VK_EXT_full_screen_exclusive); + case VK_EXT_headless_surface: return nameof(VK_EXT_headless_surface); + case VK_KHR_buffer_device_address: return nameof(VK_KHR_buffer_device_address); + case VK_EXT_line_rasterization: return nameof(VK_EXT_line_rasterization); + case VK_EXT_shader_atomic_float: return nameof(VK_EXT_shader_atomic_float); + case VK_EXT_host_query_reset: return nameof(VK_EXT_host_query_reset); + case VK_EXT_index_type_uint8: return nameof(VK_EXT_index_type_uint8); + case VK_EXT_extended_dynamic_state: return nameof(VK_EXT_extended_dynamic_state); + case VK_KHR_deferred_host_operations: return nameof(VK_KHR_deferred_host_operations); + case VK_KHR_pipeline_executable_properties: return nameof(VK_KHR_pipeline_executable_properties); + case VK_EXT_host_image_copy: return nameof(VK_EXT_host_image_copy); + case VK_KHR_map_memory2: return nameof(VK_KHR_map_memory2); + case VK_EXT_map_memory_placed: return nameof(VK_EXT_map_memory_placed); + case VK_EXT_shader_atomic_float2: return nameof(VK_EXT_shader_atomic_float2); + case VK_EXT_surface_maintenance1: return nameof(VK_EXT_surface_maintenance1); + case VK_EXT_swapchain_maintenance1: return nameof(VK_EXT_swapchain_maintenance1); + case VK_EXT_shader_demote_to_helper_invocation: return nameof(VK_EXT_shader_demote_to_helper_invocation); + case VK_NV_device_generated_commands: return nameof(VK_NV_device_generated_commands); + case VK_NV_inherited_viewport_scissor: return nameof(VK_NV_inherited_viewport_scissor); + case VK_KHR_shader_integer_dot_product: return nameof(VK_KHR_shader_integer_dot_product); + case VK_EXT_texel_buffer_alignment: return nameof(VK_EXT_texel_buffer_alignment); + case VK_QCOM_render_pass_transform: return nameof(VK_QCOM_render_pass_transform); + case VK_EXT_depth_bias_control: return nameof(VK_EXT_depth_bias_control); + case VK_EXT_device_memory_report: return nameof(VK_EXT_device_memory_report); + case VK_EXT_acquire_drm_display: return nameof(VK_EXT_acquire_drm_display); + case VK_EXT_robustness2: return nameof(VK_EXT_robustness2); + case VK_EXT_custom_border_color: return nameof(VK_EXT_custom_border_color); + case VK_GOOGLE_user_type: return nameof(VK_GOOGLE_user_type); + case VK_KHR_pipeline_library: return nameof(VK_KHR_pipeline_library); + case VK_NV_present_barrier: return nameof(VK_NV_present_barrier); + case VK_KHR_shader_non_semantic_info: return nameof(VK_KHR_shader_non_semantic_info); + case VK_KHR_present_id: return nameof(VK_KHR_present_id); + case VK_EXT_private_data: return nameof(VK_EXT_private_data); + case VK_EXT_pipeline_creation_cache_control: return nameof(VK_EXT_pipeline_creation_cache_control); + case VK_KHR_video_encode_queue: return nameof(VK_KHR_video_encode_queue); + case VK_NV_device_diagnostics_config: return nameof(VK_NV_device_diagnostics_config); + case VK_QCOM_render_pass_store_ops: return nameof(VK_QCOM_render_pass_store_ops); + case VK_NV_cuda_kernel_launch: return nameof(VK_NV_cuda_kernel_launch); + case VK_QCOM_tile_shading: return nameof(VK_QCOM_tile_shading); + case VK_NV_low_latency: return nameof(VK_NV_low_latency); + case VK_EXT_metal_objects: return nameof(VK_EXT_metal_objects); + case VK_KHR_synchronization2: return nameof(VK_KHR_synchronization2); + case VK_EXT_descriptor_buffer: return nameof(VK_EXT_descriptor_buffer); + case VK_EXT_graphics_pipeline_library: return nameof(VK_EXT_graphics_pipeline_library); + case VK_AMD_shader_early_and_late_fragment_tests: return nameof(VK_AMD_shader_early_and_late_fragment_tests); + case VK_KHR_fragment_shader_barycentric: return nameof(VK_KHR_fragment_shader_barycentric); + case VK_KHR_shader_subgroup_uniform_control_flow: return nameof(VK_KHR_shader_subgroup_uniform_control_flow); + case VK_KHR_zero_initialize_workgroup_memory: return nameof(VK_KHR_zero_initialize_workgroup_memory); + case VK_NV_fragment_shading_rate_enums: return nameof(VK_NV_fragment_shading_rate_enums); + case VK_NV_ray_tracing_motion_blur: return nameof(VK_NV_ray_tracing_motion_blur); + case VK_EXT_mesh_shader: return nameof(VK_EXT_mesh_shader); + case VK_EXT_ycbcr_2plane_444_formats: return nameof(VK_EXT_ycbcr_2plane_444_formats); + case VK_EXT_fragment_density_map2: return nameof(VK_EXT_fragment_density_map2); + case VK_QCOM_rotated_copy_commands: return nameof(VK_QCOM_rotated_copy_commands); + case VK_EXT_image_robustness: return nameof(VK_EXT_image_robustness); + case VK_KHR_workgroup_memory_explicit_layout: return nameof(VK_KHR_workgroup_memory_explicit_layout); + case VK_KHR_copy_commands2: return nameof(VK_KHR_copy_commands2); + case VK_EXT_image_compression_control: return nameof(VK_EXT_image_compression_control); + case VK_EXT_attachment_feedback_loop_layout: return nameof(VK_EXT_attachment_feedback_loop_layout); + case VK_EXT_4444_formats: return nameof(VK_EXT_4444_formats); + case VK_EXT_device_fault: return nameof(VK_EXT_device_fault); + case VK_ARM_rasterization_order_attachment_access: return nameof(VK_ARM_rasterization_order_attachment_access); + case VK_EXT_rgba10x6_formats: return nameof(VK_EXT_rgba10x6_formats); + case VK_NV_acquire_winrt_display: return nameof(VK_NV_acquire_winrt_display); + case VK_EXT_directfb_surface: return nameof(VK_EXT_directfb_surface); + case VK_VALVE_mutable_descriptor_type: return nameof(VK_VALVE_mutable_descriptor_type); + case VK_EXT_vertex_input_dynamic_state: return nameof(VK_EXT_vertex_input_dynamic_state); + case VK_EXT_physical_device_drm: return nameof(VK_EXT_physical_device_drm); + case VK_EXT_device_address_binding_report: return nameof(VK_EXT_device_address_binding_report); + case VK_EXT_depth_clip_control: return nameof(VK_EXT_depth_clip_control); + case VK_EXT_primitive_topology_list_restart: return nameof(VK_EXT_primitive_topology_list_restart); + case VK_KHR_format_feature_flags2: return nameof(VK_KHR_format_feature_flags2); + case VK_EXT_present_mode_fifo_latest_ready: return nameof(VK_EXT_present_mode_fifo_latest_ready); + case VK_FUCHSIA_external_memory: return nameof(VK_FUCHSIA_external_memory); + case VK_FUCHSIA_external_semaphore: return nameof(VK_FUCHSIA_external_semaphore); + case VK_FUCHSIA_buffer_collection: return nameof(VK_FUCHSIA_buffer_collection); + case VK_HUAWEI_subpass_shading: return nameof(VK_HUAWEI_subpass_shading); + case VK_HUAWEI_invocation_mask: return nameof(VK_HUAWEI_invocation_mask); + case VK_NV_external_memory_rdma: return nameof(VK_NV_external_memory_rdma); + case VK_EXT_pipeline_properties: return nameof(VK_EXT_pipeline_properties); + case VK_EXT_frame_boundary: return nameof(VK_EXT_frame_boundary); + case VK_EXT_multisampled_render_to_single_sampled: return nameof(VK_EXT_multisampled_render_to_single_sampled); + case VK_EXT_extended_dynamic_state2: return nameof(VK_EXT_extended_dynamic_state2); + case VK_QNX_screen_surface: return nameof(VK_QNX_screen_surface); + case VK_EXT_color_write_enable: return nameof(VK_EXT_color_write_enable); + case VK_EXT_primitives_generated_query: return nameof(VK_EXT_primitives_generated_query); + case VK_KHR_ray_tracing_maintenance1: return nameof(VK_KHR_ray_tracing_maintenance1); + case VK_KHR_shader_untyped_pointers: return nameof(VK_KHR_shader_untyped_pointers); + case VK_EXT_global_priority_query: return nameof(VK_EXT_global_priority_query); + case VK_VALVE_video_encode_rgb_conversion: return nameof(VK_VALVE_video_encode_rgb_conversion); + case VK_EXT_image_view_min_lod: return nameof(VK_EXT_image_view_min_lod); + case VK_EXT_multi_draw: return nameof(VK_EXT_multi_draw); + case VK_EXT_image_2d_view_of_3d: return nameof(VK_EXT_image_2d_view_of_3d); + case VK_KHR_portability_enumeration: return nameof(VK_KHR_portability_enumeration); + case VK_EXT_shader_tile_image: return nameof(VK_EXT_shader_tile_image); + case VK_EXT_opacity_micromap: return nameof(VK_EXT_opacity_micromap); + case VK_NV_displacement_micromap: return nameof(VK_NV_displacement_micromap); + case VK_EXT_load_store_op_none: return nameof(VK_EXT_load_store_op_none); + case VK_HUAWEI_cluster_culling_shader: return nameof(VK_HUAWEI_cluster_culling_shader); + case VK_EXT_border_color_swizzle: return nameof(VK_EXT_border_color_swizzle); + case VK_EXT_pageable_device_local_memory: return nameof(VK_EXT_pageable_device_local_memory); + case VK_KHR_maintenance4: return nameof(VK_KHR_maintenance4); + case VK_ARM_shader_core_properties: return nameof(VK_ARM_shader_core_properties); + case VK_KHR_shader_subgroup_rotate: return nameof(VK_KHR_shader_subgroup_rotate); + case VK_ARM_scheduling_controls: return nameof(VK_ARM_scheduling_controls); + case VK_EXT_image_sliced_view_of_3d: return nameof(VK_EXT_image_sliced_view_of_3d); + case VK_VALVE_descriptor_set_host_mapping: return nameof(VK_VALVE_descriptor_set_host_mapping); + case VK_EXT_depth_clamp_zero_one: return nameof(VK_EXT_depth_clamp_zero_one); + case VK_EXT_non_seamless_cube_map: return nameof(VK_EXT_non_seamless_cube_map); + case VK_ARM_render_pass_striped: return nameof(VK_ARM_render_pass_striped); + case VK_QCOM_fragment_density_map_offset: return nameof(VK_QCOM_fragment_density_map_offset); + case VK_NV_copy_memory_indirect: return nameof(VK_NV_copy_memory_indirect); + case VK_NV_memory_decompression: return nameof(VK_NV_memory_decompression); + case VK_NV_device_generated_commands_compute: return nameof(VK_NV_device_generated_commands_compute); + case VK_NV_ray_tracing_linear_swept_spheres: return nameof(VK_NV_ray_tracing_linear_swept_spheres); + case VK_NV_linear_color_attachment: return nameof(VK_NV_linear_color_attachment); + case VK_GOOGLE_surfaceless_query: return nameof(VK_GOOGLE_surfaceless_query); + case VK_KHR_shader_maximal_reconvergence: return nameof(VK_KHR_shader_maximal_reconvergence); + case VK_EXT_image_compression_control_swapchain: return nameof(VK_EXT_image_compression_control_swapchain); + case VK_QCOM_image_processing: return nameof(VK_QCOM_image_processing); + case VK_EXT_nested_command_buffer: return nameof(VK_EXT_nested_command_buffer); + case VK_OHOS_external_memory: return nameof(VK_OHOS_external_memory); + case VK_EXT_external_memory_acquire_unmodified: return nameof(VK_EXT_external_memory_acquire_unmodified); + case VK_EXT_extended_dynamic_state3: return nameof(VK_EXT_extended_dynamic_state3); + case VK_EXT_subpass_merge_feedback: return nameof(VK_EXT_subpass_merge_feedback); + case VK_LUNARG_direct_driver_loading: return nameof(VK_LUNARG_direct_driver_loading); + case VK_ARM_tensors: return nameof(VK_ARM_tensors); + case VK_EXT_shader_module_identifier: return nameof(VK_EXT_shader_module_identifier); + case VK_EXT_rasterization_order_attachment_access: return nameof(VK_EXT_rasterization_order_attachment_access); + case VK_NV_optical_flow: return nameof(VK_NV_optical_flow); + case VK_EXT_legacy_dithering: return nameof(VK_EXT_legacy_dithering); + case VK_EXT_pipeline_protected_access: return nameof(VK_EXT_pipeline_protected_access); + case VK_ANDROID_external_format_resolve: return nameof(VK_ANDROID_external_format_resolve); + case VK_KHR_maintenance5: return nameof(VK_KHR_maintenance5); + case VK_AMD_anti_lag: return nameof(VK_AMD_anti_lag); + case VK_AMDX_dense_geometry_format: return nameof(VK_AMDX_dense_geometry_format); + case VK_KHR_present_id2: return nameof(VK_KHR_present_id2); + case VK_KHR_present_wait2: return nameof(VK_KHR_present_wait2); + case VK_KHR_ray_tracing_position_fetch: return nameof(VK_KHR_ray_tracing_position_fetch); + case VK_EXT_shader_object: return nameof(VK_EXT_shader_object); + case VK_KHR_pipeline_binary: return nameof(VK_KHR_pipeline_binary); + case VK_QCOM_tile_properties: return nameof(VK_QCOM_tile_properties); + case VK_SEC_amigo_profiling: return nameof(VK_SEC_amigo_profiling); + case VK_KHR_surface_maintenance1: return nameof(VK_KHR_surface_maintenance1); + case VK_KHR_swapchain_maintenance1: return nameof(VK_KHR_swapchain_maintenance1); + case VK_QCOM_multiview_per_view_viewports: return nameof(VK_QCOM_multiview_per_view_viewports); + case VK_NV_ray_tracing_invocation_reorder: return nameof(VK_NV_ray_tracing_invocation_reorder); + case VK_NV_cooperative_vector: return nameof(VK_NV_cooperative_vector); + case VK_NV_extended_sparse_address_space: return nameof(VK_NV_extended_sparse_address_space); + case VK_EXT_mutable_descriptor_type: return nameof(VK_EXT_mutable_descriptor_type); + case VK_EXT_legacy_vertex_attributes: return nameof(VK_EXT_legacy_vertex_attributes); + case VK_EXT_layer_settings: return nameof(VK_EXT_layer_settings); + case VK_ARM_shader_core_builtins: return nameof(VK_ARM_shader_core_builtins); + case VK_EXT_pipeline_library_group_handles: return nameof(VK_EXT_pipeline_library_group_handles); + case VK_EXT_dynamic_rendering_unused_attachments: return nameof(VK_EXT_dynamic_rendering_unused_attachments); + case VK_NV_low_latency2: return nameof(VK_NV_low_latency2); + case VK_KHR_cooperative_matrix: return nameof(VK_KHR_cooperative_matrix); + case VK_ARM_data_graph: return nameof(VK_ARM_data_graph); + case VK_QCOM_multiview_per_view_render_areas: return nameof(VK_QCOM_multiview_per_view_render_areas); + case VK_KHR_compute_shader_derivatives: return nameof(VK_KHR_compute_shader_derivatives); + case VK_KHR_video_decode_av1: return nameof(VK_KHR_video_decode_av1); + case VK_KHR_video_encode_av1: return nameof(VK_KHR_video_encode_av1); + case VK_KHR_video_decode_vp9: return nameof(VK_KHR_video_decode_vp9); + case VK_KHR_video_maintenance1: return nameof(VK_KHR_video_maintenance1); + case VK_NV_per_stage_descriptor_set: return nameof(VK_NV_per_stage_descriptor_set); + case VK_QCOM_image_processing2: return nameof(VK_QCOM_image_processing2); + case VK_QCOM_filter_cubic_weights: return nameof(VK_QCOM_filter_cubic_weights); + case VK_QCOM_ycbcr_degamma: return nameof(VK_QCOM_ycbcr_degamma); + case VK_QCOM_filter_cubic_clamp: return nameof(VK_QCOM_filter_cubic_clamp); + case VK_EXT_attachment_feedback_loop_dynamic_state: return nameof(VK_EXT_attachment_feedback_loop_dynamic_state); + case VK_KHR_vertex_attribute_divisor: return nameof(VK_KHR_vertex_attribute_divisor); + case VK_KHR_load_store_op_none: return nameof(VK_KHR_load_store_op_none); + case VK_KHR_unified_image_layouts: return nameof(VK_KHR_unified_image_layouts); + case VK_KHR_shader_float_controls2: return nameof(VK_KHR_shader_float_controls2); + case VK_QNX_external_memory_screen_buffer: return nameof(VK_QNX_external_memory_screen_buffer); + case VK_MSFT_layered_driver: return nameof(VK_MSFT_layered_driver); + case VK_KHR_index_type_uint8: return nameof(VK_KHR_index_type_uint8); + case VK_KHR_line_rasterization: return nameof(VK_KHR_line_rasterization); + case VK_KHR_calibrated_timestamps: return nameof(VK_KHR_calibrated_timestamps); + case VK_KHR_shader_expect_assume: return nameof(VK_KHR_shader_expect_assume); + case VK_KHR_maintenance6: return nameof(VK_KHR_maintenance6); + case VK_NV_descriptor_pool_overallocation: return nameof(VK_NV_descriptor_pool_overallocation); + case VK_QCOM_tile_memory_heap: return nameof(VK_QCOM_tile_memory_heap); + case VK_KHR_copy_memory_indirect: return nameof(VK_KHR_copy_memory_indirect); + case VK_EXT_memory_decompression: return nameof(VK_EXT_memory_decompression); + case VK_NV_display_stereo: return nameof(VK_NV_display_stereo); + case VK_KHR_video_encode_intra_refresh: return nameof(VK_KHR_video_encode_intra_refresh); + case VK_KHR_video_encode_quantization_map: return nameof(VK_KHR_video_encode_quantization_map); + case VK_NV_raw_access_chains: return nameof(VK_NV_raw_access_chains); + case VK_NV_external_compute_queue: return nameof(VK_NV_external_compute_queue); + case VK_KHR_shader_relaxed_extended_instruction: return nameof(VK_KHR_shader_relaxed_extended_instruction); + case VK_NV_command_buffer_inheritance: return nameof(VK_NV_command_buffer_inheritance); + case VK_KHR_maintenance7: return nameof(VK_KHR_maintenance7); + case VK_NV_shader_atomic_float16_vector: return nameof(VK_NV_shader_atomic_float16_vector); + case VK_EXT_shader_replicated_composites: return nameof(VK_EXT_shader_replicated_composites); + case VK_EXT_shader_float8: return nameof(VK_EXT_shader_float8); + case VK_NV_ray_tracing_validation: return nameof(VK_NV_ray_tracing_validation); + case VK_NV_cluster_acceleration_structure: return nameof(VK_NV_cluster_acceleration_structure); + case VK_NV_partitioned_acceleration_structure: return nameof(VK_NV_partitioned_acceleration_structure); + case VK_EXT_device_generated_commands: return nameof(VK_EXT_device_generated_commands); + case VK_KHR_maintenance8: return nameof(VK_KHR_maintenance8); + case VK_MESA_image_alignment_control: return nameof(VK_MESA_image_alignment_control); + case VK_KHR_shader_fma: return nameof(VK_KHR_shader_fma); + case VK_EXT_ray_tracing_invocation_reorder: return nameof(VK_EXT_ray_tracing_invocation_reorder); + case VK_EXT_depth_clamp_control: return nameof(VK_EXT_depth_clamp_control); + case VK_KHR_maintenance9: return nameof(VK_KHR_maintenance9); + case VK_KHR_video_maintenance2: return nameof(VK_KHR_video_maintenance2); + case VK_OHOS_surface: return nameof(VK_OHOS_surface); + case VK_OHOS_native_buffer: return nameof(VK_OHOS_native_buffer); + case VK_HUAWEI_hdr_vivid: return nameof(VK_HUAWEI_hdr_vivid); + case VK_NV_cooperative_matrix2: return nameof(VK_NV_cooperative_matrix2); + case VK_ARM_pipeline_opacity_micromap: return nameof(VK_ARM_pipeline_opacity_micromap); + case VK_EXT_external_memory_metal: return nameof(VK_EXT_external_memory_metal); + case VK_KHR_depth_clamp_zero_one: return nameof(VK_KHR_depth_clamp_zero_one); + case VK_ARM_performance_counters_by_region: return nameof(VK_ARM_performance_counters_by_region); + case VK_EXT_vertex_attribute_robustness: return nameof(VK_EXT_vertex_attribute_robustness); + case VK_ARM_format_pack: return nameof(VK_ARM_format_pack); + case VK_VALVE_fragment_density_map_layered: return nameof(VK_VALVE_fragment_density_map_layered); + case VK_KHR_robustness2: return nameof(VK_KHR_robustness2); + case VK_NV_present_metering: return nameof(VK_NV_present_metering); + case VK_EXT_fragment_density_map_offset: return nameof(VK_EXT_fragment_density_map_offset); + case VK_EXT_zero_initialize_device_memory: return nameof(VK_EXT_zero_initialize_device_memory); + case VK_KHR_present_mode_fifo_latest_ready: return nameof(VK_KHR_present_mode_fifo_latest_ready); + case VK_EXT_shader_64bit_indexing: return nameof(VK_EXT_shader_64bit_indexing); + case VK_EXT_custom_resolve: return nameof(VK_EXT_custom_resolve); + case VK_QCOM_data_graph_model: return nameof(VK_QCOM_data_graph_model); + case VK_KHR_maintenance10: return nameof(VK_KHR_maintenance10); + case VK_SEC_pipeline_cache_incremental_mode: return nameof(VK_SEC_pipeline_cache_incremental_mode); + case VK_EXT_shader_uniform_buffer_unsized_array: return nameof(VK_EXT_shader_uniform_buffer_unsized_array); + default: return default; + } + } + } + + public String Tag + { + get + { + switch (this) + { + case VK_KHR_surface: return "KHR"; + case VK_KHR_swapchain: return "KHR"; + case VK_KHR_display: return "KHR"; + case VK_KHR_display_swapchain: return "KHR"; + case VK_KHR_xlib_surface: return "KHR"; + case VK_KHR_xcb_surface: return "KHR"; + case VK_KHR_wayland_surface: return "KHR"; + case VK_KHR_android_surface: return "KHR"; + case VK_KHR_win32_surface: return "KHR"; + case VK_EXT_debug_report: return "GOOGLE"; + case VK_NV_glsl_shader: return "NV"; + case VK_EXT_depth_range_unrestricted: return "NV"; + case VK_KHR_sampler_mirror_clamp_to_edge: return "KHR"; + case VK_IMG_filter_cubic: return "IMG"; + case VK_AMD_rasterization_order: return "AMD"; + case VK_AMD_shader_trinary_minmax: return "AMD"; + case VK_AMD_shader_explicit_vertex_parameter: return "AMD"; + case VK_EXT_debug_marker: return "Baldur Karlsson"; + case VK_KHR_video_queue: return "KHR"; + case VK_KHR_video_decode_queue: return "KHR"; + case VK_AMD_gcn_shader: return "AMD"; + case VK_NV_dedicated_allocation: return "NV"; + case VK_EXT_transform_feedback: return "NV"; + case VK_NVX_binary_import: return "NVX"; + case VK_NVX_image_view_handle: return "NVX"; + case VK_AMD_draw_indirect_count: return "AMD"; + case VK_AMD_negative_viewport_height: return "AMD"; + case VK_AMD_gpu_shader_half_float: return "AMD"; + case VK_AMD_shader_ballot: return "AMD"; + case VK_KHR_video_encode_h264: return "KHR"; + case VK_KHR_video_encode_h265: return "KHR"; + case VK_KHR_video_decode_h264: return "KHR"; + case VK_AMD_texture_gather_bias_lod: return "AMD"; + case VK_AMD_shader_info: return "AMD"; + case VK_KHR_dynamic_rendering: return "KHR"; + case VK_AMD_shader_image_load_store_lod: return "AMD"; + case VK_GGP_stream_descriptor_surface: return "GGP"; + case VK_NV_corner_sampled_image: return "NV"; + case VK_KHR_multiview: return "KHR"; + case VK_IMG_format_pvrtc: return "IMG"; + case VK_NV_external_memory_capabilities: return "NV"; + case VK_NV_external_memory: return "NV"; + case VK_NV_external_memory_win32: return "NV"; + case VK_NV_win32_keyed_mutex: return "NV"; + case VK_KHR_get_physical_device_properties2: return "KHR"; + case VK_KHR_device_group: return "KHR"; + case VK_EXT_validation_flags: return "GOOGLE"; + case VK_NN_vi_surface: return "NN"; + case VK_KHR_shader_draw_parameters: return "KHR"; + case VK_EXT_shader_subgroup_ballot: return "NV"; + case VK_EXT_shader_subgroup_vote: return "NV"; + case VK_EXT_texture_compression_astc_hdr: return "ARM"; + case VK_EXT_astc_decode_mode: return "ARM"; + case VK_EXT_pipeline_robustness: return "IMG"; + case VK_KHR_maintenance1: return "KHR"; + case VK_KHR_device_group_creation: return "KHR"; + case VK_KHR_external_memory_capabilities: return "KHR"; + case VK_KHR_external_memory: return "KHR"; + case VK_KHR_external_memory_win32: return "KHR"; + case VK_KHR_external_memory_fd: return "KHR"; + case VK_KHR_win32_keyed_mutex: return "KHR"; + case VK_KHR_external_semaphore_capabilities: return "KHR"; + case VK_KHR_external_semaphore: return "KHR"; + case VK_KHR_external_semaphore_win32: return "KHR"; + case VK_KHR_external_semaphore_fd: return "KHR"; + case VK_KHR_push_descriptor: return "KHR"; + case VK_EXT_conditional_rendering: return "NV"; + case VK_KHR_shader_float16_int8: return "KHR"; + case VK_KHR_16bit_storage: return "KHR"; + case VK_KHR_incremental_present: return "KHR"; + case VK_KHR_descriptor_update_template: return "KHR"; + case VK_NV_clip_space_w_scaling: return "NV"; + case VK_EXT_direct_mode_display: return "NV"; + case VK_EXT_acquire_xlib_display: return "NV"; + case VK_EXT_display_surface_counter: return "NV"; + case VK_EXT_display_control: return "NV"; + case VK_GOOGLE_display_timing: return "GOOGLE"; + case VK_NV_sample_mask_override_coverage: return "NV"; + case VK_NV_geometry_shader_passthrough: return "NV"; + case VK_NV_viewport_array2: return "NV"; + case VK_NVX_multiview_per_view_attributes: return "NVX"; + case VK_NV_viewport_swizzle: return "NV"; + case VK_EXT_discard_rectangles: return "NV"; + case VK_EXT_conservative_rasterization: return "NV"; + case VK_EXT_depth_clip_enable: return "EXT"; + case VK_EXT_swapchain_colorspace: return "GOOGLE"; + case VK_EXT_hdr_metadata: return "GOOGLE"; + case VK_KHR_imageless_framebuffer: return "KHR"; + case VK_KHR_create_renderpass2: return "KHR"; + case VK_IMG_relaxed_line_rasterization: return "IMG"; + case VK_KHR_shared_presentable_image: return "KHR"; + case VK_KHR_external_fence_capabilities: return "KHR"; + case VK_KHR_external_fence: return "KHR"; + case VK_KHR_external_fence_win32: return "KHR"; + case VK_KHR_external_fence_fd: return "KHR"; + case VK_KHR_performance_query: return "KHR"; + case VK_KHR_maintenance2: return "KHR"; + case VK_KHR_get_surface_capabilities2: return "KHR"; + case VK_KHR_variable_pointers: return "KHR"; + case VK_KHR_get_display_properties2: return "KHR"; + case VK_MVK_ios_surface: return "MVK"; + case VK_MVK_macos_surface: return "MVK"; + case VK_EXT_external_memory_dma_buf: return "EXT"; + case VK_EXT_queue_family_foreign: return "EXT"; + case VK_KHR_dedicated_allocation: return "KHR"; + case VK_EXT_debug_utils: return "EXT"; + case VK_ANDROID_external_memory_android_hardware_buffer: return "ANDROID"; + case VK_EXT_sampler_filter_minmax: return "NV"; + case VK_KHR_storage_buffer_storage_class: return "KHR"; + case VK_AMD_gpu_shader_int16: return "AMD"; + case VK_AMDX_shader_enqueue: return "AMD"; + case VK_AMD_mixed_attachment_samples: return "AMD"; + case VK_AMD_shader_fragment_mask: return "AMD"; + case VK_EXT_inline_uniform_block: return "EXT"; + case VK_EXT_shader_stencil_export: return "EXT"; + case VK_KHR_shader_bfloat16: return "KHR"; + case VK_EXT_sample_locations: return "AMD"; + case VK_KHR_relaxed_block_layout: return "KHR"; + case VK_KHR_get_memory_requirements2: return "KHR"; + case VK_KHR_image_format_list: return "KHR"; + case VK_EXT_blend_operation_advanced: return "NV"; + case VK_NV_fragment_coverage_to_color: return "NV"; + case VK_KHR_acceleration_structure: return "KHR"; + case VK_KHR_ray_tracing_pipeline: return "KHR"; + case VK_KHR_ray_query: return "KHR"; + case VK_NV_framebuffer_mixed_samples: return "NV"; + case VK_NV_fill_rectangle: return "NV"; + case VK_NV_shader_sm_builtins: return "NV"; + case VK_EXT_post_depth_coverage: return "NV"; + case VK_KHR_sampler_ycbcr_conversion: return "KHR"; + case VK_KHR_bind_memory2: return "KHR"; + case VK_EXT_image_drm_format_modifier: return "EXT"; + case VK_EXT_validation_cache: return "GOOGLE"; + case VK_EXT_descriptor_indexing: return "NV"; + case VK_EXT_shader_viewport_index_layer: return "NV"; + case VK_KHR_portability_subset: return "KHR"; + case VK_NV_shading_rate_image: return "NV"; + case VK_NV_ray_tracing: return "NV"; + case VK_NV_representative_fragment_test: return "NV"; + case VK_KHR_maintenance3: return "KHR"; + case VK_KHR_draw_indirect_count: return "KHR"; + case VK_EXT_filter_cubic: return "QCOM"; + case VK_QCOM_render_pass_shader_resolve: return "QCOM"; + case VK_EXT_global_priority: return "EXT"; + case VK_KHR_shader_subgroup_extended_types: return "KHR"; + case VK_KHR_8bit_storage: return "KHR"; + case VK_EXT_external_memory_host: return "EXT"; + case VK_AMD_buffer_marker: return "AMD"; + case VK_KHR_shader_atomic_int64: return "KHR"; + case VK_KHR_shader_clock: return "KHR"; + case VK_AMD_pipeline_compiler_control: return "AMD"; + case VK_EXT_calibrated_timestamps: return "EXT"; + case VK_AMD_shader_core_properties: return "AMD"; + case VK_KHR_video_decode_h265: return "KHR"; + case VK_KHR_global_priority: return "KHR"; + case VK_AMD_memory_overallocation_behavior: return "AMD"; + case VK_EXT_vertex_attribute_divisor: return "NV"; + case VK_GGP_frame_token: return "GGP"; + case VK_EXT_pipeline_creation_feedback: return "GOOGLE"; + case VK_KHR_driver_properties: return "KHR"; + case VK_KHR_shader_float_controls: return "KHR"; + case VK_NV_shader_subgroup_partitioned: return "NV"; + case VK_KHR_depth_stencil_resolve: return "KHR"; + case VK_KHR_swapchain_mutable_format: return "KHR"; + case VK_NV_compute_shader_derivatives: return "NV"; + case VK_NV_mesh_shader: return "NV"; + case VK_NV_fragment_shader_barycentric: return "NV"; + case VK_NV_shader_image_footprint: return "NV"; + case VK_NV_scissor_exclusive: return "NV"; + case VK_NV_device_diagnostic_checkpoints: return "NVIDIA"; + case VK_KHR_timeline_semaphore: return "KHR"; + case VK_EXT_present_timing: return "EXT"; + case VK_INTEL_shader_integer_functions2: return "INTEL"; + case VK_INTEL_performance_query: return "INTEL"; + case VK_KHR_vulkan_memory_model: return "KHR"; + case VK_EXT_pci_bus_info: return "EXT"; + case VK_AMD_display_native_hdr: return "AMD"; + case VK_FUCHSIA_imagepipe_surface: return "FUCHSIA"; + case VK_KHR_shader_terminate_invocation: return "KHR"; + case VK_EXT_metal_surface: return "EXT"; + case VK_EXT_fragment_density_map: return "EXT"; + case VK_EXT_scalar_block_layout: return "EXT"; + case VK_GOOGLE_hlsl_functionality1: return "GOOGLE"; + case VK_GOOGLE_decorate_string: return "GOOGLE"; + case VK_EXT_subgroup_size_control: return "EXT"; + case VK_KHR_fragment_shading_rate: return "KHR"; + case VK_AMD_shader_core_properties2: return "AMD"; + case VK_AMD_device_coherent_memory: return "AMD"; + case VK_KHR_dynamic_rendering_local_read: return "AMD"; + case VK_EXT_shader_image_atomic_int64: return "EXT"; + case VK_KHR_shader_quad_control: return "KHR"; + case VK_KHR_spirv_1_4: return "KHR"; + case VK_EXT_memory_budget: return "EXT"; + case VK_EXT_memory_priority: return "EXT"; + case VK_KHR_surface_protected_capabilities: return "KHR"; + case VK_NV_dedicated_allocation_image_aliasing: return "NVIDIA"; + case VK_KHR_separate_depth_stencil_layouts: return "KHR"; + case VK_EXT_buffer_device_address: return "NV"; + case VK_EXT_tooling_info: return "EXT"; + case VK_EXT_separate_stencil_usage: return "EXT"; + case VK_EXT_validation_features: return "LUNARG"; + case VK_KHR_present_wait: return "KHR"; + case VK_NV_cooperative_matrix: return "NV"; + case VK_NV_coverage_reduction_mode: return "NV"; + case VK_EXT_fragment_shader_interlock: return "EXT"; + case VK_EXT_ycbcr_image_arrays: return "EXT"; + case VK_KHR_uniform_buffer_standard_layout: return "KHR"; + case VK_EXT_provoking_vertex: return "EXT"; + case VK_EXT_full_screen_exclusive: return "EXT"; + case VK_EXT_headless_surface: return "EXT"; + case VK_KHR_buffer_device_address: return "KHR"; + case VK_EXT_line_rasterization: return "EXT"; + case VK_EXT_shader_atomic_float: return "NV"; + case VK_EXT_host_query_reset: return "EXT"; + case VK_EXT_index_type_uint8: return "EXT"; + case VK_EXT_extended_dynamic_state: return "EXT"; + case VK_KHR_deferred_host_operations: return "KHR"; + case VK_KHR_pipeline_executable_properties: return "KHR"; + case VK_EXT_host_image_copy: return "EXT"; + case VK_KHR_map_memory2: return "KHR"; + case VK_EXT_map_memory_placed: return "EXT"; + case VK_EXT_shader_atomic_float2: return "EXT"; + case VK_EXT_surface_maintenance1: return "EXT"; + case VK_EXT_swapchain_maintenance1: return "EXT"; + case VK_EXT_shader_demote_to_helper_invocation: return "EXT"; + case VK_NV_device_generated_commands: return "NV"; + case VK_NV_inherited_viewport_scissor: return "NV"; + case VK_KHR_shader_integer_dot_product: return "KHR"; + case VK_EXT_texel_buffer_alignment: return "EXT"; + case VK_QCOM_render_pass_transform: return "QCOM"; + case VK_EXT_depth_bias_control: return "EXT"; + case VK_EXT_device_memory_report: return "EXT"; + case VK_EXT_acquire_drm_display: return "EXT"; + case VK_EXT_robustness2: return "EXT"; + case VK_EXT_custom_border_color: return "EXT"; + case VK_GOOGLE_user_type: return "GOOGLE"; + case VK_KHR_pipeline_library: return "KHR"; + case VK_NV_present_barrier: return "NV"; + case VK_KHR_shader_non_semantic_info: return "KHR"; + case VK_KHR_present_id: return "KHR"; + case VK_EXT_private_data: return "NV"; + case VK_EXT_pipeline_creation_cache_control: return "AMD"; + case VK_KHR_video_encode_queue: return "KHR"; + case VK_NV_device_diagnostics_config: return "NV"; + case VK_QCOM_render_pass_store_ops: return "QCOM"; + case VK_NV_cuda_kernel_launch: return "NV"; + case VK_QCOM_tile_shading: return "QCOM"; + case VK_NV_low_latency: return "NV"; + case VK_EXT_metal_objects: return "EXT"; + case VK_KHR_synchronization2: return "KHR"; + case VK_EXT_descriptor_buffer: return "EXT"; + case VK_EXT_graphics_pipeline_library: return "AMD"; + case VK_AMD_shader_early_and_late_fragment_tests: return "EXT"; + case VK_KHR_fragment_shader_barycentric: return "KHR"; + case VK_KHR_shader_subgroup_uniform_control_flow: return "KHR"; + case VK_KHR_zero_initialize_workgroup_memory: return "KHR"; + case VK_NV_fragment_shading_rate_enums: return "NV"; + case VK_NV_ray_tracing_motion_blur: return "NV"; + case VK_EXT_mesh_shader: return "EXT"; + case VK_EXT_ycbcr_2plane_444_formats: return "EXT"; + case VK_EXT_fragment_density_map2: return "EXT"; + case VK_QCOM_rotated_copy_commands: return "QCOM"; + case VK_EXT_image_robustness: return "EXT"; + case VK_KHR_workgroup_memory_explicit_layout: return "KHR"; + case VK_KHR_copy_commands2: return "KHR"; + case VK_EXT_image_compression_control: return "EXT"; + case VK_EXT_attachment_feedback_loop_layout: return "EXT"; + case VK_EXT_4444_formats: return "EXT"; + case VK_EXT_device_fault: return "EXT"; + case VK_ARM_rasterization_order_attachment_access: return "ARM"; + case VK_EXT_rgba10x6_formats: return "EXT"; + case VK_NV_acquire_winrt_display: return "NV"; + case VK_EXT_directfb_surface: return "EXT"; + case VK_VALVE_mutable_descriptor_type: return "VALVE"; + case VK_EXT_vertex_input_dynamic_state: return "EXT"; + case VK_EXT_physical_device_drm: return "EXT"; + case VK_EXT_device_address_binding_report: return "EXT"; + case VK_EXT_depth_clip_control: return "EXT"; + case VK_EXT_primitive_topology_list_restart: return "EXT"; + case VK_KHR_format_feature_flags2: return "KHR"; + case VK_EXT_present_mode_fifo_latest_ready: return "EXT"; + case VK_FUCHSIA_external_memory: return "FUCHSIA"; + case VK_FUCHSIA_external_semaphore: return "FUCHSIA"; + case VK_FUCHSIA_buffer_collection: return "FUCHSIA"; + case VK_HUAWEI_subpass_shading: return "HUAWEI"; + case VK_HUAWEI_invocation_mask: return "Huawei"; + case VK_NV_external_memory_rdma: return "NV"; + case VK_EXT_pipeline_properties: return "EXT"; + case VK_EXT_frame_boundary: return "EXT"; + case VK_EXT_multisampled_render_to_single_sampled: return "EXT"; + case VK_EXT_extended_dynamic_state2: return "EXT"; + case VK_QNX_screen_surface: return "QNX"; + case VK_EXT_color_write_enable: return "EXT"; + case VK_EXT_primitives_generated_query: return "EXT"; + case VK_KHR_ray_tracing_maintenance1: return "KHR"; + case VK_KHR_shader_untyped_pointers: return "KHR"; + case VK_EXT_global_priority_query: return "EXT"; + case VK_VALVE_video_encode_rgb_conversion: return "VALVE"; + case VK_EXT_image_view_min_lod: return "EXT"; + case VK_EXT_multi_draw: return "EXT"; + case VK_EXT_image_2d_view_of_3d: return "EXT"; + case VK_KHR_portability_enumeration: return "KHR"; + case VK_EXT_shader_tile_image: return "EXT"; + case VK_EXT_opacity_micromap: return "EXT"; + case VK_NV_displacement_micromap: return "NV"; + case VK_EXT_load_store_op_none: return "EXT"; + case VK_HUAWEI_cluster_culling_shader: return "HUAWEI"; + case VK_EXT_border_color_swizzle: return "EXT"; + case VK_EXT_pageable_device_local_memory: return "EXT"; + case VK_KHR_maintenance4: return "KHR"; + case VK_ARM_shader_core_properties: return "ARM"; + case VK_KHR_shader_subgroup_rotate: return "KHR"; + case VK_ARM_scheduling_controls: return "ARM"; + case VK_EXT_image_sliced_view_of_3d: return "EXT"; + case VK_VALVE_descriptor_set_host_mapping: return "VALVE"; + case VK_EXT_depth_clamp_zero_one: return "EXT"; + case VK_EXT_non_seamless_cube_map: return "EXT"; + case VK_ARM_render_pass_striped: return "ARM"; + case VK_QCOM_fragment_density_map_offset: return "QCOM"; + case VK_NV_copy_memory_indirect: return "NV"; + case VK_NV_memory_decompression: return "NV"; + case VK_NV_device_generated_commands_compute: return "NV"; + case VK_NV_ray_tracing_linear_swept_spheres: return "NV"; + case VK_NV_linear_color_attachment: return "NVIDIA"; + case VK_GOOGLE_surfaceless_query: return "GOOGLE"; + case VK_KHR_shader_maximal_reconvergence: return "KHR"; + case VK_EXT_image_compression_control_swapchain: return "EXT"; + case VK_QCOM_image_processing: return "QCOM"; + case VK_EXT_nested_command_buffer: return "EXT"; + case VK_OHOS_external_memory: return "HUAWEI"; + case VK_EXT_external_memory_acquire_unmodified: return "EXT"; + case VK_EXT_extended_dynamic_state3: return "NV"; + case VK_EXT_subpass_merge_feedback: return "EXT"; + case VK_LUNARG_direct_driver_loading: return "LUNARG"; + case VK_ARM_tensors: return "ARM"; + case VK_EXT_shader_module_identifier: return "EXT"; + case VK_EXT_rasterization_order_attachment_access: return "ARM"; + case VK_NV_optical_flow: return "NV"; + case VK_EXT_legacy_dithering: return "EXT"; + case VK_EXT_pipeline_protected_access: return "EXT"; + case VK_ANDROID_external_format_resolve: return "ANDROID"; + case VK_KHR_maintenance5: return "KHR"; + case VK_AMD_anti_lag: return "AMD"; + case VK_AMDX_dense_geometry_format: return "AMD"; + case VK_KHR_present_id2: return "KHR"; + case VK_KHR_present_wait2: return "KHR"; + case VK_KHR_ray_tracing_position_fetch: return "KHR"; + case VK_EXT_shader_object: return "EXT"; + case VK_KHR_pipeline_binary: return "KHR"; + case VK_QCOM_tile_properties: return "QCOM"; + case VK_SEC_amigo_profiling: return "SEC"; + case VK_KHR_surface_maintenance1: return "KHR"; + case VK_KHR_swapchain_maintenance1: return "KHR"; + case VK_QCOM_multiview_per_view_viewports: return "QCOM"; + case VK_NV_ray_tracing_invocation_reorder: return "NV"; + case VK_NV_cooperative_vector: return "NV"; + case VK_NV_extended_sparse_address_space: return "NV"; + case VK_EXT_mutable_descriptor_type: return "EXT"; + case VK_EXT_legacy_vertex_attributes: return "EXT"; + case VK_EXT_layer_settings: return "EXT"; + case VK_ARM_shader_core_builtins: return "ARM"; + case VK_EXT_pipeline_library_group_handles: return "EXT"; + case VK_EXT_dynamic_rendering_unused_attachments: return "EXT"; + case VK_NV_low_latency2: return "NV"; + case VK_KHR_cooperative_matrix: return "KHR"; + case VK_ARM_data_graph: return "ARM"; + case VK_QCOM_multiview_per_view_render_areas: return "QCOM"; + case VK_KHR_compute_shader_derivatives: return "KHR"; + case VK_KHR_video_decode_av1: return "KHR"; + case VK_KHR_video_encode_av1: return "KHR"; + case VK_KHR_video_decode_vp9: return "KHR"; + case VK_KHR_video_maintenance1: return "KHR"; + case VK_NV_per_stage_descriptor_set: return "NV"; + case VK_QCOM_image_processing2: return "QCOM"; + case VK_QCOM_filter_cubic_weights: return "QCOM"; + case VK_QCOM_ycbcr_degamma: return "QCOM"; + case VK_QCOM_filter_cubic_clamp: return "QCOM"; + case VK_EXT_attachment_feedback_loop_dynamic_state: return "EXT"; + case VK_KHR_vertex_attribute_divisor: return "KHR"; + case VK_KHR_load_store_op_none: return "KHR"; + case VK_KHR_unified_image_layouts: return "KHR"; + case VK_KHR_shader_float_controls2: return "KHR"; + case VK_QNX_external_memory_screen_buffer: return "QNX"; + case VK_MSFT_layered_driver: return "MSFT"; + case VK_KHR_index_type_uint8: return "KHR"; + case VK_KHR_line_rasterization: return "KHR"; + case VK_KHR_calibrated_timestamps: return "KHR"; + case VK_KHR_shader_expect_assume: return "KHR"; + case VK_KHR_maintenance6: return "KHR"; + case VK_NV_descriptor_pool_overallocation: return "NV"; + case VK_QCOM_tile_memory_heap: return "QCOM"; + case VK_KHR_copy_memory_indirect: return "KHR"; + case VK_EXT_memory_decompression: return "EXT"; + case VK_NV_display_stereo: return "NV"; + case VK_KHR_video_encode_intra_refresh: return "KHR"; + case VK_KHR_video_encode_quantization_map: return "KHR"; + case VK_NV_raw_access_chains: return "NV"; + case VK_NV_external_compute_queue: return "NV"; + case VK_KHR_shader_relaxed_extended_instruction: return "KHR"; + case VK_NV_command_buffer_inheritance: return "NV"; + case VK_KHR_maintenance7: return "KHR"; + case VK_NV_shader_atomic_float16_vector: return "NV"; + case VK_EXT_shader_replicated_composites: return "EXT"; + case VK_EXT_shader_float8: return "EXT"; + case VK_NV_ray_tracing_validation: return "NV"; + case VK_NV_cluster_acceleration_structure: return "NV"; + case VK_NV_partitioned_acceleration_structure: return "NV"; + case VK_EXT_device_generated_commands: return "EXT"; + case VK_KHR_maintenance8: return "KHR"; + case VK_MESA_image_alignment_control: return "MESA"; + case VK_KHR_shader_fma: return "KHR"; + case VK_EXT_ray_tracing_invocation_reorder: return "EXT"; + case VK_EXT_depth_clamp_control: return "EXT"; + case VK_KHR_maintenance9: return "KHR"; + case VK_KHR_video_maintenance2: return "KHR"; + case VK_OHOS_surface: return "HUAWEI"; + case VK_OHOS_native_buffer: return "HUAWEI"; + case VK_HUAWEI_hdr_vivid: return "HUAWEI"; + case VK_NV_cooperative_matrix2: return "NV"; + case VK_ARM_pipeline_opacity_micromap: return "ARM"; + case VK_EXT_external_memory_metal: return "EXT"; + case VK_KHR_depth_clamp_zero_one: return "KHR"; + case VK_ARM_performance_counters_by_region: return "ARM"; + case VK_EXT_vertex_attribute_robustness: return "EXT"; + case VK_ARM_format_pack: return "ARM"; + case VK_VALVE_fragment_density_map_layered: return "VALVE"; + case VK_KHR_robustness2: return "KHR"; + case VK_NV_present_metering: return "NV"; + case VK_EXT_fragment_density_map_offset: return "EXT"; + case VK_EXT_zero_initialize_device_memory: return "EXT"; + case VK_KHR_present_mode_fifo_latest_ready: return "KHR"; + case VK_EXT_shader_64bit_indexing: return "EXT"; + case VK_EXT_custom_resolve: return "EXT"; + case VK_QCOM_data_graph_model: return "QCOM"; + case VK_KHR_maintenance10: return "KHR"; + case VK_SEC_pipeline_cache_incremental_mode: return "SEC"; + case VK_EXT_shader_uniform_buffer_unsized_array: return "EXT"; + default: return default; + } + } + } + + public Kind Kind + { + get + { + switch (this) + { + case VK_KHR_surface: return .Instance; + case VK_KHR_swapchain: return .Device; + case VK_KHR_display: return .Instance; + case VK_KHR_display_swapchain: return .Device; + case VK_KHR_xlib_surface: return .Instance; + case VK_KHR_xcb_surface: return .Instance; + case VK_KHR_wayland_surface: return .Instance; + case VK_KHR_android_surface: return .Instance; + case VK_KHR_win32_surface: return .Instance; + case VK_EXT_debug_report: return .Instance; + case VK_NV_glsl_shader: return .Device; + case VK_EXT_depth_range_unrestricted: return .Device; + case VK_KHR_sampler_mirror_clamp_to_edge: return .Device; + case VK_IMG_filter_cubic: return .Device; + case VK_AMD_rasterization_order: return .Device; + case VK_AMD_shader_trinary_minmax: return .Device; + case VK_AMD_shader_explicit_vertex_parameter: return .Device; + case VK_EXT_debug_marker: return .Device; + case VK_KHR_video_queue: return .Device; + case VK_KHR_video_decode_queue: return .Device; + case VK_AMD_gcn_shader: return .Device; + case VK_NV_dedicated_allocation: return .Device; + case VK_EXT_transform_feedback: return .Device; + case VK_NVX_binary_import: return .Device; + case VK_NVX_image_view_handle: return .Device; + case VK_AMD_draw_indirect_count: return .Device; + case VK_AMD_negative_viewport_height: return .Device; + case VK_AMD_gpu_shader_half_float: return .Device; + case VK_AMD_shader_ballot: return .Device; + case VK_KHR_video_encode_h264: return .Device; + case VK_KHR_video_encode_h265: return .Device; + case VK_KHR_video_decode_h264: return .Device; + case VK_AMD_texture_gather_bias_lod: return .Device; + case VK_AMD_shader_info: return .Device; + case VK_KHR_dynamic_rendering: return .Device; + case VK_AMD_shader_image_load_store_lod: return .Device; + case VK_GGP_stream_descriptor_surface: return .Instance; + case VK_NV_corner_sampled_image: return .Device; + case VK_KHR_multiview: return .Device; + case VK_IMG_format_pvrtc: return .Device; + case VK_NV_external_memory_capabilities: return .Instance; + case VK_NV_external_memory: return .Device; + case VK_NV_external_memory_win32: return .Device; + case VK_NV_win32_keyed_mutex: return .Device; + case VK_KHR_get_physical_device_properties2: return .Instance; + case VK_KHR_device_group: return .Device; + case VK_EXT_validation_flags: return .Instance; + case VK_NN_vi_surface: return .Instance; + case VK_KHR_shader_draw_parameters: return .Device; + case VK_EXT_shader_subgroup_ballot: return .Device; + case VK_EXT_shader_subgroup_vote: return .Device; + case VK_EXT_texture_compression_astc_hdr: return .Device; + case VK_EXT_astc_decode_mode: return .Device; + case VK_EXT_pipeline_robustness: return .Device; + case VK_KHR_maintenance1: return .Device; + case VK_KHR_device_group_creation: return .Instance; + case VK_KHR_external_memory_capabilities: return .Instance; + case VK_KHR_external_memory: return .Device; + case VK_KHR_external_memory_win32: return .Device; + case VK_KHR_external_memory_fd: return .Device; + case VK_KHR_win32_keyed_mutex: return .Device; + case VK_KHR_external_semaphore_capabilities: return .Instance; + case VK_KHR_external_semaphore: return .Device; + case VK_KHR_external_semaphore_win32: return .Device; + case VK_KHR_external_semaphore_fd: return .Device; + case VK_KHR_push_descriptor: return .Device; + case VK_EXT_conditional_rendering: return .Device; + case VK_KHR_shader_float16_int8: return .Device; + case VK_KHR_16bit_storage: return .Device; + case VK_KHR_incremental_present: return .Device; + case VK_KHR_descriptor_update_template: return .Device; + case VK_NV_clip_space_w_scaling: return .Device; + case VK_EXT_direct_mode_display: return .Instance; + case VK_EXT_acquire_xlib_display: return .Instance; + case VK_EXT_display_surface_counter: return .Instance; + case VK_EXT_display_control: return .Device; + case VK_GOOGLE_display_timing: return .Device; + case VK_NV_sample_mask_override_coverage: return .Device; + case VK_NV_geometry_shader_passthrough: return .Device; + case VK_NV_viewport_array2: return .Device; + case VK_NVX_multiview_per_view_attributes: return .Device; + case VK_NV_viewport_swizzle: return .Device; + case VK_EXT_discard_rectangles: return .Device; + case VK_EXT_conservative_rasterization: return .Device; + case VK_EXT_depth_clip_enable: return .Device; + case VK_EXT_swapchain_colorspace: return .Instance; + case VK_EXT_hdr_metadata: return .Device; + case VK_KHR_imageless_framebuffer: return .Device; + case VK_KHR_create_renderpass2: return .Device; + case VK_IMG_relaxed_line_rasterization: return .Device; + case VK_KHR_shared_presentable_image: return .Device; + case VK_KHR_external_fence_capabilities: return .Instance; + case VK_KHR_external_fence: return .Device; + case VK_KHR_external_fence_win32: return .Device; + case VK_KHR_external_fence_fd: return .Device; + case VK_KHR_performance_query: return .Device; + case VK_KHR_maintenance2: return .Device; + case VK_KHR_get_surface_capabilities2: return .Instance; + case VK_KHR_variable_pointers: return .Device; + case VK_KHR_get_display_properties2: return .Instance; + case VK_MVK_ios_surface: return .Instance; + case VK_MVK_macos_surface: return .Instance; + case VK_EXT_external_memory_dma_buf: return .Device; + case VK_EXT_queue_family_foreign: return .Device; + case VK_KHR_dedicated_allocation: return .Device; + case VK_EXT_debug_utils: return .Instance; + case VK_ANDROID_external_memory_android_hardware_buffer: return .Device; + case VK_EXT_sampler_filter_minmax: return .Device; + case VK_KHR_storage_buffer_storage_class: return .Device; + case VK_AMD_gpu_shader_int16: return .Device; + case VK_AMDX_shader_enqueue: return .Device; + case VK_AMD_mixed_attachment_samples: return .Device; + case VK_AMD_shader_fragment_mask: return .Device; + case VK_EXT_inline_uniform_block: return .Device; + case VK_EXT_shader_stencil_export: return .Device; + case VK_KHR_shader_bfloat16: return .Device; + case VK_EXT_sample_locations: return .Device; + case VK_KHR_relaxed_block_layout: return .Device; + case VK_KHR_get_memory_requirements2: return .Device; + case VK_KHR_image_format_list: return .Device; + case VK_EXT_blend_operation_advanced: return .Device; + case VK_NV_fragment_coverage_to_color: return .Device; + case VK_KHR_acceleration_structure: return .Device; + case VK_KHR_ray_tracing_pipeline: return .Device; + case VK_KHR_ray_query: return .Device; + case VK_NV_framebuffer_mixed_samples: return .Device; + case VK_NV_fill_rectangle: return .Device; + case VK_NV_shader_sm_builtins: return .Device; + case VK_EXT_post_depth_coverage: return .Device; + case VK_KHR_sampler_ycbcr_conversion: return .Device; + case VK_KHR_bind_memory2: return .Device; + case VK_EXT_image_drm_format_modifier: return .Device; + case VK_EXT_validation_cache: return .Device; + case VK_EXT_descriptor_indexing: return .Device; + case VK_EXT_shader_viewport_index_layer: return .Device; + case VK_KHR_portability_subset: return .Device; + case VK_NV_shading_rate_image: return .Device; + case VK_NV_ray_tracing: return .Device; + case VK_NV_representative_fragment_test: return .Device; + case VK_KHR_maintenance3: return .Device; + case VK_KHR_draw_indirect_count: return .Device; + case VK_EXT_filter_cubic: return .Device; + case VK_QCOM_render_pass_shader_resolve: return .Device; + case VK_EXT_global_priority: return .Device; + case VK_KHR_shader_subgroup_extended_types: return .Device; + case VK_KHR_8bit_storage: return .Device; + case VK_EXT_external_memory_host: return .Device; + case VK_AMD_buffer_marker: return .Device; + case VK_KHR_shader_atomic_int64: return .Device; + case VK_KHR_shader_clock: return .Device; + case VK_AMD_pipeline_compiler_control: return .Device; + case VK_EXT_calibrated_timestamps: return .Device; + case VK_AMD_shader_core_properties: return .Device; + case VK_KHR_video_decode_h265: return .Device; + case VK_KHR_global_priority: return .Device; + case VK_AMD_memory_overallocation_behavior: return .Device; + case VK_EXT_vertex_attribute_divisor: return .Device; + case VK_GGP_frame_token: return .Device; + case VK_EXT_pipeline_creation_feedback: return .Device; + case VK_KHR_driver_properties: return .Device; + case VK_KHR_shader_float_controls: return .Device; + case VK_NV_shader_subgroup_partitioned: return .Device; + case VK_KHR_depth_stencil_resolve: return .Device; + case VK_KHR_swapchain_mutable_format: return .Device; + case VK_NV_compute_shader_derivatives: return .Device; + case VK_NV_mesh_shader: return .Device; + case VK_NV_fragment_shader_barycentric: return .Device; + case VK_NV_shader_image_footprint: return .Device; + case VK_NV_scissor_exclusive: return .Device; + case VK_NV_device_diagnostic_checkpoints: return .Device; + case VK_KHR_timeline_semaphore: return .Device; + case VK_EXT_present_timing: return .Device; + case VK_INTEL_shader_integer_functions2: return .Device; + case VK_INTEL_performance_query: return .Device; + case VK_KHR_vulkan_memory_model: return .Device; + case VK_EXT_pci_bus_info: return .Device; + case VK_AMD_display_native_hdr: return .Device; + case VK_FUCHSIA_imagepipe_surface: return .Instance; + case VK_KHR_shader_terminate_invocation: return .Device; + case VK_EXT_metal_surface: return .Instance; + case VK_EXT_fragment_density_map: return .Device; + case VK_EXT_scalar_block_layout: return .Device; + case VK_GOOGLE_hlsl_functionality1: return .Device; + case VK_GOOGLE_decorate_string: return .Device; + case VK_EXT_subgroup_size_control: return .Device; + case VK_KHR_fragment_shading_rate: return .Device; + case VK_AMD_shader_core_properties2: return .Device; + case VK_AMD_device_coherent_memory: return .Device; + case VK_KHR_dynamic_rendering_local_read: return .Device; + case VK_EXT_shader_image_atomic_int64: return .Device; + case VK_KHR_shader_quad_control: return .Device; + case VK_KHR_spirv_1_4: return .Device; + case VK_EXT_memory_budget: return .Device; + case VK_EXT_memory_priority: return .Device; + case VK_KHR_surface_protected_capabilities: return .Instance; + case VK_NV_dedicated_allocation_image_aliasing: return .Device; + case VK_KHR_separate_depth_stencil_layouts: return .Device; + case VK_EXT_buffer_device_address: return .Device; + case VK_EXT_tooling_info: return .Device; + case VK_EXT_separate_stencil_usage: return .Device; + case VK_EXT_validation_features: return .Instance; + case VK_KHR_present_wait: return .Device; + case VK_NV_cooperative_matrix: return .Device; + case VK_NV_coverage_reduction_mode: return .Device; + case VK_EXT_fragment_shader_interlock: return .Device; + case VK_EXT_ycbcr_image_arrays: return .Device; + case VK_KHR_uniform_buffer_standard_layout: return .Device; + case VK_EXT_provoking_vertex: return .Device; + case VK_EXT_full_screen_exclusive: return .Device; + case VK_EXT_headless_surface: return .Instance; + case VK_KHR_buffer_device_address: return .Device; + case VK_EXT_line_rasterization: return .Device; + case VK_EXT_shader_atomic_float: return .Device; + case VK_EXT_host_query_reset: return .Device; + case VK_EXT_index_type_uint8: return .Device; + case VK_EXT_extended_dynamic_state: return .Device; + case VK_KHR_deferred_host_operations: return .Device; + case VK_KHR_pipeline_executable_properties: return .Device; + case VK_EXT_host_image_copy: return .Device; + case VK_KHR_map_memory2: return .Device; + case VK_EXT_map_memory_placed: return .Device; + case VK_EXT_shader_atomic_float2: return .Device; + case VK_EXT_surface_maintenance1: return .Instance; + case VK_EXT_swapchain_maintenance1: return .Device; + case VK_EXT_shader_demote_to_helper_invocation: return .Device; + case VK_NV_device_generated_commands: return .Device; + case VK_NV_inherited_viewport_scissor: return .Device; + case VK_KHR_shader_integer_dot_product: return .Device; + case VK_EXT_texel_buffer_alignment: return .Device; + case VK_QCOM_render_pass_transform: return .Device; + case VK_EXT_depth_bias_control: return .Device; + case VK_EXT_device_memory_report: return .Device; + case VK_EXT_acquire_drm_display: return .Instance; + case VK_EXT_robustness2: return .Device; + case VK_EXT_custom_border_color: return .Device; + case VK_GOOGLE_user_type: return .Device; + case VK_KHR_pipeline_library: return .Device; + case VK_NV_present_barrier: return .Device; + case VK_KHR_shader_non_semantic_info: return .Device; + case VK_KHR_present_id: return .Device; + case VK_EXT_private_data: return .Device; + case VK_EXT_pipeline_creation_cache_control: return .Device; + case VK_KHR_video_encode_queue: return .Device; + case VK_NV_device_diagnostics_config: return .Device; + case VK_QCOM_render_pass_store_ops: return .Device; + case VK_NV_cuda_kernel_launch: return .Device; + case VK_QCOM_tile_shading: return .Device; + case VK_NV_low_latency: return .Device; + case VK_EXT_metal_objects: return .Device; + case VK_KHR_synchronization2: return .Device; + case VK_EXT_descriptor_buffer: return .Device; + case VK_EXT_graphics_pipeline_library: return .Device; + case VK_AMD_shader_early_and_late_fragment_tests: return .Device; + case VK_KHR_fragment_shader_barycentric: return .Device; + case VK_KHR_shader_subgroup_uniform_control_flow: return .Device; + case VK_KHR_zero_initialize_workgroup_memory: return .Device; + case VK_NV_fragment_shading_rate_enums: return .Device; + case VK_NV_ray_tracing_motion_blur: return .Device; + case VK_EXT_mesh_shader: return .Device; + case VK_EXT_ycbcr_2plane_444_formats: return .Device; + case VK_EXT_fragment_density_map2: return .Device; + case VK_QCOM_rotated_copy_commands: return .Device; + case VK_EXT_image_robustness: return .Device; + case VK_KHR_workgroup_memory_explicit_layout: return .Device; + case VK_KHR_copy_commands2: return .Device; + case VK_EXT_image_compression_control: return .Device; + case VK_EXT_attachment_feedback_loop_layout: return .Device; + case VK_EXT_4444_formats: return .Device; + case VK_EXT_device_fault: return .Device; + case VK_ARM_rasterization_order_attachment_access: return .Device; + case VK_EXT_rgba10x6_formats: return .Device; + case VK_NV_acquire_winrt_display: return .Device; + case VK_EXT_directfb_surface: return .Instance; + case VK_VALVE_mutable_descriptor_type: return .Device; + case VK_EXT_vertex_input_dynamic_state: return .Device; + case VK_EXT_physical_device_drm: return .Device; + case VK_EXT_device_address_binding_report: return .Device; + case VK_EXT_depth_clip_control: return .Device; + case VK_EXT_primitive_topology_list_restart: return .Device; + case VK_KHR_format_feature_flags2: return .Device; + case VK_EXT_present_mode_fifo_latest_ready: return .Device; + case VK_FUCHSIA_external_memory: return .Device; + case VK_FUCHSIA_external_semaphore: return .Device; + case VK_FUCHSIA_buffer_collection: return .Device; + case VK_HUAWEI_subpass_shading: return .Device; + case VK_HUAWEI_invocation_mask: return .Device; + case VK_NV_external_memory_rdma: return .Device; + case VK_EXT_pipeline_properties: return .Device; + case VK_EXT_frame_boundary: return .Device; + case VK_EXT_multisampled_render_to_single_sampled: return .Device; + case VK_EXT_extended_dynamic_state2: return .Device; + case VK_QNX_screen_surface: return .Instance; + case VK_EXT_color_write_enable: return .Device; + case VK_EXT_primitives_generated_query: return .Device; + case VK_KHR_ray_tracing_maintenance1: return .Device; + case VK_KHR_shader_untyped_pointers: return .Device; + case VK_EXT_global_priority_query: return .Device; + case VK_VALVE_video_encode_rgb_conversion: return .Device; + case VK_EXT_image_view_min_lod: return .Device; + case VK_EXT_multi_draw: return .Device; + case VK_EXT_image_2d_view_of_3d: return .Device; + case VK_KHR_portability_enumeration: return .Instance; + case VK_EXT_shader_tile_image: return .Device; + case VK_EXT_opacity_micromap: return .Device; + case VK_NV_displacement_micromap: return .Device; + case VK_EXT_load_store_op_none: return .Device; + case VK_HUAWEI_cluster_culling_shader: return .Device; + case VK_EXT_border_color_swizzle: return .Device; + case VK_EXT_pageable_device_local_memory: return .Device; + case VK_KHR_maintenance4: return .Device; + case VK_ARM_shader_core_properties: return .Device; + case VK_KHR_shader_subgroup_rotate: return .Device; + case VK_ARM_scheduling_controls: return .Device; + case VK_EXT_image_sliced_view_of_3d: return .Device; + case VK_VALVE_descriptor_set_host_mapping: return .Device; + case VK_EXT_depth_clamp_zero_one: return .Device; + case VK_EXT_non_seamless_cube_map: return .Device; + case VK_ARM_render_pass_striped: return .Device; + case VK_QCOM_fragment_density_map_offset: return .Device; + case VK_NV_copy_memory_indirect: return .Device; + case VK_NV_memory_decompression: return .Device; + case VK_NV_device_generated_commands_compute: return .Device; + case VK_NV_ray_tracing_linear_swept_spheres: return .Device; + case VK_NV_linear_color_attachment: return .Device; + case VK_GOOGLE_surfaceless_query: return .Instance; + case VK_KHR_shader_maximal_reconvergence: return .Device; + case VK_EXT_image_compression_control_swapchain: return .Device; + case VK_QCOM_image_processing: return .Device; + case VK_EXT_nested_command_buffer: return .Device; + case VK_OHOS_external_memory: return .Device; + case VK_EXT_external_memory_acquire_unmodified: return .Device; + case VK_EXT_extended_dynamic_state3: return .Device; + case VK_EXT_subpass_merge_feedback: return .Device; + case VK_LUNARG_direct_driver_loading: return .Instance; + case VK_ARM_tensors: return .Device; + case VK_EXT_shader_module_identifier: return .Device; + case VK_EXT_rasterization_order_attachment_access: return .Device; + case VK_NV_optical_flow: return .Device; + case VK_EXT_legacy_dithering: return .Device; + case VK_EXT_pipeline_protected_access: return .Device; + case VK_ANDROID_external_format_resolve: return .Device; + case VK_KHR_maintenance5: return .Device; + case VK_AMD_anti_lag: return .Device; + case VK_AMDX_dense_geometry_format: return .Device; + case VK_KHR_present_id2: return .Device; + case VK_KHR_present_wait2: return .Device; + case VK_KHR_ray_tracing_position_fetch: return .Device; + case VK_EXT_shader_object: return .Device; + case VK_KHR_pipeline_binary: return .Device; + case VK_QCOM_tile_properties: return .Device; + case VK_SEC_amigo_profiling: return .Device; + case VK_KHR_surface_maintenance1: return .Instance; + case VK_KHR_swapchain_maintenance1: return .Device; + case VK_QCOM_multiview_per_view_viewports: return .Device; + case VK_NV_ray_tracing_invocation_reorder: return .Device; + case VK_NV_cooperative_vector: return .Device; + case VK_NV_extended_sparse_address_space: return .Device; + case VK_EXT_mutable_descriptor_type: return .Device; + case VK_EXT_legacy_vertex_attributes: return .Device; + case VK_EXT_layer_settings: return .Instance; + case VK_ARM_shader_core_builtins: return .Device; + case VK_EXT_pipeline_library_group_handles: return .Device; + case VK_EXT_dynamic_rendering_unused_attachments: return .Device; + case VK_NV_low_latency2: return .Device; + case VK_KHR_cooperative_matrix: return .Device; + case VK_ARM_data_graph: return .Device; + case VK_QCOM_multiview_per_view_render_areas: return .Device; + case VK_KHR_compute_shader_derivatives: return .Device; + case VK_KHR_video_decode_av1: return .Device; + case VK_KHR_video_encode_av1: return .Device; + case VK_KHR_video_decode_vp9: return .Device; + case VK_KHR_video_maintenance1: return .Device; + case VK_NV_per_stage_descriptor_set: return .Device; + case VK_QCOM_image_processing2: return .Device; + case VK_QCOM_filter_cubic_weights: return .Device; + case VK_QCOM_ycbcr_degamma: return .Device; + case VK_QCOM_filter_cubic_clamp: return .Device; + case VK_EXT_attachment_feedback_loop_dynamic_state: return .Device; + case VK_KHR_vertex_attribute_divisor: return .Device; + case VK_KHR_load_store_op_none: return .Device; + case VK_KHR_unified_image_layouts: return .Device; + case VK_KHR_shader_float_controls2: return .Device; + case VK_QNX_external_memory_screen_buffer: return .Device; + case VK_MSFT_layered_driver: return .Device; + case VK_KHR_index_type_uint8: return .Device; + case VK_KHR_line_rasterization: return .Device; + case VK_KHR_calibrated_timestamps: return .Device; + case VK_KHR_shader_expect_assume: return .Device; + case VK_KHR_maintenance6: return .Device; + case VK_NV_descriptor_pool_overallocation: return .Device; + case VK_QCOM_tile_memory_heap: return .Device; + case VK_KHR_copy_memory_indirect: return .Device; + case VK_EXT_memory_decompression: return .Device; + case VK_NV_display_stereo: return .Instance; + case VK_KHR_video_encode_intra_refresh: return .Device; + case VK_KHR_video_encode_quantization_map: return .Device; + case VK_NV_raw_access_chains: return .Device; + case VK_NV_external_compute_queue: return .Device; + case VK_KHR_shader_relaxed_extended_instruction: return .Device; + case VK_NV_command_buffer_inheritance: return .Device; + case VK_KHR_maintenance7: return .Device; + case VK_NV_shader_atomic_float16_vector: return .Device; + case VK_EXT_shader_replicated_composites: return .Device; + case VK_EXT_shader_float8: return .Device; + case VK_NV_ray_tracing_validation: return .Device; + case VK_NV_cluster_acceleration_structure: return .Device; + case VK_NV_partitioned_acceleration_structure: return .Device; + case VK_EXT_device_generated_commands: return .Device; + case VK_KHR_maintenance8: return .Device; + case VK_MESA_image_alignment_control: return .Device; + case VK_KHR_shader_fma: return .Device; + case VK_EXT_ray_tracing_invocation_reorder: return .Device; + case VK_EXT_depth_clamp_control: return .Device; + case VK_KHR_maintenance9: return .Device; + case VK_KHR_video_maintenance2: return .Device; + case VK_OHOS_surface: return .Instance; + case VK_OHOS_native_buffer: return .Device; + case VK_HUAWEI_hdr_vivid: return .Device; + case VK_NV_cooperative_matrix2: return .Device; + case VK_ARM_pipeline_opacity_micromap: return .Device; + case VK_EXT_external_memory_metal: return .Device; + case VK_KHR_depth_clamp_zero_one: return .Device; + case VK_ARM_performance_counters_by_region: return .Device; + case VK_EXT_vertex_attribute_robustness: return .Device; + case VK_ARM_format_pack: return .Device; + case VK_VALVE_fragment_density_map_layered: return .Device; + case VK_KHR_robustness2: return .Device; + case VK_NV_present_metering: return .Device; + case VK_EXT_fragment_density_map_offset: return .Device; + case VK_EXT_zero_initialize_device_memory: return .Device; + case VK_KHR_present_mode_fifo_latest_ready: return .Device; + case VK_EXT_shader_64bit_indexing: return .Device; + case VK_EXT_custom_resolve: return .Device; + case VK_QCOM_data_graph_model: return .Device; + case VK_KHR_maintenance10: return .Device; + case VK_SEC_pipeline_cache_incremental_mode: return .Device; + case VK_EXT_shader_uniform_buffer_unsized_array: return .Device; + default: return default; + } + } + } + + public VulkanApiVersion MinVersion + { + get + { + switch (this) + { + case VK_KHR_surface: return .VK_VERSION_1_0; + case VK_KHR_swapchain: return .VK_VERSION_1_0; + case VK_KHR_display: return .VK_VERSION_1_0; + case VK_KHR_display_swapchain: return .VK_VERSION_1_0; + case VK_KHR_xlib_surface: return .VK_VERSION_1_0; + case VK_KHR_xcb_surface: return .VK_VERSION_1_0; + case VK_KHR_wayland_surface: return .VK_VERSION_1_0; + case VK_KHR_android_surface: return .VK_VERSION_1_0; + case VK_KHR_win32_surface: return .VK_VERSION_1_0; + case VK_EXT_debug_report: return .VK_VERSION_1_0; + case VK_NV_glsl_shader: return .VK_VERSION_1_0; + case VK_EXT_depth_range_unrestricted: return .VK_VERSION_1_0; + case VK_KHR_sampler_mirror_clamp_to_edge: return .VK_VERSION_1_0; + case VK_IMG_filter_cubic: return .VK_VERSION_1_0; + case VK_AMD_rasterization_order: return .VK_VERSION_1_0; + case VK_AMD_shader_trinary_minmax: return .VK_VERSION_1_0; + case VK_AMD_shader_explicit_vertex_parameter: return .VK_VERSION_1_0; + case VK_EXT_debug_marker: return .VK_VERSION_1_0; + case VK_KHR_video_queue: return .VK_VERSION_1_1; + case VK_KHR_video_decode_queue: return .VK_VERSION_1_0; + case VK_AMD_gcn_shader: return .VK_VERSION_1_0; + case VK_NV_dedicated_allocation: return .VK_VERSION_1_0; + case VK_EXT_transform_feedback: return .VK_VERSION_1_0; + case VK_NVX_binary_import: return .VK_VERSION_1_0; + case VK_NVX_image_view_handle: return .VK_VERSION_1_0; + case VK_AMD_draw_indirect_count: return .VK_VERSION_1_0; + case VK_AMD_negative_viewport_height: return .VK_VERSION_1_0; + case VK_AMD_gpu_shader_half_float: return .VK_VERSION_1_0; + case VK_AMD_shader_ballot: return .VK_VERSION_1_0; + case VK_KHR_video_encode_h264: return .VK_VERSION_1_0; + case VK_KHR_video_encode_h265: return .VK_VERSION_1_0; + case VK_KHR_video_decode_h264: return .VK_VERSION_1_0; + case VK_AMD_texture_gather_bias_lod: return .VK_VERSION_1_0; + case VK_AMD_shader_info: return .VK_VERSION_1_0; + case VK_KHR_dynamic_rendering: return .VK_VERSION_1_0; + case VK_AMD_shader_image_load_store_lod: return .VK_VERSION_1_0; + case VK_GGP_stream_descriptor_surface: return .VK_VERSION_1_0; + case VK_NV_corner_sampled_image: return .VK_VERSION_1_0; + case VK_KHR_multiview: return .VK_VERSION_1_0; + case VK_IMG_format_pvrtc: return .VK_VERSION_1_0; + case VK_NV_external_memory_capabilities: return .VK_VERSION_1_0; + case VK_NV_external_memory: return .VK_VERSION_1_0; + case VK_NV_external_memory_win32: return .VK_VERSION_1_0; + case VK_NV_win32_keyed_mutex: return .VK_VERSION_1_0; + case VK_KHR_get_physical_device_properties2: return .VK_VERSION_1_0; + case VK_KHR_device_group: return .VK_VERSION_1_0; + case VK_EXT_validation_flags: return .VK_VERSION_1_0; + case VK_NN_vi_surface: return .VK_VERSION_1_0; + case VK_KHR_shader_draw_parameters: return .VK_VERSION_1_0; + case VK_EXT_shader_subgroup_ballot: return .VK_VERSION_1_0; + case VK_EXT_shader_subgroup_vote: return .VK_VERSION_1_0; + case VK_EXT_texture_compression_astc_hdr: return .VK_VERSION_1_0; + case VK_EXT_astc_decode_mode: return .VK_VERSION_1_0; + case VK_EXT_pipeline_robustness: return .VK_VERSION_1_0; + case VK_KHR_maintenance1: return .VK_VERSION_1_0; + case VK_KHR_device_group_creation: return .VK_VERSION_1_0; + case VK_KHR_external_memory_capabilities: return .VK_VERSION_1_0; + case VK_KHR_external_memory: return .VK_VERSION_1_0; + case VK_KHR_external_memory_win32: return .VK_VERSION_1_0; + case VK_KHR_external_memory_fd: return .VK_VERSION_1_0; + case VK_KHR_win32_keyed_mutex: return .VK_VERSION_1_0; + case VK_KHR_external_semaphore_capabilities: return .VK_VERSION_1_0; + case VK_KHR_external_semaphore: return .VK_VERSION_1_0; + case VK_KHR_external_semaphore_win32: return .VK_VERSION_1_0; + case VK_KHR_external_semaphore_fd: return .VK_VERSION_1_0; + case VK_KHR_push_descriptor: return .VK_VERSION_1_0; + case VK_EXT_conditional_rendering: return .VK_VERSION_1_0; + case VK_KHR_shader_float16_int8: return .VK_VERSION_1_0; + case VK_KHR_16bit_storage: return .VK_VERSION_1_0; + case VK_KHR_incremental_present: return .VK_VERSION_1_0; + case VK_KHR_descriptor_update_template: return .VK_VERSION_1_0; + case VK_NV_clip_space_w_scaling: return .VK_VERSION_1_0; + case VK_EXT_direct_mode_display: return .VK_VERSION_1_0; + case VK_EXT_acquire_xlib_display: return .VK_VERSION_1_0; + case VK_EXT_display_surface_counter: return .VK_VERSION_1_0; + case VK_EXT_display_control: return .VK_VERSION_1_0; + case VK_GOOGLE_display_timing: return .VK_VERSION_1_0; + case VK_NV_sample_mask_override_coverage: return .VK_VERSION_1_0; + case VK_NV_geometry_shader_passthrough: return .VK_VERSION_1_0; + case VK_NV_viewport_array2: return .VK_VERSION_1_0; + case VK_NVX_multiview_per_view_attributes: return .VK_VERSION_1_0; + case VK_NV_viewport_swizzle: return .VK_VERSION_1_0; + case VK_EXT_discard_rectangles: return .VK_VERSION_1_0; + case VK_EXT_conservative_rasterization: return .VK_VERSION_1_0; + case VK_EXT_depth_clip_enable: return .VK_VERSION_1_0; + case VK_EXT_swapchain_colorspace: return .VK_VERSION_1_0; + case VK_EXT_hdr_metadata: return .VK_VERSION_1_0; + case VK_KHR_imageless_framebuffer: return .VK_VERSION_1_0; + case VK_KHR_create_renderpass2: return .VK_VERSION_1_0; + case VK_IMG_relaxed_line_rasterization: return .VK_VERSION_1_0; + case VK_KHR_shared_presentable_image: return .VK_VERSION_1_0; + case VK_KHR_external_fence_capabilities: return .VK_VERSION_1_0; + case VK_KHR_external_fence: return .VK_VERSION_1_0; + case VK_KHR_external_fence_win32: return .VK_VERSION_1_0; + case VK_KHR_external_fence_fd: return .VK_VERSION_1_0; + case VK_KHR_performance_query: return .VK_VERSION_1_0; + case VK_KHR_maintenance2: return .VK_VERSION_1_0; + case VK_KHR_get_surface_capabilities2: return .VK_VERSION_1_0; + case VK_KHR_variable_pointers: return .VK_VERSION_1_0; + case VK_KHR_get_display_properties2: return .VK_VERSION_1_0; + case VK_MVK_ios_surface: return .VK_VERSION_1_0; + case VK_MVK_macos_surface: return .VK_VERSION_1_0; + case VK_EXT_external_memory_dma_buf: return .VK_VERSION_1_0; + case VK_EXT_queue_family_foreign: return .VK_VERSION_1_0; + case VK_KHR_dedicated_allocation: return .VK_VERSION_1_0; + case VK_EXT_debug_utils: return .VK_VERSION_1_0; + case VK_ANDROID_external_memory_android_hardware_buffer: return .VK_VERSION_1_0; + case VK_EXT_sampler_filter_minmax: return .VK_VERSION_1_0; + case VK_KHR_storage_buffer_storage_class: return .VK_VERSION_1_0; + case VK_AMD_gpu_shader_int16: return .VK_VERSION_1_0; + case VK_AMDX_shader_enqueue: return .VK_VERSION_1_0; + case VK_AMD_mixed_attachment_samples: return .VK_VERSION_1_0; + case VK_AMD_shader_fragment_mask: return .VK_VERSION_1_0; + case VK_EXT_inline_uniform_block: return .VK_VERSION_1_0; + case VK_EXT_shader_stencil_export: return .VK_VERSION_1_0; + case VK_KHR_shader_bfloat16: return .VK_VERSION_1_0; + case VK_EXT_sample_locations: return .VK_VERSION_1_0; + case VK_KHR_relaxed_block_layout: return .VK_VERSION_1_0; + case VK_KHR_get_memory_requirements2: return .VK_VERSION_1_0; + case VK_KHR_image_format_list: return .VK_VERSION_1_0; + case VK_EXT_blend_operation_advanced: return .VK_VERSION_1_0; + case VK_NV_fragment_coverage_to_color: return .VK_VERSION_1_0; + case VK_KHR_acceleration_structure: return .VK_VERSION_1_1; + case VK_KHR_ray_tracing_pipeline: return .VK_VERSION_1_0; + case VK_KHR_ray_query: return .VK_VERSION_1_0; + case VK_NV_framebuffer_mixed_samples: return .VK_VERSION_1_0; + case VK_NV_fill_rectangle: return .VK_VERSION_1_0; + case VK_NV_shader_sm_builtins: return .VK_VERSION_1_1; + case VK_EXT_post_depth_coverage: return .VK_VERSION_1_0; + case VK_KHR_sampler_ycbcr_conversion: return .VK_VERSION_1_0; + case VK_KHR_bind_memory2: return .VK_VERSION_1_0; + case VK_EXT_image_drm_format_modifier: return .VK_VERSION_1_0; + case VK_EXT_validation_cache: return .VK_VERSION_1_0; + case VK_EXT_descriptor_indexing: return .VK_VERSION_1_0; + case VK_EXT_shader_viewport_index_layer: return .VK_VERSION_1_0; + case VK_KHR_portability_subset: return .VK_VERSION_1_0; + case VK_NV_shading_rate_image: return .VK_VERSION_1_0; + case VK_NV_ray_tracing: return .VK_VERSION_1_0; + case VK_NV_representative_fragment_test: return .VK_VERSION_1_0; + case VK_KHR_maintenance3: return .VK_VERSION_1_0; + case VK_KHR_draw_indirect_count: return .VK_VERSION_1_0; + case VK_EXT_filter_cubic: return .VK_VERSION_1_0; + case VK_QCOM_render_pass_shader_resolve: return .VK_VERSION_1_0; + case VK_EXT_global_priority: return .VK_VERSION_1_0; + case VK_KHR_shader_subgroup_extended_types: return .VK_VERSION_1_1; + case VK_KHR_8bit_storage: return .VK_VERSION_1_0; + case VK_EXT_external_memory_host: return .VK_VERSION_1_0; + case VK_AMD_buffer_marker: return .VK_VERSION_1_0; + case VK_KHR_shader_atomic_int64: return .VK_VERSION_1_0; + case VK_KHR_shader_clock: return .VK_VERSION_1_0; + case VK_AMD_pipeline_compiler_control: return .VK_VERSION_1_0; + case VK_EXT_calibrated_timestamps: return .VK_VERSION_1_0; + case VK_AMD_shader_core_properties: return .VK_VERSION_1_0; + case VK_KHR_video_decode_h265: return .VK_VERSION_1_0; + case VK_KHR_global_priority: return .VK_VERSION_1_0; + case VK_AMD_memory_overallocation_behavior: return .VK_VERSION_1_0; + case VK_EXT_vertex_attribute_divisor: return .VK_VERSION_1_0; + case VK_GGP_frame_token: return .VK_VERSION_1_0; + case VK_EXT_pipeline_creation_feedback: return .VK_VERSION_1_0; + case VK_KHR_driver_properties: return .VK_VERSION_1_0; + case VK_KHR_shader_float_controls: return .VK_VERSION_1_0; + case VK_NV_shader_subgroup_partitioned: return .VK_VERSION_1_1; + case VK_KHR_depth_stencil_resolve: return .VK_VERSION_1_0; + case VK_KHR_swapchain_mutable_format: return .VK_VERSION_1_0; + case VK_NV_compute_shader_derivatives: return .VK_VERSION_1_0; + case VK_NV_mesh_shader: return .VK_VERSION_1_0; + case VK_NV_fragment_shader_barycentric: return .VK_VERSION_1_0; + case VK_NV_shader_image_footprint: return .VK_VERSION_1_0; + case VK_NV_scissor_exclusive: return .VK_VERSION_1_0; + case VK_NV_device_diagnostic_checkpoints: return .VK_VERSION_1_0; + case VK_KHR_timeline_semaphore: return .VK_VERSION_1_0; + case VK_EXT_present_timing: return .VK_VERSION_1_0; + case VK_INTEL_shader_integer_functions2: return .VK_VERSION_1_0; + case VK_INTEL_performance_query: return .VK_VERSION_1_0; + case VK_KHR_vulkan_memory_model: return .VK_VERSION_1_0; + case VK_EXT_pci_bus_info: return .VK_VERSION_1_0; + case VK_AMD_display_native_hdr: return .VK_VERSION_1_0; + case VK_FUCHSIA_imagepipe_surface: return .VK_VERSION_1_0; + case VK_KHR_shader_terminate_invocation: return .VK_VERSION_1_0; + case VK_EXT_metal_surface: return .VK_VERSION_1_0; + case VK_EXT_fragment_density_map: return .VK_VERSION_1_0; + case VK_EXT_scalar_block_layout: return .VK_VERSION_1_0; + case VK_GOOGLE_hlsl_functionality1: return .VK_VERSION_1_0; + case VK_GOOGLE_decorate_string: return .VK_VERSION_1_0; + case VK_EXT_subgroup_size_control: return .VK_VERSION_1_1; + case VK_KHR_fragment_shading_rate: return .VK_VERSION_1_0; + case VK_AMD_shader_core_properties2: return .VK_VERSION_1_0; + case VK_AMD_device_coherent_memory: return .VK_VERSION_1_0; + case VK_KHR_dynamic_rendering_local_read: return .VK_VERSION_1_0; + case VK_EXT_shader_image_atomic_int64: return .VK_VERSION_1_0; + case VK_KHR_shader_quad_control: return .VK_VERSION_1_1; + case VK_KHR_spirv_1_4: return .VK_VERSION_1_1; + case VK_EXT_memory_budget: return .VK_VERSION_1_0; + case VK_EXT_memory_priority: return .VK_VERSION_1_0; + case VK_KHR_surface_protected_capabilities: return .VK_VERSION_1_1; + case VK_NV_dedicated_allocation_image_aliasing: return .VK_VERSION_1_0; + case VK_KHR_separate_depth_stencil_layouts: return .VK_VERSION_1_0; + case VK_EXT_buffer_device_address: return .VK_VERSION_1_0; + case VK_EXT_tooling_info: return .VK_VERSION_1_0; + case VK_EXT_separate_stencil_usage: return .VK_VERSION_1_0; + case VK_EXT_validation_features: return .VK_VERSION_1_0; + case VK_KHR_present_wait: return .VK_VERSION_1_0; + case VK_NV_cooperative_matrix: return .VK_VERSION_1_0; + case VK_NV_coverage_reduction_mode: return .VK_VERSION_1_0; + case VK_EXT_fragment_shader_interlock: return .VK_VERSION_1_0; + case VK_EXT_ycbcr_image_arrays: return .VK_VERSION_1_0; + case VK_KHR_uniform_buffer_standard_layout: return .VK_VERSION_1_0; + case VK_EXT_provoking_vertex: return .VK_VERSION_1_0; + case VK_EXT_full_screen_exclusive: return .VK_VERSION_1_0; + case VK_EXT_headless_surface: return .VK_VERSION_1_0; + case VK_KHR_buffer_device_address: return .VK_VERSION_1_0; + case VK_EXT_line_rasterization: return .VK_VERSION_1_0; + case VK_EXT_shader_atomic_float: return .VK_VERSION_1_0; + case VK_EXT_host_query_reset: return .VK_VERSION_1_0; + case VK_EXT_index_type_uint8: return .VK_VERSION_1_0; + case VK_EXT_extended_dynamic_state: return .VK_VERSION_1_0; + case VK_KHR_deferred_host_operations: return .VK_VERSION_1_0; + case VK_KHR_pipeline_executable_properties: return .VK_VERSION_1_0; + case VK_EXT_host_image_copy: return .VK_VERSION_1_0; + case VK_KHR_map_memory2: return .VK_VERSION_1_0; + case VK_EXT_map_memory_placed: return .VK_VERSION_1_0; + case VK_EXT_shader_atomic_float2: return .VK_VERSION_1_0; + case VK_EXT_surface_maintenance1: return .VK_VERSION_1_0; + case VK_EXT_swapchain_maintenance1: return .VK_VERSION_1_0; + case VK_EXT_shader_demote_to_helper_invocation: return .VK_VERSION_1_0; + case VK_NV_device_generated_commands: return .VK_VERSION_1_1; + case VK_NV_inherited_viewport_scissor: return .VK_VERSION_1_0; + case VK_KHR_shader_integer_dot_product: return .VK_VERSION_1_0; + case VK_EXT_texel_buffer_alignment: return .VK_VERSION_1_0; + case VK_QCOM_render_pass_transform: return .VK_VERSION_1_0; + case VK_EXT_depth_bias_control: return .VK_VERSION_1_0; + case VK_EXT_device_memory_report: return .VK_VERSION_1_0; + case VK_EXT_acquire_drm_display: return .VK_VERSION_1_0; + case VK_EXT_robustness2: return .VK_VERSION_1_0; + case VK_EXT_custom_border_color: return .VK_VERSION_1_0; + case VK_GOOGLE_user_type: return .VK_VERSION_1_0; + case VK_KHR_pipeline_library: return .VK_VERSION_1_0; + case VK_NV_present_barrier: return .VK_VERSION_1_0; + case VK_KHR_shader_non_semantic_info: return .VK_VERSION_1_0; + case VK_KHR_present_id: return .VK_VERSION_1_0; + case VK_EXT_private_data: return .VK_VERSION_1_0; + case VK_EXT_pipeline_creation_cache_control: return .VK_VERSION_1_0; + case VK_KHR_video_encode_queue: return .VK_VERSION_1_0; + case VK_NV_device_diagnostics_config: return .VK_VERSION_1_0; + case VK_QCOM_render_pass_store_ops: return .VK_VERSION_1_0; + case VK_NV_cuda_kernel_launch: return .VK_VERSION_1_0; + case VK_QCOM_tile_shading: return .VK_VERSION_1_0; + case VK_NV_low_latency: return .VK_VERSION_1_0; + case VK_EXT_metal_objects: return .VK_VERSION_1_0; + case VK_KHR_synchronization2: return .VK_VERSION_1_0; + case VK_EXT_descriptor_buffer: return .VK_VERSION_1_0; + case VK_EXT_graphics_pipeline_library: return .VK_VERSION_1_0; + case VK_AMD_shader_early_and_late_fragment_tests: return .VK_VERSION_1_0; + case VK_KHR_fragment_shader_barycentric: return .VK_VERSION_1_0; + case VK_KHR_shader_subgroup_uniform_control_flow: return .VK_VERSION_1_1; + case VK_KHR_zero_initialize_workgroup_memory: return .VK_VERSION_1_0; + case VK_NV_fragment_shading_rate_enums: return .VK_VERSION_1_0; + case VK_NV_ray_tracing_motion_blur: return .VK_VERSION_1_0; + case VK_EXT_mesh_shader: return .VK_VERSION_1_0; + case VK_EXT_ycbcr_2plane_444_formats: return .VK_VERSION_1_0; + case VK_EXT_fragment_density_map2: return .VK_VERSION_1_0; + case VK_QCOM_rotated_copy_commands: return .VK_VERSION_1_0; + case VK_EXT_image_robustness: return .VK_VERSION_1_0; + case VK_KHR_workgroup_memory_explicit_layout: return .VK_VERSION_1_0; + case VK_KHR_copy_commands2: return .VK_VERSION_1_0; + case VK_EXT_image_compression_control: return .VK_VERSION_1_0; + case VK_EXT_attachment_feedback_loop_layout: return .VK_VERSION_1_0; + case VK_EXT_4444_formats: return .VK_VERSION_1_0; + case VK_EXT_device_fault: return .VK_VERSION_1_0; + case VK_ARM_rasterization_order_attachment_access: return .VK_VERSION_1_0; + case VK_EXT_rgba10x6_formats: return .VK_VERSION_1_0; + case VK_NV_acquire_winrt_display: return .VK_VERSION_1_0; + case VK_EXT_directfb_surface: return .VK_VERSION_1_0; + case VK_VALVE_mutable_descriptor_type: return .VK_VERSION_1_0; + case VK_EXT_vertex_input_dynamic_state: return .VK_VERSION_1_0; + case VK_EXT_physical_device_drm: return .VK_VERSION_1_0; + case VK_EXT_device_address_binding_report: return .VK_VERSION_1_0; + case VK_EXT_depth_clip_control: return .VK_VERSION_1_0; + case VK_EXT_primitive_topology_list_restart: return .VK_VERSION_1_0; + case VK_KHR_format_feature_flags2: return .VK_VERSION_1_0; + case VK_EXT_present_mode_fifo_latest_ready: return .VK_VERSION_1_0; + case VK_FUCHSIA_external_memory: return .VK_VERSION_1_0; + case VK_FUCHSIA_external_semaphore: return .VK_VERSION_1_0; + case VK_FUCHSIA_buffer_collection: return .VK_VERSION_1_0; + case VK_HUAWEI_subpass_shading: return .VK_VERSION_1_0; + case VK_HUAWEI_invocation_mask: return .VK_VERSION_1_0; + case VK_NV_external_memory_rdma: return .VK_VERSION_1_0; + case VK_EXT_pipeline_properties: return .VK_VERSION_1_0; + case VK_EXT_frame_boundary: return .VK_VERSION_1_0; + case VK_EXT_multisampled_render_to_single_sampled: return .VK_VERSION_1_0; + case VK_EXT_extended_dynamic_state2: return .VK_VERSION_1_0; + case VK_QNX_screen_surface: return .VK_VERSION_1_0; + case VK_EXT_color_write_enable: return .VK_VERSION_1_0; + case VK_EXT_primitives_generated_query: return .VK_VERSION_1_0; + case VK_KHR_ray_tracing_maintenance1: return .VK_VERSION_1_0; + case VK_KHR_shader_untyped_pointers: return .VK_VERSION_1_0; + case VK_EXT_global_priority_query: return .VK_VERSION_1_0; + case VK_VALVE_video_encode_rgb_conversion: return .VK_VERSION_1_0; + case VK_EXT_image_view_min_lod: return .VK_VERSION_1_0; + case VK_EXT_multi_draw: return .VK_VERSION_1_0; + case VK_EXT_image_2d_view_of_3d: return .VK_VERSION_1_0; + case VK_KHR_portability_enumeration: return .VK_VERSION_1_0; + case VK_EXT_shader_tile_image: return .VK_VERSION_1_3; + case VK_EXT_opacity_micromap: return .VK_VERSION_1_0; + case VK_NV_displacement_micromap: return .VK_VERSION_1_0; + case VK_EXT_load_store_op_none: return .VK_VERSION_1_0; + case VK_HUAWEI_cluster_culling_shader: return .VK_VERSION_1_0; + case VK_EXT_border_color_swizzle: return .VK_VERSION_1_0; + case VK_EXT_pageable_device_local_memory: return .VK_VERSION_1_0; + case VK_KHR_maintenance4: return .VK_VERSION_1_1; + case VK_ARM_shader_core_properties: return .VK_VERSION_1_1; + case VK_KHR_shader_subgroup_rotate: return .VK_VERSION_1_0; + case VK_ARM_scheduling_controls: return .VK_VERSION_1_0; + case VK_EXT_image_sliced_view_of_3d: return .VK_VERSION_1_0; + case VK_VALVE_descriptor_set_host_mapping: return .VK_VERSION_1_0; + case VK_EXT_depth_clamp_zero_one: return .VK_VERSION_1_0; + case VK_EXT_non_seamless_cube_map: return .VK_VERSION_1_0; + case VK_ARM_render_pass_striped: return .VK_VERSION_1_0; + case VK_QCOM_fragment_density_map_offset: return .VK_VERSION_1_0; + case VK_NV_copy_memory_indirect: return .VK_VERSION_1_0; + case VK_NV_memory_decompression: return .VK_VERSION_1_0; + case VK_NV_device_generated_commands_compute: return .VK_VERSION_1_0; + case VK_NV_ray_tracing_linear_swept_spheres: return .VK_VERSION_1_0; + case VK_NV_linear_color_attachment: return .VK_VERSION_1_0; + case VK_GOOGLE_surfaceless_query: return .VK_VERSION_1_0; + case VK_KHR_shader_maximal_reconvergence: return .VK_VERSION_1_1; + case VK_EXT_image_compression_control_swapchain: return .VK_VERSION_1_0; + case VK_QCOM_image_processing: return .VK_VERSION_1_0; + case VK_EXT_nested_command_buffer: return .VK_VERSION_1_0; + case VK_OHOS_external_memory: return .VK_VERSION_1_0; + case VK_EXT_external_memory_acquire_unmodified: return .VK_VERSION_1_0; + case VK_EXT_extended_dynamic_state3: return .VK_VERSION_1_0; + case VK_EXT_subpass_merge_feedback: return .VK_VERSION_1_0; + case VK_LUNARG_direct_driver_loading: return .VK_VERSION_1_0; + case VK_ARM_tensors: return .VK_VERSION_1_3; + case VK_EXT_shader_module_identifier: return .VK_VERSION_1_0; + case VK_EXT_rasterization_order_attachment_access: return .VK_VERSION_1_0; + case VK_NV_optical_flow: return .VK_VERSION_1_0; + case VK_EXT_legacy_dithering: return .VK_VERSION_1_0; + case VK_EXT_pipeline_protected_access: return .VK_VERSION_1_0; + case VK_ANDROID_external_format_resolve: return .VK_VERSION_1_0; + case VK_KHR_maintenance5: return .VK_VERSION_1_1; + case VK_AMD_anti_lag: return .VK_VERSION_1_0; + case VK_AMDX_dense_geometry_format: return .VK_VERSION_1_0; + case VK_KHR_present_id2: return .VK_VERSION_1_0; + case VK_KHR_present_wait2: return .VK_VERSION_1_0; + case VK_KHR_ray_tracing_position_fetch: return .VK_VERSION_1_0; + case VK_EXT_shader_object: return .VK_VERSION_1_0; + case VK_KHR_pipeline_binary: return .VK_VERSION_1_0; + case VK_QCOM_tile_properties: return .VK_VERSION_1_0; + case VK_SEC_amigo_profiling: return .VK_VERSION_1_0; + case VK_KHR_surface_maintenance1: return .VK_VERSION_1_0; + case VK_KHR_swapchain_maintenance1: return .VK_VERSION_1_0; + case VK_QCOM_multiview_per_view_viewports: return .VK_VERSION_1_0; + case VK_NV_ray_tracing_invocation_reorder: return .VK_VERSION_1_0; + case VK_NV_cooperative_vector: return .VK_VERSION_1_0; + case VK_NV_extended_sparse_address_space: return .VK_VERSION_1_0; + case VK_EXT_mutable_descriptor_type: return .VK_VERSION_1_0; + case VK_EXT_legacy_vertex_attributes: return .VK_VERSION_1_0; + case VK_EXT_layer_settings: return .VK_VERSION_1_0; + case VK_ARM_shader_core_builtins: return .VK_VERSION_1_0; + case VK_EXT_pipeline_library_group_handles: return .VK_VERSION_1_0; + case VK_EXT_dynamic_rendering_unused_attachments: return .VK_VERSION_1_0; + case VK_NV_low_latency2: return .VK_VERSION_1_0; + case VK_KHR_cooperative_matrix: return .VK_VERSION_1_0; + case VK_ARM_data_graph: return .VK_VERSION_1_3; + case VK_QCOM_multiview_per_view_render_areas: return .VK_VERSION_1_0; + case VK_KHR_compute_shader_derivatives: return .VK_VERSION_1_0; + case VK_KHR_video_decode_av1: return .VK_VERSION_1_0; + case VK_KHR_video_encode_av1: return .VK_VERSION_1_0; + case VK_KHR_video_decode_vp9: return .VK_VERSION_1_0; + case VK_KHR_video_maintenance1: return .VK_VERSION_1_0; + case VK_NV_per_stage_descriptor_set: return .VK_VERSION_1_0; + case VK_QCOM_image_processing2: return .VK_VERSION_1_0; + case VK_QCOM_filter_cubic_weights: return .VK_VERSION_1_0; + case VK_QCOM_ycbcr_degamma: return .VK_VERSION_1_0; + case VK_QCOM_filter_cubic_clamp: return .VK_VERSION_1_0; + case VK_EXT_attachment_feedback_loop_dynamic_state: return .VK_VERSION_1_0; + case VK_KHR_vertex_attribute_divisor: return .VK_VERSION_1_0; + case VK_KHR_load_store_op_none: return .VK_VERSION_1_0; + case VK_KHR_unified_image_layouts: return .VK_VERSION_1_0; + case VK_KHR_shader_float_controls2: return .VK_VERSION_1_1; + case VK_QNX_external_memory_screen_buffer: return .VK_VERSION_1_0; + case VK_MSFT_layered_driver: return .VK_VERSION_1_0; + case VK_KHR_index_type_uint8: return .VK_VERSION_1_0; + case VK_KHR_line_rasterization: return .VK_VERSION_1_0; + case VK_KHR_calibrated_timestamps: return .VK_VERSION_1_0; + case VK_KHR_shader_expect_assume: return .VK_VERSION_1_0; + case VK_KHR_maintenance6: return .VK_VERSION_1_1; + case VK_NV_descriptor_pool_overallocation: return .VK_VERSION_1_1; + case VK_QCOM_tile_memory_heap: return .VK_VERSION_1_0; + case VK_KHR_copy_memory_indirect: return .VK_VERSION_1_0; + case VK_EXT_memory_decompression: return .VK_VERSION_1_0; + case VK_NV_display_stereo: return .VK_VERSION_1_0; + case VK_KHR_video_encode_intra_refresh: return .VK_VERSION_1_0; + case VK_KHR_video_encode_quantization_map: return .VK_VERSION_1_0; + case VK_NV_raw_access_chains: return .VK_VERSION_1_0; + case VK_NV_external_compute_queue: return .VK_VERSION_1_0; + case VK_KHR_shader_relaxed_extended_instruction: return .VK_VERSION_1_0; + case VK_NV_command_buffer_inheritance: return .VK_VERSION_1_0; + case VK_KHR_maintenance7: return .VK_VERSION_1_1; + case VK_NV_shader_atomic_float16_vector: return .VK_VERSION_1_0; + case VK_EXT_shader_replicated_composites: return .VK_VERSION_1_0; + case VK_EXT_shader_float8: return .VK_VERSION_1_0; + case VK_NV_ray_tracing_validation: return .VK_VERSION_1_0; + case VK_NV_cluster_acceleration_structure: return .VK_VERSION_1_0; + case VK_NV_partitioned_acceleration_structure: return .VK_VERSION_1_0; + case VK_EXT_device_generated_commands: return .VK_VERSION_1_0; + case VK_KHR_maintenance8: return .VK_VERSION_1_1; + case VK_MESA_image_alignment_control: return .VK_VERSION_1_0; + case VK_KHR_shader_fma: return .VK_VERSION_1_0; + case VK_EXT_ray_tracing_invocation_reorder: return .VK_VERSION_1_0; + case VK_EXT_depth_clamp_control: return .VK_VERSION_1_0; + case VK_KHR_maintenance9: return .VK_VERSION_1_0; + case VK_KHR_video_maintenance2: return .VK_VERSION_1_0; + case VK_OHOS_surface: return .VK_VERSION_1_0; + case VK_OHOS_native_buffer: return .VK_VERSION_1_0; + case VK_HUAWEI_hdr_vivid: return .VK_VERSION_1_0; + case VK_NV_cooperative_matrix2: return .VK_VERSION_1_0; + case VK_ARM_pipeline_opacity_micromap: return .VK_VERSION_1_0; + case VK_EXT_external_memory_metal: return .VK_VERSION_1_0; + case VK_KHR_depth_clamp_zero_one: return .VK_VERSION_1_0; + case VK_ARM_performance_counters_by_region: return .VK_VERSION_1_0; + case VK_EXT_vertex_attribute_robustness: return .VK_VERSION_1_0; + case VK_ARM_format_pack: return .VK_VERSION_1_0; + case VK_VALVE_fragment_density_map_layered: return .VK_VERSION_1_0; + case VK_KHR_robustness2: return .VK_VERSION_1_0; + case VK_NV_present_metering: return .VK_VERSION_1_0; + case VK_EXT_fragment_density_map_offset: return .VK_VERSION_1_0; + case VK_EXT_zero_initialize_device_memory: return .VK_VERSION_1_0; + case VK_KHR_present_mode_fifo_latest_ready: return .VK_VERSION_1_0; + case VK_EXT_shader_64bit_indexing: return .VK_VERSION_1_0; + case VK_EXT_custom_resolve: return .VK_VERSION_1_0; + case VK_QCOM_data_graph_model: return .VK_VERSION_1_0; + case VK_KHR_maintenance10: return .VK_VERSION_1_0; + case VK_SEC_pipeline_cache_incremental_mode: return .VK_VERSION_1_0; + case VK_EXT_shader_uniform_buffer_unsized_array: return .VK_VERSION_1_0; + default: return default; + } + } + } + + public VulkanApiVersion PromotedTo + { + get + { + switch (this) + { + case VK_KHR_sampler_mirror_clamp_to_edge: return .VK_VERSION_1_2; + case VK_KHR_dynamic_rendering: return .VK_VERSION_1_3; + case VK_KHR_multiview: return .VK_VERSION_1_1; + case VK_KHR_get_physical_device_properties2: return .VK_VERSION_1_1; + case VK_KHR_device_group: return .VK_VERSION_1_1; + case VK_KHR_shader_draw_parameters: return .VK_VERSION_1_1; + case VK_EXT_texture_compression_astc_hdr: return .VK_VERSION_1_3; + case VK_EXT_pipeline_robustness: return .VK_VERSION_1_4; + case VK_KHR_maintenance1: return .VK_VERSION_1_1; + case VK_KHR_device_group_creation: return .VK_VERSION_1_1; + case VK_KHR_external_memory_capabilities: return .VK_VERSION_1_1; + case VK_KHR_external_memory: return .VK_VERSION_1_1; + case VK_KHR_external_semaphore_capabilities: return .VK_VERSION_1_1; + case VK_KHR_external_semaphore: return .VK_VERSION_1_1; + case VK_KHR_push_descriptor: return .VK_VERSION_1_4; + case VK_KHR_shader_float16_int8: return .VK_VERSION_1_2; + case VK_KHR_16bit_storage: return .VK_VERSION_1_1; + case VK_KHR_descriptor_update_template: return .VK_VERSION_1_1; + case VK_KHR_imageless_framebuffer: return .VK_VERSION_1_2; + case VK_KHR_create_renderpass2: return .VK_VERSION_1_2; + case VK_KHR_external_fence_capabilities: return .VK_VERSION_1_1; + case VK_KHR_external_fence: return .VK_VERSION_1_1; + case VK_KHR_maintenance2: return .VK_VERSION_1_1; + case VK_KHR_variable_pointers: return .VK_VERSION_1_1; + case VK_KHR_dedicated_allocation: return .VK_VERSION_1_1; + case VK_EXT_sampler_filter_minmax: return .VK_VERSION_1_2; + case VK_KHR_storage_buffer_storage_class: return .VK_VERSION_1_1; + case VK_EXT_inline_uniform_block: return .VK_VERSION_1_3; + case VK_KHR_relaxed_block_layout: return .VK_VERSION_1_1; + case VK_KHR_get_memory_requirements2: return .VK_VERSION_1_1; + case VK_KHR_image_format_list: return .VK_VERSION_1_2; + case VK_KHR_sampler_ycbcr_conversion: return .VK_VERSION_1_1; + case VK_KHR_bind_memory2: return .VK_VERSION_1_1; + case VK_EXT_descriptor_indexing: return .VK_VERSION_1_2; + case VK_EXT_shader_viewport_index_layer: return .VK_VERSION_1_2; + case VK_KHR_maintenance3: return .VK_VERSION_1_1; + case VK_KHR_draw_indirect_count: return .VK_VERSION_1_2; + case VK_KHR_shader_subgroup_extended_types: return .VK_VERSION_1_2; + case VK_KHR_8bit_storage: return .VK_VERSION_1_2; + case VK_KHR_shader_atomic_int64: return .VK_VERSION_1_2; + case VK_KHR_global_priority: return .VK_VERSION_1_4; + case VK_EXT_pipeline_creation_feedback: return .VK_VERSION_1_3; + case VK_KHR_driver_properties: return .VK_VERSION_1_2; + case VK_KHR_shader_float_controls: return .VK_VERSION_1_2; + case VK_KHR_depth_stencil_resolve: return .VK_VERSION_1_2; + case VK_KHR_timeline_semaphore: return .VK_VERSION_1_2; + case VK_KHR_vulkan_memory_model: return .VK_VERSION_1_2; + case VK_KHR_shader_terminate_invocation: return .VK_VERSION_1_3; + case VK_EXT_scalar_block_layout: return .VK_VERSION_1_2; + case VK_EXT_subgroup_size_control: return .VK_VERSION_1_3; + case VK_KHR_dynamic_rendering_local_read: return .VK_VERSION_1_4; + case VK_KHR_spirv_1_4: return .VK_VERSION_1_2; + case VK_KHR_separate_depth_stencil_layouts: return .VK_VERSION_1_2; + case VK_EXT_tooling_info: return .VK_VERSION_1_3; + case VK_EXT_separate_stencil_usage: return .VK_VERSION_1_2; + case VK_KHR_uniform_buffer_standard_layout: return .VK_VERSION_1_2; + case VK_KHR_buffer_device_address: return .VK_VERSION_1_2; + case VK_EXT_host_query_reset: return .VK_VERSION_1_2; + case VK_EXT_extended_dynamic_state: return .VK_VERSION_1_3; + case VK_EXT_host_image_copy: return .VK_VERSION_1_4; + case VK_KHR_map_memory2: return .VK_VERSION_1_4; + case VK_EXT_shader_demote_to_helper_invocation: return .VK_VERSION_1_3; + case VK_KHR_shader_integer_dot_product: return .VK_VERSION_1_3; + case VK_EXT_texel_buffer_alignment: return .VK_VERSION_1_3; + case VK_KHR_shader_non_semantic_info: return .VK_VERSION_1_3; + case VK_EXT_private_data: return .VK_VERSION_1_3; + case VK_EXT_pipeline_creation_cache_control: return .VK_VERSION_1_3; + case VK_KHR_synchronization2: return .VK_VERSION_1_3; + case VK_KHR_zero_initialize_workgroup_memory: return .VK_VERSION_1_3; + case VK_EXT_ycbcr_2plane_444_formats: return .VK_VERSION_1_3; + case VK_EXT_image_robustness: return .VK_VERSION_1_3; + case VK_KHR_copy_commands2: return .VK_VERSION_1_3; + case VK_EXT_4444_formats: return .VK_VERSION_1_3; + case VK_KHR_format_feature_flags2: return .VK_VERSION_1_3; + case VK_EXT_extended_dynamic_state2: return .VK_VERSION_1_3; + case VK_KHR_maintenance4: return .VK_VERSION_1_3; + case VK_KHR_shader_subgroup_rotate: return .VK_VERSION_1_4; + case VK_EXT_pipeline_protected_access: return .VK_VERSION_1_4; + case VK_KHR_maintenance5: return .VK_VERSION_1_4; + case VK_KHR_vertex_attribute_divisor: return .VK_VERSION_1_4; + case VK_KHR_load_store_op_none: return .VK_VERSION_1_4; + case VK_KHR_shader_float_controls2: return .VK_VERSION_1_4; + case VK_KHR_index_type_uint8: return .VK_VERSION_1_4; + case VK_KHR_line_rasterization: return .VK_VERSION_1_4; + case VK_KHR_shader_expect_assume: return .VK_VERSION_1_4; + case VK_KHR_maintenance6: return .VK_VERSION_1_4; + default: return default; + } + } + } + + public Span Dependencies + { + get + { + switch (this) + { + case VK_KHR_swapchain: return Self[?](VK_KHR_surface); + case VK_KHR_display: return Self[?](VK_KHR_surface); + case VK_KHR_display_swapchain: return Self[?](VK_KHR_swapchain, VK_KHR_display); + case VK_KHR_xlib_surface: return Self[?](VK_KHR_surface); + case VK_KHR_xcb_surface: return Self[?](VK_KHR_surface); + case VK_KHR_wayland_surface: return Self[?](VK_KHR_surface); + case VK_KHR_android_surface: return Self[?](VK_KHR_surface); + case VK_KHR_win32_surface: return Self[?](VK_KHR_surface); + case VK_EXT_debug_marker: return Self[?](VK_EXT_debug_report); + case VK_KHR_video_queue: return Self[?](VK_KHR_synchronization2); + case VK_KHR_video_decode_queue: return Self[?](VK_KHR_video_queue, VK_KHR_synchronization2); + case VK_EXT_transform_feedback: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_video_encode_h264: return Self[?](VK_KHR_video_encode_queue); + case VK_KHR_video_encode_h265: return Self[?](VK_KHR_video_encode_queue); + case VK_KHR_video_decode_h264: return Self[?](VK_KHR_video_decode_queue); + case VK_AMD_texture_gather_bias_lod: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_dynamic_rendering: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_depth_stencil_resolve); + case VK_GGP_stream_descriptor_surface: return Self[?](VK_KHR_surface); + case VK_NV_corner_sampled_image: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_multiview: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_external_memory: return Self[?](VK_NV_external_memory_capabilities); + case VK_NV_external_memory_win32: return Self[?](VK_NV_external_memory); + case VK_NV_win32_keyed_mutex: return Self[?](VK_NV_external_memory_win32); + case VK_KHR_device_group: return Self[?](VK_KHR_device_group_creation); + case VK_NN_vi_surface: return Self[?](VK_KHR_surface); + case VK_EXT_texture_compression_astc_hdr: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_astc_decode_mode: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_pipeline_robustness: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_external_memory_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_external_memory: return Self[?](VK_KHR_external_memory_capabilities); + case VK_KHR_external_memory_win32: return Self[?](VK_KHR_external_memory); + case VK_KHR_external_memory_fd: return Self[?](VK_KHR_external_memory); + case VK_KHR_win32_keyed_mutex: return Self[?](VK_KHR_external_memory_win32); + case VK_KHR_external_semaphore_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_external_semaphore: return Self[?](VK_KHR_external_semaphore_capabilities); + case VK_KHR_external_semaphore_win32: return Self[?](VK_KHR_external_semaphore); + case VK_KHR_external_semaphore_fd: return Self[?](VK_KHR_external_semaphore); + case VK_KHR_push_descriptor: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_conditional_rendering: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_float16_int8: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_16bit_storage: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); + case VK_KHR_incremental_present: return Self[?](VK_KHR_swapchain); + case VK_EXT_direct_mode_display: return Self[?](VK_KHR_display); + case VK_EXT_acquire_xlib_display: return Self[?](VK_EXT_direct_mode_display); + case VK_EXT_display_surface_counter: return Self[?](VK_KHR_display); + case VK_EXT_display_control: return Self[?](VK_EXT_display_surface_counter, VK_KHR_swapchain); + case VK_GOOGLE_display_timing: return Self[?](VK_KHR_swapchain); + case VK_NVX_multiview_per_view_attributes: return Self[?](VK_KHR_multiview); + case VK_EXT_discard_rectangles: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_conservative_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_depth_clip_enable: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_swapchain_colorspace: return Self[?](VK_KHR_surface); + case VK_EXT_hdr_metadata: return Self[?](VK_KHR_swapchain); + case VK_KHR_imageless_framebuffer: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance2, VK_KHR_image_format_list); + case VK_KHR_create_renderpass2: return Self[?](VK_KHR_multiview, VK_KHR_maintenance2); + case VK_IMG_relaxed_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shared_presentable_image: return Self[?](VK_KHR_swapchain, VK_KHR_get_surface_capabilities2, VK_KHR_get_physical_device_properties2); + case VK_KHR_external_fence_capabilities: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_external_fence: return Self[?](VK_KHR_external_fence_capabilities); + case VK_KHR_external_fence_win32: return Self[?](VK_KHR_external_fence); + case VK_KHR_external_fence_fd: return Self[?](VK_KHR_external_fence); + case VK_KHR_performance_query: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_get_surface_capabilities2: return Self[?](VK_KHR_surface); + case VK_KHR_variable_pointers: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); + case VK_KHR_get_display_properties2: return Self[?](VK_KHR_display); + case VK_MVK_ios_surface: return Self[?](VK_KHR_surface); + case VK_MVK_macos_surface: return Self[?](VK_KHR_surface); + case VK_EXT_external_memory_dma_buf: return Self[?](VK_KHR_external_memory_fd); + case VK_EXT_queue_family_foreign: return Self[?](VK_KHR_external_memory); + case VK_KHR_dedicated_allocation: return Self[?](VK_KHR_get_memory_requirements2); + case VK_ANDROID_external_memory_android_hardware_buffer: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); + case VK_EXT_sampler_filter_minmax: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_AMDX_shader_enqueue: return Self[?](VK_KHR_synchronization2, VK_KHR_spirv_1_4, VK_EXT_extended_dynamic_state, VK_KHR_maintenance5, VK_KHR_pipeline_library); + case VK_EXT_inline_uniform_block: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance1); + case VK_KHR_shader_bfloat16: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_sample_locations: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_blend_operation_advanced: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_acceleration_structure: return Self[?](VK_EXT_descriptor_indexing, VK_KHR_buffer_device_address, VK_KHR_deferred_host_operations); + case VK_KHR_ray_tracing_pipeline: return Self[?](VK_KHR_spirv_1_4, VK_KHR_acceleration_structure); + case VK_KHR_ray_query: return Self[?](VK_KHR_spirv_1_4, VK_KHR_acceleration_structure); + case VK_KHR_sampler_ycbcr_conversion: return Self[?](VK_KHR_maintenance1, VK_KHR_bind_memory2, VK_KHR_get_memory_requirements2, VK_KHR_get_physical_device_properties2); + case VK_EXT_image_drm_format_modifier: return Self[?](VK_KHR_bind_memory2, VK_KHR_get_physical_device_properties2, VK_KHR_sampler_ycbcr_conversion, VK_KHR_image_format_list); + case VK_EXT_descriptor_indexing: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_maintenance3); + case VK_KHR_portability_subset: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_shading_rate_image: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_ray_tracing: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_get_memory_requirements2); + case VK_NV_representative_fragment_test: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_maintenance3: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_8bit_storage: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_storage_buffer_storage_class); + case VK_EXT_external_memory_host: return Self[?](VK_KHR_external_memory); + case VK_KHR_shader_atomic_int64: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_clock: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_calibrated_timestamps: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_AMD_shader_core_properties: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_video_decode_h265: return Self[?](VK_KHR_video_decode_queue); + case VK_KHR_global_priority: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_vertex_attribute_divisor: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_GGP_frame_token: return Self[?](VK_KHR_swapchain, VK_GGP_stream_descriptor_surface); + case VK_KHR_driver_properties: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_float_controls: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_depth_stencil_resolve: return Self[?](VK_KHR_create_renderpass2); + case VK_KHR_swapchain_mutable_format: return Self[?](VK_KHR_swapchain, VK_KHR_maintenance2, VK_KHR_image_format_list); + case VK_NV_compute_shader_derivatives: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_mesh_shader: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_fragment_shader_barycentric: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_shader_image_footprint: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_scissor_exclusive: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_device_diagnostic_checkpoints: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_timeline_semaphore: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_present_timing: return Self[?](VK_KHR_swapchain, VK_KHR_present_id2, VK_KHR_get_surface_capabilities2, VK_KHR_calibrated_timestamps); + case VK_INTEL_shader_integer_functions2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_vulkan_memory_model: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_pci_bus_info: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_AMD_display_native_hdr: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); + case VK_FUCHSIA_imagepipe_surface: return Self[?](VK_KHR_surface); + case VK_KHR_shader_terminate_invocation: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_metal_surface: return Self[?](VK_KHR_surface); + case VK_EXT_fragment_density_map: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_scalar_block_layout: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_fragment_shading_rate: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_create_renderpass2); + case VK_AMD_shader_core_properties2: return Self[?](VK_AMD_shader_core_properties); + case VK_AMD_device_coherent_memory: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_dynamic_rendering_local_read: return Self[?](VK_KHR_dynamic_rendering); + case VK_EXT_shader_image_atomic_int64: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_quad_control: return Self[?](VK_KHR_vulkan_memory_model, VK_KHR_shader_maximal_reconvergence); + case VK_KHR_spirv_1_4: return Self[?](VK_KHR_shader_float_controls); + case VK_EXT_memory_budget: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_memory_priority: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_surface_protected_capabilities: return Self[?](VK_KHR_get_surface_capabilities2); + case VK_NV_dedicated_allocation_image_aliasing: return Self[?](VK_KHR_dedicated_allocation, VK_KHR_get_physical_device_properties2); + case VK_KHR_separate_depth_stencil_layouts: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_create_renderpass2); + case VK_EXT_buffer_device_address: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_present_wait: return Self[?](VK_KHR_swapchain, VK_KHR_present_id); + case VK_NV_cooperative_matrix: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_coverage_reduction_mode: return Self[?](VK_NV_framebuffer_mixed_samples, VK_KHR_get_physical_device_properties2); + case VK_EXT_fragment_shader_interlock: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_ycbcr_image_arrays: return Self[?](VK_KHR_sampler_ycbcr_conversion); + case VK_KHR_uniform_buffer_standard_layout: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_provoking_vertex: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_full_screen_exclusive: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_surface, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); + case VK_EXT_headless_surface: return Self[?](VK_KHR_surface); + case VK_KHR_buffer_device_address: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_device_group); + case VK_EXT_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_atomic_float: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_host_query_reset: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_index_type_uint8: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_extended_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_pipeline_executable_properties: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_host_image_copy: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_copy_commands2, VK_KHR_format_feature_flags2); + case VK_EXT_map_memory_placed: return Self[?](VK_KHR_map_memory2); + case VK_EXT_shader_atomic_float2: return Self[?](VK_EXT_shader_atomic_float); + case VK_EXT_surface_maintenance1: return Self[?](VK_KHR_surface, VK_KHR_get_surface_capabilities2); + case VK_EXT_swapchain_maintenance1: return Self[?](VK_KHR_swapchain, VK_EXT_surface_maintenance1, VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_demote_to_helper_invocation: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_device_generated_commands: return Self[?](VK_KHR_buffer_device_address); + case VK_NV_inherited_viewport_scissor: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_integer_dot_product: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_texel_buffer_alignment: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_depth_bias_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_device_memory_report: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_acquire_drm_display: return Self[?](VK_EXT_direct_mode_display); + case VK_EXT_robustness2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_custom_border_color: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_present_barrier: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_surface, VK_KHR_get_surface_capabilities2, VK_KHR_swapchain); + case VK_KHR_present_id: return Self[?](VK_KHR_swapchain, VK_KHR_get_physical_device_properties2); + case VK_EXT_private_data: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_pipeline_creation_cache_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_video_encode_queue: return Self[?](VK_KHR_video_queue, VK_KHR_synchronization2); + case VK_NV_device_diagnostics_config: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_cuda_kernel_launch: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_QCOM_tile_shading: return Self[?](VK_QCOM_tile_properties, VK_KHR_get_physical_device_properties2); + case VK_KHR_synchronization2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_descriptor_buffer: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address, VK_EXT_descriptor_indexing, VK_KHR_synchronization2); + case VK_EXT_graphics_pipeline_library: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_pipeline_library); + case VK_AMD_shader_early_and_late_fragment_tests: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_fragment_shader_barycentric: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_zero_initialize_workgroup_memory: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_fragment_shading_rate_enums: return Self[?](VK_KHR_fragment_shading_rate); + case VK_NV_ray_tracing_motion_blur: return Self[?](VK_KHR_ray_tracing_pipeline); + case VK_EXT_mesh_shader: return Self[?](VK_KHR_spirv_1_4); + case VK_EXT_ycbcr_2plane_444_formats: return Self[?](VK_KHR_sampler_ycbcr_conversion); + case VK_EXT_fragment_density_map2: return Self[?](VK_EXT_fragment_density_map); + case VK_QCOM_rotated_copy_commands: return Self[?](VK_KHR_copy_commands2); + case VK_EXT_image_robustness: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_workgroup_memory_explicit_layout: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_copy_commands2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_image_compression_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_attachment_feedback_loop_layout: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_4444_formats: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_device_fault: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_rasterization_order_attachment_access: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_rgba10x6_formats: return Self[?](VK_KHR_sampler_ycbcr_conversion); + case VK_NV_acquire_winrt_display: return Self[?](VK_EXT_direct_mode_display); + case VK_EXT_directfb_surface: return Self[?](VK_KHR_surface); + case VK_VALVE_mutable_descriptor_type: return Self[?](VK_KHR_maintenance3); + case VK_EXT_vertex_input_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_physical_device_drm: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_device_address_binding_report: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_debug_utils); + case VK_EXT_depth_clip_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_primitive_topology_list_restart: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_format_feature_flags2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_present_mode_fifo_latest_ready: return Self[?](VK_KHR_swapchain); + case VK_FUCHSIA_external_memory: return Self[?](VK_KHR_external_memory_capabilities, VK_KHR_external_memory); + case VK_FUCHSIA_external_semaphore: return Self[?](VK_KHR_external_semaphore_capabilities, VK_KHR_external_semaphore); + case VK_FUCHSIA_buffer_collection: return Self[?](VK_FUCHSIA_external_memory, VK_KHR_sampler_ycbcr_conversion); + case VK_HUAWEI_subpass_shading: return Self[?](VK_KHR_create_renderpass2, VK_KHR_synchronization2); + case VK_HUAWEI_invocation_mask: return Self[?](VK_KHR_ray_tracing_pipeline, VK_KHR_synchronization2); + case VK_NV_external_memory_rdma: return Self[?](VK_KHR_external_memory); + case VK_EXT_pipeline_properties: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_frame_boundary: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_multisampled_render_to_single_sampled: return Self[?](VK_KHR_create_renderpass2, VK_KHR_depth_stencil_resolve); + case VK_EXT_extended_dynamic_state2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_QNX_screen_surface: return Self[?](VK_KHR_surface); + case VK_EXT_color_write_enable: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_primitives_generated_query: return Self[?](VK_EXT_transform_feedback); + case VK_KHR_ray_tracing_maintenance1: return Self[?](VK_KHR_acceleration_structure); + case VK_KHR_shader_untyped_pointers: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_global_priority_query: return Self[?](VK_EXT_global_priority, VK_KHR_get_physical_device_properties2); + case VK_VALVE_video_encode_rgb_conversion: return Self[?](VK_KHR_video_encode_queue, VK_KHR_sampler_ycbcr_conversion); + case VK_EXT_image_view_min_lod: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_multi_draw: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_image_2d_view_of_3d: return Self[?](VK_KHR_maintenance1, VK_KHR_get_physical_device_properties2); + case VK_EXT_opacity_micromap: return Self[?](VK_KHR_acceleration_structure, VK_KHR_synchronization2); + case VK_NV_displacement_micromap: return Self[?](VK_EXT_opacity_micromap); + case VK_HUAWEI_cluster_culling_shader: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_border_color_swizzle: return Self[?](VK_EXT_custom_border_color); + case VK_EXT_pageable_device_local_memory: return Self[?](VK_EXT_memory_priority); + case VK_KHR_shader_subgroup_rotate: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_scheduling_controls: return Self[?](VK_ARM_shader_core_builtins); + case VK_EXT_image_sliced_view_of_3d: return Self[?](VK_KHR_maintenance1, VK_KHR_get_physical_device_properties2); + case VK_VALVE_descriptor_set_host_mapping: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_depth_clamp_zero_one: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_non_seamless_cube_map: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_render_pass_striped: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_synchronization2); + case VK_QCOM_fragment_density_map_offset: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_fragment_density_map); + case VK_NV_copy_memory_indirect: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); + case VK_NV_memory_decompression: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); + case VK_NV_device_generated_commands_compute: return Self[?](VK_NV_device_generated_commands); + case VK_NV_ray_tracing_linear_swept_spheres: return Self[?](VK_KHR_ray_tracing_pipeline); + case VK_NV_linear_color_attachment: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_GOOGLE_surfaceless_query: return Self[?](VK_KHR_surface); + case VK_EXT_image_compression_control_swapchain: return Self[?](VK_EXT_image_compression_control); + case VK_QCOM_image_processing: return Self[?](VK_KHR_format_feature_flags2); + case VK_EXT_nested_command_buffer: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_OHOS_external_memory: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); + case VK_EXT_external_memory_acquire_unmodified: return Self[?](VK_KHR_external_memory); + case VK_EXT_extended_dynamic_state3: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_subpass_merge_feedback: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_module_identifier: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_pipeline_creation_cache_control); + case VK_EXT_rasterization_order_attachment_access: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_optical_flow: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_format_feature_flags2, VK_KHR_synchronization2); + case VK_EXT_legacy_dithering: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_pipeline_protected_access: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ANDROID_external_format_resolve: return Self[?](VK_ANDROID_external_memory_android_hardware_buffer); + case VK_KHR_maintenance5: return Self[?](VK_KHR_dynamic_rendering); + case VK_AMD_anti_lag: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_AMDX_dense_geometry_format: return Self[?](VK_KHR_acceleration_structure, VK_KHR_maintenance5); + case VK_KHR_present_id2: return Self[?](VK_KHR_get_surface_capabilities2, VK_KHR_surface, VK_KHR_swapchain); + case VK_KHR_present_wait2: return Self[?](VK_KHR_get_surface_capabilities2, VK_KHR_surface, VK_KHR_swapchain, VK_KHR_present_id2); + case VK_KHR_ray_tracing_position_fetch: return Self[?](VK_KHR_acceleration_structure); + case VK_EXT_shader_object: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_dynamic_rendering); + case VK_KHR_pipeline_binary: return Self[?](VK_KHR_maintenance5); + case VK_QCOM_tile_properties: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_SEC_amigo_profiling: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_surface_maintenance1: return Self[?](VK_KHR_surface, VK_KHR_get_surface_capabilities2); + case VK_KHR_swapchain_maintenance1: return Self[?](VK_KHR_swapchain, VK_KHR_surface_maintenance1, VK_KHR_get_physical_device_properties2); + case VK_QCOM_multiview_per_view_viewports: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_ray_tracing_invocation_reorder: return Self[?](VK_KHR_ray_tracing_pipeline); + case VK_NV_cooperative_vector: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_extended_sparse_address_space: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_mutable_descriptor_type: return Self[?](VK_KHR_maintenance3); + case VK_EXT_legacy_vertex_attributes: return Self[?](VK_EXT_vertex_input_dynamic_state); + case VK_ARM_shader_core_builtins: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_pipeline_library_group_handles: return Self[?](VK_KHR_ray_tracing_pipeline, VK_KHR_pipeline_library); + case VK_EXT_dynamic_rendering_unused_attachments: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_dynamic_rendering); + case VK_NV_low_latency2: return Self[?](VK_KHR_timeline_semaphore, VK_KHR_present_id, VK_KHR_present_id2); + case VK_KHR_cooperative_matrix: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_data_graph: return Self[?](VK_KHR_maintenance5, VK_KHR_deferred_host_operations); + case VK_QCOM_multiview_per_view_render_areas: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_compute_shader_derivatives: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_video_decode_av1: return Self[?](VK_KHR_video_decode_queue); + case VK_KHR_video_encode_av1: return Self[?](VK_KHR_video_encode_queue); + case VK_KHR_video_decode_vp9: return Self[?](VK_KHR_video_decode_queue); + case VK_KHR_video_maintenance1: return Self[?](VK_KHR_video_queue); + case VK_NV_per_stage_descriptor_set: return Self[?](VK_KHR_maintenance6); + case VK_QCOM_image_processing2: return Self[?](VK_QCOM_image_processing); + case VK_QCOM_filter_cubic_weights: return Self[?](VK_EXT_filter_cubic); + case VK_QCOM_ycbcr_degamma: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_QCOM_filter_cubic_clamp: return Self[?](VK_EXT_filter_cubic, VK_EXT_sampler_filter_minmax); + case VK_EXT_attachment_feedback_loop_dynamic_state: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_attachment_feedback_loop_layout); + case VK_KHR_vertex_attribute_divisor: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_unified_image_layouts: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_float_controls2: return Self[?](VK_KHR_shader_float_controls); + case VK_QNX_external_memory_screen_buffer: return Self[?](VK_KHR_sampler_ycbcr_conversion, VK_KHR_external_memory, VK_KHR_dedicated_allocation, VK_EXT_queue_family_foreign); + case VK_MSFT_layered_driver: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_index_type_uint8: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_line_rasterization: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_calibrated_timestamps: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_expect_assume: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_QCOM_tile_memory_heap: return Self[?](VK_KHR_get_memory_requirements2, VK_KHR_get_physical_device_properties2); + case VK_KHR_copy_memory_indirect: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); + case VK_EXT_memory_decompression: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_buffer_device_address); + case VK_NV_display_stereo: return Self[?](VK_KHR_display, VK_KHR_get_display_properties2); + case VK_KHR_video_encode_intra_refresh: return Self[?](VK_KHR_video_encode_queue); + case VK_KHR_video_encode_quantization_map: return Self[?](VK_KHR_video_encode_queue, VK_KHR_format_feature_flags2); + case VK_NV_raw_access_chains: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_relaxed_extended_instruction: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_command_buffer_inheritance: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_shader_atomic_float16_vector: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_replicated_composites: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_float8: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_ray_tracing_validation: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_cluster_acceleration_structure: return Self[?](VK_KHR_acceleration_structure); + case VK_NV_partitioned_acceleration_structure: return Self[?](VK_KHR_acceleration_structure); + case VK_EXT_device_generated_commands: return Self[?](VK_KHR_buffer_device_address, VK_KHR_maintenance5); + case VK_MESA_image_alignment_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_shader_fma: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_ray_tracing_invocation_reorder: return Self[?](VK_KHR_ray_tracing_pipeline); + case VK_EXT_depth_clamp_control: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_maintenance9: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_video_maintenance2: return Self[?](VK_KHR_video_queue); + case VK_OHOS_surface: return Self[?](VK_KHR_surface); + case VK_HUAWEI_hdr_vivid: return Self[?](VK_KHR_get_physical_device_properties2, VK_KHR_swapchain, VK_EXT_hdr_metadata); + case VK_NV_cooperative_matrix2: return Self[?](VK_KHR_cooperative_matrix); + case VK_ARM_pipeline_opacity_micromap: return Self[?](VK_EXT_opacity_micromap); + case VK_EXT_external_memory_metal: return Self[?](VK_KHR_external_memory); + case VK_KHR_depth_clamp_zero_one: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_performance_counters_by_region: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_vertex_attribute_robustness: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_ARM_format_pack: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_VALVE_fragment_density_map_layered: return Self[?](VK_KHR_maintenance5, VK_EXT_fragment_density_map); + case VK_KHR_robustness2: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_NV_present_metering: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_fragment_density_map_offset: return Self[?](VK_KHR_get_physical_device_properties2, VK_EXT_fragment_density_map, VK_KHR_create_renderpass2, VK_KHR_dynamic_rendering); + case VK_EXT_zero_initialize_device_memory: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_KHR_present_mode_fifo_latest_ready: return Self[?](VK_KHR_swapchain); + case VK_EXT_shader_64bit_indexing: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_custom_resolve: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_QCOM_data_graph_model: return Self[?](VK_ARM_data_graph); + case VK_KHR_maintenance10: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_SEC_pipeline_cache_incremental_mode: return Self[?](VK_KHR_get_physical_device_properties2); + case VK_EXT_shader_uniform_buffer_unsized_array: return Self[?](VK_KHR_get_physical_device_properties2); + default: return default; + } + } + } +} + +namespace Vulkan; + +extension VkStructureType +{ + public Type Type + { + get + { + switch (this) + { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: return typeof(VkApplicationInfo); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: return typeof(VkDeviceQueueCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return typeof(VkDeviceCreateInfo); + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return typeof(VkInstanceCreateInfo); + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: return typeof(VkMemoryAllocateInfo); + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: return typeof(VkMappedMemoryRange); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: return typeof(VkWriteDescriptorSet); + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: return typeof(VkCopyDescriptorSet); + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: return typeof(VkBufferUsageFlags2CreateInfo); + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: return typeof(VkBufferCreateInfo); + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: return typeof(VkBufferViewCreateInfo); + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: return typeof(VkMemoryBarrier); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return typeof(VkBufferMemoryBarrier); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: return typeof(VkImageMemoryBarrier); + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: return typeof(VkImageCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return typeof(VkImageViewCreateInfo); + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: return typeof(VkBindSparseInfo); + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: return typeof(VkCopyMemoryIndirectInfoKHR); + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: return typeof(VkCopyMemoryToImageIndirectInfoKHR); + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return typeof(VkShaderModuleCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: return typeof(VkDescriptorSetLayoutCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: return typeof(VkDescriptorPoolCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: return typeof(VkDescriptorSetAllocateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return typeof(VkPipelineShaderStageCreateInfo); + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return typeof(VkComputePipelineCreateInfo); + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: return typeof(VkComputePipelineIndirectBufferInfoNV); + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: return typeof(VkPipelineCreateFlags2CreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: return typeof(VkPipelineVertexInputStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: return typeof(VkPipelineInputAssemblyStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: return typeof(VkPipelineTessellationStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: return typeof(VkPipelineViewportStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: return typeof(VkPipelineRasterizationStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: return typeof(VkPipelineMultisampleStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: return typeof(VkPipelineColorBlendStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: return typeof(VkPipelineDynamicStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: return typeof(VkPipelineDepthStencilStateCreateInfo); + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return typeof(VkGraphicsPipelineCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: return typeof(VkPipelineCacheCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: return typeof(VkPipelineBinaryCreateInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: return typeof(VkPipelineBinaryHandlesInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: return typeof(VkPipelineBinaryKeyKHR); + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: return typeof(VkPipelineBinaryInfoKHR); + case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: return typeof(VkReleaseCapturedPipelineDataInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: return typeof(VkPipelineBinaryDataInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: return typeof(VkPipelineCreateInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return typeof(VkPipelineLayoutCreateInfo); + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: return typeof(VkSamplerCreateInfo); + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: return typeof(VkCommandPoolCreateInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: return typeof(VkCommandBufferAllocateInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: return typeof(VkCommandBufferInheritanceInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: return typeof(VkCommandBufferBeginInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return typeof(VkRenderPassBeginInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return typeof(VkRenderPassCreateInfo); + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: return typeof(VkEventCreateInfo); + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: return typeof(VkFenceCreateInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: return typeof(VkSemaphoreCreateInfo); + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return typeof(VkQueryPoolCreateInfo); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: return typeof(VkFramebufferCreateInfo); + case VK_STRUCTURE_TYPE_SUBMIT_INFO: return typeof(VkSubmitInfo); + case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: return typeof(VkDisplayModeCreateInfoKHR); + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: return typeof(VkDisplaySurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: return typeof(VkDisplaySurfaceStereoCreateInfoNV); + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: return typeof(VkDisplayPresentInfoKHR); + case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: return typeof(VkAndroidSurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: return typeof(VkViSurfaceCreateInfoNN); + case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: return typeof(VkWaylandSurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: return typeof(VkWin32SurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: return typeof(VkXlibSurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: return typeof(VkXcbSurfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: return typeof(VkDirectFBSurfaceCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: return typeof(VkImagePipeSurfaceCreateInfoFUCHSIA); + case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: return typeof(VkStreamDescriptorSurfaceCreateInfoGGP); + case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: return typeof(VkScreenSurfaceCreateInfoQNX); + case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: return typeof(VkSwapchainCreateInfoKHR); + case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: return typeof(VkPresentInfoKHR); + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: return typeof(VkDebugReportCallbackCreateInfoEXT); + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: return typeof(VkValidationFlagsEXT); + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: return typeof(VkValidationFeaturesEXT); + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: return typeof(VkLayerSettingsCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: return typeof(VkPipelineRasterizationStateRasterizationOrderAMD); + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: return typeof(VkDebugMarkerObjectNameInfoEXT); + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: return typeof(VkDebugMarkerObjectTagInfoEXT); + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: return typeof(VkDebugMarkerMarkerInfoEXT); + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: return typeof(VkDedicatedAllocationImageCreateInfoNV); + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: return typeof(VkDedicatedAllocationBufferCreateInfoNV); + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: return typeof(VkDedicatedAllocationMemoryAllocateInfoNV); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: return typeof(VkExternalMemoryImageCreateInfoNV); + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: return typeof(VkExportMemoryAllocateInfoNV); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: return typeof(VkImportMemoryWin32HandleInfoNV); + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: return typeof(VkExportMemoryWin32HandleInfoNV); + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: return typeof(VkWin32KeyedMutexAcquireReleaseInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: return typeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: return typeof(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV); + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: return typeof(VkDevicePrivateDataCreateInfo); + case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: return typeof(VkPrivateDataSlotCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: return typeof(VkPhysicalDevicePrivateDataFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: return typeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: return typeof(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: return typeof(VkPhysicalDeviceClusterAccelerationStructurePropertiesNV); + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: return typeof(VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV); + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: return typeof(VkClusterAccelerationStructureClustersBottomLevelInputNV); + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: return typeof(VkClusterAccelerationStructureTriangleClusterInputNV); + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: return typeof(VkClusterAccelerationStructureMoveObjectsInputNV); + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: return typeof(VkClusterAccelerationStructureInputInfoNV); + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: return typeof(VkClusterAccelerationStructureCommandsInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: return typeof(VkPhysicalDeviceMultiDrawPropertiesEXT); + case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: return typeof(VkGraphicsShaderGroupCreateInfoNV); + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: return typeof(VkGraphicsPipelineShaderGroupsCreateInfoNV); + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: return typeof(VkIndirectCommandsLayoutTokenNV); + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: return typeof(VkIndirectCommandsLayoutCreateInfoNV); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: return typeof(VkGeneratedCommandsInfoNV); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: return typeof(VkGeneratedCommandsMemoryRequirementsInfoNV); + case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: return typeof(VkPipelineIndirectDeviceAddressInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: return typeof(VkPhysicalDeviceFeatures2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: return typeof(VkPhysicalDeviceProperties2); + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: return typeof(VkFormatProperties2); + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: return typeof(VkImageFormatProperties2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: return typeof(VkPhysicalDeviceImageFormatInfo2); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: return typeof(VkQueueFamilyProperties2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: return typeof(VkPhysicalDeviceMemoryProperties2); + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: return typeof(VkSparseImageFormatProperties2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: return typeof(VkPhysicalDeviceSparseImageFormatInfo2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: return typeof(VkPhysicalDevicePushDescriptorProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: return typeof(VkPhysicalDeviceDriverProperties); + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: return typeof(VkPresentRegionsKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: return typeof(VkPhysicalDeviceVariablePointersFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: return typeof(VkPhysicalDeviceExternalImageFormatInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: return typeof(VkExternalImageFormatProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: return typeof(VkPhysicalDeviceExternalBufferInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: return typeof(VkExternalBufferProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: return typeof(VkPhysicalDeviceIDProperties); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: return typeof(VkExternalMemoryImageCreateInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: return typeof(VkExternalMemoryBufferCreateInfo); + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: return typeof(VkExportMemoryAllocateInfo); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: return typeof(VkImportMemoryWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: return typeof(VkExportMemoryWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: return typeof(VkImportMemoryZirconHandleInfoFUCHSIA); + case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: return typeof(VkMemoryZirconHandlePropertiesFUCHSIA); + case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: return typeof(VkMemoryGetZirconHandleInfoFUCHSIA); + case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: return typeof(VkMemoryWin32HandlePropertiesKHR); + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: return typeof(VkMemoryGetWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: return typeof(VkImportMemoryFdInfoKHR); + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: return typeof(VkMemoryFdPropertiesKHR); + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: return typeof(VkMemoryGetFdInfoKHR); + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: return typeof(VkWin32KeyedMutexAcquireReleaseInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: return typeof(VkImportMemoryMetalHandleInfoEXT); + case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT: return typeof(VkMemoryMetalHandlePropertiesEXT); + case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT: return typeof(VkMemoryGetMetalHandleInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: return typeof(VkPhysicalDeviceExternalSemaphoreInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: return typeof(VkExternalSemaphoreProperties); + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: return typeof(VkExportSemaphoreCreateInfo); + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: return typeof(VkImportSemaphoreWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: return typeof(VkExportSemaphoreWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: return typeof(VkD3D12FenceSubmitInfoKHR); + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: return typeof(VkSemaphoreGetWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: return typeof(VkImportSemaphoreFdInfoKHR); + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: return typeof(VkSemaphoreGetFdInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: return typeof(VkImportSemaphoreZirconHandleInfoFUCHSIA); + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: return typeof(VkSemaphoreGetZirconHandleInfoFUCHSIA); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: return typeof(VkPhysicalDeviceExternalFenceInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: return typeof(VkExternalFenceProperties); + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: return typeof(VkExportFenceCreateInfo); + case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: return typeof(VkImportFenceWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: return typeof(VkExportFenceWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: return typeof(VkFenceGetWin32HandleInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: return typeof(VkImportFenceFdInfoKHR); + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: return typeof(VkFenceGetFdInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: return typeof(VkPhysicalDeviceMultiviewFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: return typeof(VkPhysicalDeviceMultiviewProperties); + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: return typeof(VkRenderPassMultiviewCreateInfo); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: return typeof(VkSurfaceCapabilities2EXT); + case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: return typeof(VkDisplayPowerInfoEXT); + case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: return typeof(VkDeviceEventInfoEXT); + case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: return typeof(VkDisplayEventInfoEXT); + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: return typeof(VkSwapchainCounterCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: return typeof(VkPhysicalDeviceGroupProperties); + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: return typeof(VkMemoryAllocateFlagsInfo); + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: return typeof(VkBindBufferMemoryInfo); + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: return typeof(VkBindBufferMemoryDeviceGroupInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: return typeof(VkBindImageMemoryInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: return typeof(VkBindImageMemoryDeviceGroupInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: return typeof(VkDeviceGroupRenderPassBeginInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: return typeof(VkDeviceGroupCommandBufferBeginInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: return typeof(VkDeviceGroupSubmitInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: return typeof(VkDeviceGroupBindSparseInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: return typeof(VkDeviceGroupPresentCapabilitiesKHR); + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: return typeof(VkImageSwapchainCreateInfoKHR); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: return typeof(VkBindImageMemorySwapchainInfoKHR); + case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: return typeof(VkAcquireNextImageInfoKHR); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: return typeof(VkDeviceGroupPresentInfoKHR); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: return typeof(VkDeviceGroupDeviceCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: return typeof(VkDeviceGroupSwapchainCreateInfoKHR); + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: return typeof(VkDescriptorUpdateTemplateCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: return typeof(VkPhysicalDevicePresentIdFeaturesKHR); + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: return typeof(VkPresentIdKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: return typeof(VkPhysicalDevicePresentId2FeaturesKHR); + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: return typeof(VkPresentId2KHR); + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: return typeof(VkPresentWait2InfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: return typeof(VkPhysicalDevicePresentWaitFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: return typeof(VkPhysicalDevicePresentWait2FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: return typeof(VkPhysicalDevicePresentTimingFeaturesEXT); + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: return typeof(VkPresentTimingSurfaceCapabilitiesEXT); + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: return typeof(VkSwapchainTimingPropertiesEXT); + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: return typeof(VkSwapchainTimeDomainPropertiesEXT); + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: return typeof(VkPastPresentationTimingInfoEXT); + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: return typeof(VkPastPresentationTimingPropertiesEXT); + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: return typeof(VkPastPresentationTimingEXT); + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: return typeof(VkPresentTimingsInfoEXT); + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: return typeof(VkPresentTimingInfoEXT); + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: return typeof(VkSwapchainCalibratedTimestampInfoEXT); + case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: return typeof(VkHdrMetadataEXT); + case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: return typeof(VkHdrVividDynamicMetadataHUAWEI); + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: return typeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD); + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: return typeof(VkSwapchainDisplayNativeHdrCreateInfoAMD); + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: return typeof(VkPresentTimesInfoGOOGLE); + case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: return typeof(VkIOSSurfaceCreateInfoMVK); + case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: return typeof(VkMacOSSurfaceCreateInfoMVK); + case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: return typeof(VkMetalSurfaceCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: return typeof(VkPipelineViewportWScalingStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: return typeof(VkPipelineViewportSwizzleStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: return typeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: return typeof(VkPipelineDiscardRectangleStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: return typeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX); + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: return typeof(VkRenderPassInputAttachmentAspectCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: return typeof(VkPhysicalDeviceSurfaceInfo2KHR); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: return typeof(VkSurfaceCapabilities2KHR); + case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: return typeof(VkSurfaceFormat2KHR); + case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: return typeof(VkDisplayProperties2KHR); + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: return typeof(VkDisplayPlaneProperties2KHR); + case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: return typeof(VkDisplayModeProperties2KHR); + case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: return typeof(VkDisplayModeStereoPropertiesNV); + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: return typeof(VkDisplayPlaneInfo2KHR); + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: return typeof(VkDisplayPlaneCapabilities2KHR); + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: return typeof(VkSharedPresentSurfaceCapabilitiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: return typeof(VkPhysicalDevice16BitStorageFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: return typeof(VkPhysicalDeviceSubgroupProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: return typeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: return typeof(VkBufferMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: return typeof(VkDeviceBufferMemoryRequirements); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: return typeof(VkImageMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: return typeof(VkImageSparseMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: return typeof(VkDeviceImageMemoryRequirements); + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: return typeof(VkMemoryRequirements2); + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: return typeof(VkSparseImageMemoryRequirements2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: return typeof(VkPhysicalDevicePointClippingProperties); + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: return typeof(VkMemoryDedicatedRequirements); + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: return typeof(VkMemoryDedicatedAllocateInfo); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: return typeof(VkImageViewUsageCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: return typeof(VkImageViewSlicedCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: return typeof(VkPipelineTessellationDomainOriginStateCreateInfo); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: return typeof(VkSamplerYcbcrConversionInfo); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: return typeof(VkSamplerYcbcrConversionCreateInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: return typeof(VkBindImagePlaneMemoryInfo); + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: return typeof(VkImagePlaneMemoryRequirementsInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: return typeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: return typeof(VkSamplerYcbcrConversionImageFormatProperties); + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: return typeof(VkTextureLODGatherFormatPropertiesAMD); + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: return typeof(VkConditionalRenderingBeginInfoEXT); + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: return typeof(VkProtectedSubmitInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: return typeof(VkPhysicalDeviceProtectedMemoryFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: return typeof(VkPhysicalDeviceProtectedMemoryProperties); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: return typeof(VkDeviceQueueInfo2); + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: return typeof(VkPipelineCoverageToColorStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: return typeof(VkPhysicalDeviceSamplerFilterMinmaxProperties); + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: return typeof(VkSampleLocationsInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: return typeof(VkRenderPassSampleLocationsBeginInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: return typeof(VkPipelineSampleLocationsStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: return typeof(VkPhysicalDeviceSampleLocationsPropertiesEXT); + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: return typeof(VkMultisamplePropertiesEXT); + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: return typeof(VkSamplerReductionModeCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: return typeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: return typeof(VkPhysicalDeviceMultiDrawFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: return typeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: return typeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: return typeof(VkPhysicalDeviceInlineUniformBlockFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: return typeof(VkPhysicalDeviceInlineUniformBlockProperties); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: return typeof(VkWriteDescriptorSetInlineUniformBlock); + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: return typeof(VkDescriptorPoolInlineUniformBlockCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: return typeof(VkPipelineCoverageModulationStateCreateInfoNV); + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: return typeof(VkImageFormatListCreateInfo); + case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: return typeof(VkValidationCacheCreateInfoEXT); + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: return typeof(VkShaderModuleValidationCacheCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: return typeof(VkPhysicalDeviceMaintenance3Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: return typeof(VkPhysicalDeviceMaintenance4Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: return typeof(VkPhysicalDeviceMaintenance4Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: return typeof(VkPhysicalDeviceMaintenance5Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: return typeof(VkPhysicalDeviceMaintenance5Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: return typeof(VkPhysicalDeviceMaintenance6Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: return typeof(VkPhysicalDeviceMaintenance6Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: return typeof(VkPhysicalDeviceMaintenance7FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: return typeof(VkPhysicalDeviceMaintenance7PropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: return typeof(VkPhysicalDeviceLayeredApiPropertiesListKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: return typeof(VkPhysicalDeviceLayeredApiPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: return typeof(VkPhysicalDeviceLayeredApiVulkanPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: return typeof(VkPhysicalDeviceMaintenance8FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: return typeof(VkPhysicalDeviceMaintenance9FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: return typeof(VkPhysicalDeviceMaintenance9PropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: return typeof(VkPhysicalDeviceMaintenance10PropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: return typeof(VkPhysicalDeviceMaintenance10FeaturesKHR); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: return typeof(VkQueueFamilyOwnershipTransferPropertiesKHR); + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: return typeof(VkRenderingAreaInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: return typeof(VkDescriptorSetLayoutSupport); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: return typeof(VkPhysicalDeviceShaderDrawParametersFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: return typeof(VkPhysicalDeviceShaderFloat16Int8Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: return typeof(VkPhysicalDeviceFloatControlsProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: return typeof(VkPhysicalDeviceHostQueryResetFeatures); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: return typeof(VkDeviceQueueGlobalPriorityCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: return typeof(VkPhysicalDeviceGlobalPriorityQueryFeatures); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: return typeof(VkQueueFamilyGlobalPriorityProperties); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: return typeof(VkDebugUtilsObjectNameInfoEXT); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: return typeof(VkDebugUtilsObjectTagInfoEXT); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: return typeof(VkDebugUtilsLabelEXT); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: return typeof(VkDebugUtilsMessengerCreateInfoEXT); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: return typeof(VkDebugUtilsMessengerCallbackDataEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: return typeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT); + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: return typeof(VkDeviceDeviceMemoryReportCreateInfoEXT); + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: return typeof(VkDeviceMemoryReportCallbackDataEXT); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: return typeof(VkImportMemoryHostPointerInfoEXT); + case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: return typeof(VkMemoryHostPointerPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: return typeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: return typeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT); + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: return typeof(VkCalibratedTimestampInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: return typeof(VkPhysicalDeviceShaderCorePropertiesAMD); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: return typeof(VkPhysicalDeviceShaderCoreProperties2AMD); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: return typeof(VkPipelineRasterizationConservativeStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: return typeof(VkPhysicalDeviceDescriptorIndexingFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: return typeof(VkPhysicalDeviceDescriptorIndexingProperties); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: return typeof(VkDescriptorSetLayoutBindingFlagsCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: return typeof(VkDescriptorSetVariableDescriptorCountAllocateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: return typeof(VkDescriptorSetVariableDescriptorCountLayoutSupport); + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: return typeof(VkAttachmentDescription2); + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: return typeof(VkAttachmentReference2); + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: return typeof(VkSubpassDescription2); + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: return typeof(VkSubpassDependency2); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: return typeof(VkRenderPassCreateInfo2); + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: return typeof(VkSubpassBeginInfo); + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: return typeof(VkSubpassEndInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: return typeof(VkPhysicalDeviceTimelineSemaphoreFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: return typeof(VkPhysicalDeviceTimelineSemaphoreProperties); + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: return typeof(VkSemaphoreTypeCreateInfo); + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: return typeof(VkTimelineSemaphoreSubmitInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: return typeof(VkSemaphoreWaitInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: return typeof(VkSemaphoreSignalInfo); + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: return typeof(VkPipelineVertexInputDivisorStateCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: return typeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: return typeof(VkPhysicalDeviceVertexAttributeDivisorProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: return typeof(VkPhysicalDevicePCIBusInfoPropertiesEXT); + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: return typeof(VkImportAndroidHardwareBufferInfoANDROID); + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: return typeof(VkAndroidHardwareBufferUsageANDROID); + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: return typeof(VkAndroidHardwareBufferPropertiesANDROID); + case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: return typeof(VkMemoryGetAndroidHardwareBufferInfoANDROID); + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: return typeof(VkAndroidHardwareBufferFormatPropertiesANDROID); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: return typeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT); + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: return typeof(VkExternalFormatANDROID); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: return typeof(VkPhysicalDevice8BitStorageFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: return typeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: return typeof(VkPhysicalDeviceVulkanMemoryModelFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: return typeof(VkPhysicalDeviceShaderAtomicInt64Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: return typeof(VkPhysicalDeviceVertexAttributeDivisorFeatures); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: return typeof(VkQueueFamilyCheckpointPropertiesNV); + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: return typeof(VkCheckpointDataNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: return typeof(VkPhysicalDeviceDepthStencilResolveProperties); + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: return typeof(VkSubpassDescriptionDepthStencilResolve); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: return typeof(VkImageViewASTCDecodeModeEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: return typeof(VkPhysicalDeviceASTCDecodeFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: return typeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: return typeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: return typeof(VkPipelineRasterizationStateStreamCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: return typeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV); + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: return typeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: return typeof(VkPhysicalDeviceExclusiveScissorFeaturesNV); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: return typeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: return typeof(VkPhysicalDeviceCornerSampledImageFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: return typeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: return typeof(VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: return typeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: return typeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: return typeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: return typeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: return typeof(VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: return typeof(VkPhysicalDeviceMemoryDecompressionFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: return typeof(VkPhysicalDeviceMemoryDecompressionPropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: return typeof(VkPipelineViewportShadingRateImageStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: return typeof(VkPhysicalDeviceShadingRateImageFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: return typeof(VkPhysicalDeviceShadingRateImagePropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: return typeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: return typeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: return typeof(VkPhysicalDeviceMeshShaderFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: return typeof(VkPhysicalDeviceMeshShaderPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: return typeof(VkPhysicalDeviceMeshShaderFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: return typeof(VkPhysicalDeviceMeshShaderPropertiesEXT); + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: return typeof(VkRayTracingShaderGroupCreateInfoNV); + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: return typeof(VkRayTracingShaderGroupCreateInfoKHR); + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: return typeof(VkRayTracingPipelineCreateInfoNV); + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: return typeof(VkRayTracingPipelineCreateInfoKHR); + case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: return typeof(VkGeometryTrianglesNV); + case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: return typeof(VkGeometryAABBNV); + case VK_STRUCTURE_TYPE_GEOMETRY_NV: return typeof(VkGeometryNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: return typeof(VkAccelerationStructureInfoNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: return typeof(VkAccelerationStructureCreateInfoNV); + case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: return typeof(VkBindAccelerationStructureMemoryInfoNV); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: return typeof(VkWriteDescriptorSetAccelerationStructureKHR); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: return typeof(VkWriteDescriptorSetAccelerationStructureNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: return typeof(VkAccelerationStructureMemoryRequirementsInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: return typeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: return typeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: return typeof(VkPhysicalDeviceRayQueryFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: return typeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: return typeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: return typeof(VkPhysicalDeviceRayTracingPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: return typeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR); + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: return typeof(VkDrmFormatModifierPropertiesListEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: return typeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: return typeof(VkImageDrmFormatModifierListCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: return typeof(VkImageDrmFormatModifierExplicitCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: return typeof(VkImageDrmFormatModifierPropertiesEXT); + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: return typeof(VkImageStencilUsageCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: return typeof(VkDeviceMemoryOverallocationCreateInfoAMD); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: return typeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: return typeof(VkRenderPassFragmentDensityMapCreateInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: return typeof(VkRenderPassFragmentDensityMapOffsetEndInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: return typeof(VkPhysicalDeviceScalarBlockLayoutFeatures); + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: return typeof(VkSurfaceProtectedCapabilitiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: return typeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: return typeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: return typeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: return typeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: return typeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT); + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: return typeof(VkMemoryPriorityAllocateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: return typeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: return typeof(VkPhysicalDeviceBufferDeviceAddressFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: return typeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: return typeof(VkBufferDeviceAddressInfo); + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: return typeof(VkBufferOpaqueCaptureAddressCreateInfo); + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: return typeof(VkBufferDeviceAddressCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: return typeof(VkPhysicalDeviceImageViewImageFormatInfoEXT); + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: return typeof(VkFilterCubicImageViewImageFormatPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: return typeof(VkPhysicalDeviceImagelessFramebufferFeatures); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: return typeof(VkFramebufferAttachmentsCreateInfo); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: return typeof(VkFramebufferAttachmentImageInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: return typeof(VkRenderPassAttachmentBeginInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: return typeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: return typeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: return typeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV); + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: return typeof(VkCooperativeMatrixPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: return typeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: return typeof(VkImageViewHandleInfoNVX); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: return typeof(VkImageViewAddressPropertiesNVX); + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: return typeof(VkPresentFrameTokenGGP); + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: return typeof(VkPipelineCreationFeedbackCreateInfo); + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: return typeof(VkSurfaceFullScreenExclusiveInfoEXT); + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: return typeof(VkSurfaceFullScreenExclusiveWin32InfoEXT); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: return typeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: return typeof(VkPhysicalDevicePresentBarrierFeaturesNV); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: return typeof(VkSurfaceCapabilitiesPresentBarrierNV); + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: return typeof(VkSwapchainPresentBarrierCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: return typeof(VkPhysicalDevicePerformanceQueryFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: return typeof(VkPhysicalDevicePerformanceQueryPropertiesKHR); + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: return typeof(VkPerformanceCounterKHR); + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: return typeof(VkPerformanceCounterDescriptionKHR); + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: return typeof(VkQueryPoolPerformanceCreateInfoKHR); + case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: return typeof(VkAcquireProfilingLockInfoKHR); + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: return typeof(VkPerformanceQuerySubmitInfoKHR); + case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: return typeof(VkHeadlessSurfaceCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: return typeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV); + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: return typeof(VkPipelineCoverageReductionStateCreateInfoNV); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: return typeof(VkFramebufferMixedSamplesCombinationNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: return typeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL); + case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: return typeof(VkInitializePerformanceApiInfoINTEL); + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: return typeof(VkQueryPoolPerformanceQueryCreateInfoINTEL); + case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: return typeof(VkPerformanceMarkerInfoINTEL); + case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: return typeof(VkPerformanceStreamMarkerInfoINTEL); + case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: return typeof(VkPerformanceOverrideInfoINTEL); + case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: return typeof(VkPerformanceConfigurationAcquireInfoINTEL); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderClockFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: return typeof(VkPhysicalDeviceIndexTypeUint8Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: return typeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: return typeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: return typeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: return typeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures); + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: return typeof(VkAttachmentReferenceStencilLayout); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: return typeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT); + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: return typeof(VkAttachmentDescriptionStencilLayout); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: return typeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR); + case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: return typeof(VkPipelineInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: return typeof(VkPipelineExecutablePropertiesKHR); + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: return typeof(VkPipelineExecutableInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: return typeof(VkPipelineExecutableStatisticKHR); + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: return typeof(VkPipelineExecutableInternalRepresentationKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: return typeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: return typeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: return typeof(VkPhysicalDeviceTexelBufferAlignmentProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: return typeof(VkPhysicalDeviceSubgroupSizeControlFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: return typeof(VkPhysicalDeviceSubgroupSizeControlProperties); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: return typeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo); + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: return typeof(VkSubpassShadingPipelineCreateInfoHUAWEI); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: return typeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: return typeof(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI); + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: return typeof(VkMemoryOpaqueCaptureAddressAllocateInfo); + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: return typeof(VkDeviceMemoryOpaqueCaptureAddressInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: return typeof(VkPhysicalDeviceLineRasterizationFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: return typeof(VkPhysicalDeviceLineRasterizationProperties); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: return typeof(VkPipelineRasterizationLineStateCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: return typeof(VkPhysicalDevicePipelineCreationCacheControlFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: return typeof(VkPhysicalDeviceVulkan11Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: return typeof(VkPhysicalDeviceVulkan11Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: return typeof(VkPhysicalDeviceVulkan12Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: return typeof(VkPhysicalDeviceVulkan12Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: return typeof(VkPhysicalDeviceVulkan13Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: return typeof(VkPhysicalDeviceVulkan13Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: return typeof(VkPhysicalDeviceVulkan14Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: return typeof(VkPhysicalDeviceVulkan14Properties); + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: return typeof(VkPipelineCompilerControlCreateInfoAMD); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: return typeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: return typeof(VkPhysicalDeviceToolProperties); + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: return typeof(VkSamplerCustomBorderColorCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: return typeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: return typeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT); + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: return typeof(VkSamplerBorderColorComponentMappingCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: return typeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: return typeof(VkAccelerationStructureGeometryTrianglesDataKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: return typeof(VkAccelerationStructureGeometryAabbsDataKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: return typeof(VkAccelerationStructureGeometryInstancesDataKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: return typeof(VkAccelerationStructureGeometryLinearSweptSpheresDataNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: return typeof(VkAccelerationStructureGeometrySpheresDataNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: return typeof(VkAccelerationStructureGeometryKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: return typeof(VkAccelerationStructureBuildGeometryInfoKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: return typeof(VkAccelerationStructureCreateInfoKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: return typeof(VkAccelerationStructureDeviceAddressInfoKHR); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: return typeof(VkAccelerationStructureVersionInfoKHR); + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: return typeof(VkCopyAccelerationStructureInfoKHR); + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: return typeof(VkCopyAccelerationStructureToMemoryInfoKHR); + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: return typeof(VkCopyMemoryToAccelerationStructureInfoKHR); + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: return typeof(VkRayTracingPipelineInterfaceCreateInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: return typeof(VkPipelineLibraryCreateInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: return typeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: return typeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: return typeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: return typeof(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: return typeof(VkRenderPassTransformBeginInfoQCOM); + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: return typeof(VkCopyCommandTransformInfoQCOM); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: return typeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: return typeof(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: return typeof(VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV); + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: return typeof(VkPartitionedAccelerationStructureFlagsNV); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: return typeof(VkWriteDescriptorSetPartitionedAccelerationStructureNV); + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: return typeof(VkPartitionedAccelerationStructureInstancesInputNV); + case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: return typeof(VkBuildPartitionedAccelerationStructureInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: return typeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV); + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: return typeof(VkDeviceDiagnosticsConfigCreateInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: return typeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: return typeof(VkPhysicalDeviceRobustness2FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: return typeof(VkPhysicalDeviceRobustness2PropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: return typeof(VkPhysicalDeviceImageRobustnessFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: return typeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: return typeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: return typeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: return typeof(VkPhysicalDevice4444FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: return typeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: return typeof(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: return typeof(VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI); + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: return typeof(VkBufferCopy2); + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: return typeof(VkImageCopy2); + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: return typeof(VkImageBlit2); + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: return typeof(VkBufferImageCopy2); + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: return typeof(VkImageResolve2); + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: return typeof(VkCopyBufferInfo2); + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: return typeof(VkCopyImageInfo2); + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: return typeof(VkBlitImageInfo2); + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: return typeof(VkCopyBufferToImageInfo2); + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: return typeof(VkCopyImageToBufferInfo2); + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: return typeof(VkResolveImageInfo2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT); + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: return typeof(VkFragmentShadingRateAttachmentInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: return typeof(VkPipelineFragmentShadingRateStateCreateInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: return typeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: return typeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: return typeof(VkPhysicalDeviceFragmentShadingRateKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: return typeof(VkPhysicalDeviceShaderTerminateInvocationFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: return typeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: return typeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV); + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: return typeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: return typeof(VkAccelerationStructureBuildSizesInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: return typeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: return typeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: return typeof(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: return typeof(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: return typeof(VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: return typeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT); + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: return typeof(VkMutableDescriptorTypeCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: return typeof(VkPhysicalDeviceDepthClipControlFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: return typeof(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT); + case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: return typeof(VkBeginCustomResolveInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: return typeof(VkPhysicalDeviceCustomResolveFeaturesEXT); + case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: return typeof(VkCustomResolveCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: return typeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: return typeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: return typeof(VkGeneratedCommandsPipelineInfoEXT); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: return typeof(VkGeneratedCommandsShaderInfoEXT); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: return typeof(VkGeneratedCommandsMemoryRequirementsInfoEXT); + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: return typeof(VkIndirectExecutionSetPipelineInfoEXT); + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: return typeof(VkIndirectExecutionSetShaderLayoutInfoEXT); + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: return typeof(VkIndirectExecutionSetShaderInfoEXT); + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: return typeof(VkIndirectExecutionSetCreateInfoEXT); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: return typeof(VkGeneratedCommandsInfoEXT); + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: return typeof(VkWriteIndirectExecutionSetPipelineEXT); + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: return typeof(VkWriteIndirectExecutionSetShaderEXT); + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: return typeof(VkIndirectCommandsLayoutCreateInfoEXT); + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: return typeof(VkIndirectCommandsLayoutTokenEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: return typeof(VkPipelineViewportDepthClipControlCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: return typeof(VkPhysicalDeviceDepthClampControlFeaturesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: return typeof(VkPipelineViewportDepthClampControlCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: return typeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: return typeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR); + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: return typeof(VkVertexInputBindingDescription2EXT); + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: return typeof(VkVertexInputAttributeDescription2EXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: return typeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: return typeof(VkPipelineColorWriteCreateInfoEXT); + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: return typeof(VkMemoryBarrier2); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: return typeof(VkImageMemoryBarrier2); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: return typeof(VkBufferMemoryBarrier2); + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: return typeof(VkMemoryBarrierAccessFlags3KHR); + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: return typeof(VkDependencyInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: return typeof(VkSemaphoreSubmitInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: return typeof(VkCommandBufferSubmitInfo); + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: return typeof(VkSubmitInfo2); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: return typeof(VkQueueFamilyCheckpointProperties2NV); + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: return typeof(VkCheckpointData2NV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: return typeof(VkPhysicalDeviceSynchronization2Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: return typeof(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: return typeof(VkPhysicalDeviceHostImageCopyFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: return typeof(VkPhysicalDeviceHostImageCopyProperties); + case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: return typeof(VkMemoryToImageCopy); + case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: return typeof(VkImageToMemoryCopy); + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: return typeof(VkCopyMemoryToImageInfo); + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: return typeof(VkCopyImageToMemoryInfo); + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: return typeof(VkCopyImageToImageInfo); + case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: return typeof(VkHostImageLayoutTransitionInfo); + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: return typeof(VkSubresourceHostMemcpySize); + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: return typeof(VkHostImageCopyDevicePerformanceQuery); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: return typeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: return typeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: return typeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: return typeof(VkSurfaceCapabilitiesPresentId2KHR); + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: return typeof(VkSurfaceCapabilitiesPresentWait2KHR); + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: return typeof(VkSubpassResolvePerformanceQueryEXT); + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: return typeof(VkMultisampledRenderToSingleSampledInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: return typeof(VkPhysicalDevicePipelineProtectedAccessFeatures); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: return typeof(VkQueueFamilyVideoPropertiesKHR); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: return typeof(VkQueueFamilyQueryResultStatusPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: return typeof(VkVideoProfileListInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: return typeof(VkPhysicalDeviceVideoFormatInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: return typeof(VkVideoFormatPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: return typeof(VkVideoEncodeQuantizationMapCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: return typeof(VkVideoEncodeH264QuantizationMapCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: return typeof(VkVideoEncodeH265QuantizationMapCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: return typeof(VkVideoEncodeAV1QuantizationMapCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: return typeof(VkVideoFormatQuantizationMapPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: return typeof(VkVideoFormatH265QuantizationMapPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: return typeof(VkVideoFormatAV1QuantizationMapPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: return typeof(VkVideoProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: return typeof(VkVideoCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: return typeof(VkVideoSessionMemoryRequirementsKHR); + case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: return typeof(VkBindVideoSessionMemoryInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: return typeof(VkVideoPictureResourceInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: return typeof(VkVideoReferenceSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: return typeof(VkVideoDecodeCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: return typeof(VkVideoDecodeUsageInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: return typeof(VkVideoDecodeInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoMaintenance1FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoMaintenance2FeaturesKHR); + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: return typeof(VkVideoInlineQueryInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: return typeof(VkVideoDecodeH264ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: return typeof(VkVideoDecodeH264CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: return typeof(VkVideoDecodeH264SessionParametersAddInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoDecodeH264SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: return typeof(VkVideoDecodeH264InlineSessionParametersInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: return typeof(VkVideoDecodeH264PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: return typeof(VkVideoDecodeH264DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: return typeof(VkVideoDecodeH265ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: return typeof(VkVideoDecodeH265CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: return typeof(VkVideoDecodeH265SessionParametersAddInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoDecodeH265SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: return typeof(VkVideoDecodeH265InlineSessionParametersInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: return typeof(VkVideoDecodeH265PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: return typeof(VkVideoDecodeH265DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: return typeof(VkVideoDecodeVP9ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: return typeof(VkVideoDecodeVP9CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: return typeof(VkVideoDecodeVP9PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: return typeof(VkVideoDecodeAV1ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: return typeof(VkVideoDecodeAV1CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoDecodeAV1SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: return typeof(VkVideoDecodeAV1InlineSessionParametersInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: return typeof(VkVideoDecodeAV1PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: return typeof(VkVideoDecodeAV1DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: return typeof(VkVideoSessionCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoSessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: return typeof(VkVideoSessionParametersUpdateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: return typeof(VkVideoEncodeSessionParametersGetInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return typeof(VkVideoEncodeSessionParametersFeedbackInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: return typeof(VkVideoBeginCodingInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: return typeof(VkVideoEndCodingInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: return typeof(VkVideoCodingControlInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: return typeof(VkVideoEncodeUsageInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: return typeof(VkVideoEncodeInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: return typeof(VkVideoEncodeQuantizationMapInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR); + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: return typeof(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: return typeof(VkVideoEncodeQualityLevelInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: return typeof(VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: return typeof(VkVideoEncodeQualityLevelPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: return typeof(VkVideoEncodeRateControlInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: return typeof(VkVideoEncodeRateControlLayerInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: return typeof(VkVideoEncodeCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: return typeof(VkVideoEncodeH264CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: return typeof(VkVideoEncodeH264QualityLevelPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: return typeof(VkVideoEncodeH264SessionCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: return typeof(VkVideoEncodeH264SessionParametersAddInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoEncodeH264SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: return typeof(VkVideoEncodeH264SessionParametersGetInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return typeof(VkVideoEncodeH264SessionParametersFeedbackInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: return typeof(VkVideoEncodeH264DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: return typeof(VkVideoEncodeH264PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: return typeof(VkVideoEncodeH264ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: return typeof(VkVideoEncodeH264NaluSliceInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: return typeof(VkVideoEncodeH264RateControlInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: return typeof(VkVideoEncodeH264GopRemainingFrameInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: return typeof(VkVideoEncodeH264RateControlLayerInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: return typeof(VkVideoEncodeH265CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: return typeof(VkVideoEncodeH265QualityLevelPropertiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: return typeof(VkVideoEncodeH265SessionCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: return typeof(VkVideoEncodeH265SessionParametersAddInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoEncodeH265SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: return typeof(VkVideoEncodeH265SessionParametersGetInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return typeof(VkVideoEncodeH265SessionParametersFeedbackInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: return typeof(VkVideoEncodeH265PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: return typeof(VkVideoEncodeH265NaluSliceSegmentInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: return typeof(VkVideoEncodeH265RateControlInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: return typeof(VkVideoEncodeH265GopRemainingFrameInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: return typeof(VkVideoEncodeH265RateControlLayerInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: return typeof(VkVideoEncodeH265ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: return typeof(VkVideoEncodeH265DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: return typeof(VkVideoEncodeAV1CapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: return typeof(VkVideoEncodeAV1QualityLevelPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: return typeof(VkVideoEncodeAV1SessionCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: return typeof(VkVideoEncodeAV1SessionParametersCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: return typeof(VkVideoEncodeAV1DpbSlotInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: return typeof(VkVideoEncodeAV1PictureInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: return typeof(VkVideoEncodeAV1ProfileInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: return typeof(VkVideoEncodeAV1RateControlInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: return typeof(VkVideoEncodeAV1GopRemainingFrameInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: return typeof(VkVideoEncodeAV1RateControlLayerInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: return typeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: return typeof(VkCommandBufferInheritanceViewportScissorInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: return typeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: return typeof(VkPhysicalDeviceProvokingVertexFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: return typeof(VkPhysicalDeviceProvokingVertexPropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: return typeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: return typeof(VkVideoEncodeIntraRefreshCapabilitiesKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: return typeof(VkVideoEncodeSessionIntraRefreshCreateInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: return typeof(VkVideoEncodeIntraRefreshInfoKHR); + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: return typeof(VkVideoReferenceIntraRefreshInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: return typeof(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR); + case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: return typeof(VkCuModuleCreateInfoNVX); + case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: return typeof(VkCuModuleTexturingModeCreateInfoNVX); + case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: return typeof(VkCuFunctionCreateInfoNVX); + case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: return typeof(VkCuLaunchInfoNVX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: return typeof(VkPhysicalDeviceDescriptorBufferFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: return typeof(VkPhysicalDeviceDescriptorBufferPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: return typeof(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT); + case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: return typeof(VkDescriptorAddressInfoEXT); + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: return typeof(VkDescriptorBufferBindingInfoEXT); + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: return typeof(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT); + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: return typeof(VkDescriptorGetInfoEXT); + case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: return typeof(VkBufferCaptureDescriptorDataInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: return typeof(VkImageCaptureDescriptorDataInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: return typeof(VkImageViewCaptureDescriptorDataInfoEXT); + case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: return typeof(VkSamplerCaptureDescriptorDataInfoEXT); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: return typeof(VkAccelerationStructureCaptureDescriptorDataInfoEXT); + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: return typeof(VkOpaqueCaptureDescriptorDataCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: return typeof(VkPhysicalDeviceShaderIntegerDotProductFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: return typeof(VkPhysicalDeviceShaderIntegerDotProductProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: return typeof(VkPhysicalDeviceDrmPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: return typeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: return typeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderFmaFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: return typeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: return typeof(VkPhysicalDeviceRayTracingValidationFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: return typeof(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: return typeof(VkAccelerationStructureGeometryMotionTrianglesDataNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: return typeof(VkAccelerationStructureMotionInfoNV); + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: return typeof(VkMemoryGetRemoteAddressInfoNV); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: return typeof(VkImportMemoryBufferCollectionFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: return typeof(VkBufferCollectionImageCreateInfoFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: return typeof(VkBufferCollectionBufferCreateInfoFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: return typeof(VkBufferCollectionCreateInfoFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: return typeof(VkBufferCollectionPropertiesFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: return typeof(VkBufferConstraintsInfoFUCHSIA); + case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: return typeof(VkSysmemColorSpaceFUCHSIA); + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: return typeof(VkImageFormatConstraintsInfoFUCHSIA); + case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: return typeof(VkImageConstraintsInfoFUCHSIA); + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: return typeof(VkBufferCollectionConstraintsInfoFUCHSIA); + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: return typeof(VkCudaModuleCreateInfoNV); + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: return typeof(VkCudaFunctionCreateInfoNV); + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: return typeof(VkCudaLaunchInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: return typeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: return typeof(VkFormatProperties3); + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: return typeof(VkDrmFormatModifierPropertiesList2EXT); + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: return typeof(VkAndroidHardwareBufferFormatProperties2ANDROID); + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: return typeof(VkPipelineRenderingCreateInfo); + case VK_STRUCTURE_TYPE_RENDERING_INFO: return typeof(VkRenderingInfo); + case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: return typeof(VkRenderingEndInfoKHR); + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: return typeof(VkRenderingAttachmentInfo); + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: return typeof(VkRenderingFragmentShadingRateAttachmentInfoKHR); + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: return typeof(VkRenderingFragmentDensityMapAttachmentInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: return typeof(VkPhysicalDeviceDynamicRenderingFeatures); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: return typeof(VkCommandBufferInheritanceRenderingInfo); + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: return typeof(VkAttachmentSampleCountInfoAMD); + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: return typeof(VkMultiviewPerViewAttributesInfoNVX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: return typeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: return typeof(VkImageViewMinLodCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: return typeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: return typeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: return typeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: return typeof(VkPhysicalDevicePipelineBinaryFeaturesKHR); + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: return typeof(VkDevicePipelineBinaryInternalCacheControlKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: return typeof(VkPhysicalDevicePipelineBinaryPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: return typeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT); + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: return typeof(VkGraphicsPipelineLibraryCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: return typeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: return typeof(VkDescriptorSetBindingReferenceVALVE); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: return typeof(VkDescriptorSetLayoutHostMappingInfoVALVE); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: return typeof(VkPhysicalDeviceNestedCommandBufferFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: return typeof(VkPhysicalDeviceNestedCommandBufferPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: return typeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: return typeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT); + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: return typeof(VkShaderModuleIdentifierEXT); + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: return typeof(VkImageCompressionControlEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: return typeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT); + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: return typeof(VkImageCompressionPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: return typeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT); + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: return typeof(VkImageSubresource2); + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: return typeof(VkSubresourceLayout2); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: return typeof(VkRenderPassCreationControlEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: return typeof(VkRenderPassCreationFeedbackCreateInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: return typeof(VkRenderPassSubpassFeedbackCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: return typeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT); + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: return typeof(VkMicromapBuildInfoEXT); + case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: return typeof(VkMicromapCreateInfoEXT); + case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: return typeof(VkMicromapVersionInfoEXT); + case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: return typeof(VkCopyMicromapInfoEXT); + case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: return typeof(VkCopyMicromapToMemoryInfoEXT); + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: return typeof(VkCopyMemoryToMicromapInfoEXT); + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: return typeof(VkMicromapBuildSizesInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: return typeof(VkPhysicalDeviceOpacityMicromapFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: return typeof(VkPhysicalDeviceOpacityMicromapPropertiesEXT); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: return typeof(VkAccelerationStructureTrianglesOpacityMicromapEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: return typeof(VkPhysicalDeviceDisplacementMicromapFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: return typeof(VkPhysicalDeviceDisplacementMicromapPropertiesNV); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: return typeof(VkAccelerationStructureTrianglesDisplacementMicromapNV); + case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: return typeof(VkPipelinePropertiesIdentifierEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: return typeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: return typeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: return typeof(VkExternalMemoryAcquireUnmodifiedEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: return typeof(VkExportMetalObjectCreateInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: return typeof(VkExportMetalObjectsInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: return typeof(VkExportMetalDeviceInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: return typeof(VkExportMetalCommandQueueInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: return typeof(VkExportMetalBufferInfoEXT); + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: return typeof(VkImportMetalBufferInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: return typeof(VkExportMetalTextureInfoEXT); + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: return typeof(VkImportMetalTextureInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: return typeof(VkExportMetalIOSurfaceInfoEXT); + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: return typeof(VkImportMetalIOSurfaceInfoEXT); + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: return typeof(VkExportMetalSharedEventInfoEXT); + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: return typeof(VkImportMetalSharedEventInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: return typeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: return typeof(VkPhysicalDevicePipelineRobustnessFeatures); + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: return typeof(VkPipelineRobustnessCreateInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: return typeof(VkPhysicalDevicePipelineRobustnessProperties); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: return typeof(VkImageViewSampleWeightCreateInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: return typeof(VkPhysicalDeviceImageProcessingFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: return typeof(VkPhysicalDeviceImageProcessingPropertiesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: return typeof(VkPhysicalDeviceTilePropertiesFeaturesQCOM); + case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: return typeof(VkTilePropertiesQCOM); + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: return typeof(VkTileMemoryBindInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: return typeof(VkPhysicalDeviceAmigoProfilingFeaturesSEC); + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: return typeof(VkAmigoProfilingSubmitInfoSEC); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: return typeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT); + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: return typeof(VkAttachmentFeedbackLoopInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: return typeof(VkPhysicalDeviceAddressBindingReportFeaturesEXT); + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: return typeof(VkRenderingAttachmentFlagsInfoKHR); + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: return typeof(VkResolveImageModeInfoKHR); + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: return typeof(VkDeviceAddressBindingCallbackDataEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: return typeof(VkPhysicalDeviceOpticalFlowFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: return typeof(VkPhysicalDeviceOpticalFlowPropertiesNV); + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: return typeof(VkOpticalFlowImageFormatInfoNV); + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: return typeof(VkOpticalFlowImageFormatPropertiesNV); + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: return typeof(VkOpticalFlowSessionCreateInfoNV); + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: return typeof(VkOpticalFlowSessionCreatePrivateDataInfoNV); + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: return typeof(VkOpticalFlowExecuteInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: return typeof(VkPhysicalDeviceFaultFeaturesEXT); + case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: return typeof(VkDeviceFaultCountsEXT); + case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: return typeof(VkDeviceFaultInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: return typeof(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT); + case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: return typeof(VkDepthBiasInfoEXT); + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: return typeof(VkDepthBiasRepresentationInfoEXT); + case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: return typeof(VkDecompressMemoryInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: return typeof(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: return typeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM); + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: return typeof(VkFrameBoundaryEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: return typeof(VkPhysicalDeviceFrameBoundaryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: return typeof(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT); + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: return typeof(VkSurfacePresentModeKHR); + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: return typeof(VkSurfacePresentScalingCapabilitiesKHR); + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: return typeof(VkSurfacePresentModeCompatibilityKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: return typeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR); + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: return typeof(VkSwapchainPresentFenceInfoKHR); + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: return typeof(VkSwapchainPresentModesCreateInfoKHR); + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: return typeof(VkSwapchainPresentModeInfoKHR); + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: return typeof(VkSwapchainPresentScalingCreateInfoKHR); + case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: return typeof(VkReleaseSwapchainImagesInfoKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: return typeof(VkPhysicalDeviceDepthBiasControlFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: return typeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: return typeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: return typeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: return typeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: return typeof(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: return typeof(VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV); + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: return typeof(VkDirectDriverLoadingInfoLUNARG); + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: return typeof(VkDirectDriverLoadingListLUNARG); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: return typeof(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: return typeof(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR); + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: return typeof(VkDeviceImageSubresourceInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: return typeof(VkPhysicalDeviceShaderCorePropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: return typeof(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM); + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: return typeof(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM); + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: return typeof(VkQueryLowLatencySupportNV); + case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: return typeof(VkMemoryMapInfo); + case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: return typeof(VkMemoryUnmapInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderObjectFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: return typeof(VkPhysicalDeviceShaderObjectPropertiesEXT); + case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: return typeof(VkShaderCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderTileImageFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: return typeof(VkPhysicalDeviceShaderTileImagePropertiesEXT); + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: return typeof(VkImportScreenBufferInfoQNX); + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: return typeof(VkScreenBufferPropertiesQNX); + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: return typeof(VkScreenBufferFormatPropertiesQNX); + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: return typeof(VkExternalFormatQNX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: return typeof(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: return typeof(VkPhysicalDeviceCooperativeMatrixFeaturesKHR); + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: return typeof(VkCooperativeMatrixPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: return typeof(VkPhysicalDeviceCooperativeMatrixPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: return typeof(VkPhysicalDeviceShaderEnqueuePropertiesAMDX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: return typeof(VkPhysicalDeviceShaderEnqueueFeaturesAMDX); + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: return typeof(VkExecutionGraphPipelineCreateInfoAMDX); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: return typeof(VkPipelineShaderStageNodeCreateInfoAMDX); + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: return typeof(VkExecutionGraphPipelineScratchSizeAMDX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: return typeof(VkPhysicalDeviceAntiLagFeaturesAMD); + case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: return typeof(VkAntiLagDataAMD); + case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: return typeof(VkAntiLagPresentationInfoAMD); + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: return typeof(VkBindMemoryStatus); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: return typeof(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: return typeof(VkPhysicalDeviceTileMemoryHeapPropertiesQCOM); + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: return typeof(VkTileMemorySizeInfoQCOM); + case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: return typeof(VkTileMemoryRequirementsQCOM); + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: return typeof(VkBindDescriptorSetsInfo); + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: return typeof(VkPushConstantsInfo); + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: return typeof(VkPushDescriptorSetInfo); + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: return typeof(VkPushDescriptorSetWithTemplateInfo); + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: return typeof(VkSetDescriptorBufferOffsetsInfoEXT); + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: return typeof(VkBindDescriptorBufferEmbeddedSamplersInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: return typeof(VkPhysicalDeviceCubicClampFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: return typeof(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: return typeof(VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: return typeof(VkPhysicalDeviceCubicWeightsFeaturesQCOM); + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: return typeof(VkSamplerCubicWeightsCreateInfoQCOM); + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: return typeof(VkBlitImageCubicWeightsInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: return typeof(VkPhysicalDeviceImageProcessing2FeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: return typeof(VkPhysicalDeviceImageProcessing2PropertiesQCOM); + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: return typeof(VkSamplerBlockMatchWindowCreateInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: return typeof(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: return typeof(VkPhysicalDeviceLayeredDriverPropertiesMSFT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: return typeof(VkPhysicalDevicePerStageDescriptorSetFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: return typeof(VkPhysicalDeviceExternalFormatResolveFeaturesANDROID); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: return typeof(VkPhysicalDeviceExternalFormatResolvePropertiesANDROID); + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: return typeof(VkAndroidHardwareBufferFormatResolvePropertiesANDROID); + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: return typeof(VkLatencySleepModeInfoNV); + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: return typeof(VkLatencySleepInfoNV); + case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: return typeof(VkSetLatencyMarkerInfoNV); + case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: return typeof(VkGetLatencyMarkerInfoNV); + case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: return typeof(VkLatencyTimingsFrameReportNV); + case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: return typeof(VkOutOfBandQueueTypeInfoNV); + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: return typeof(VkLatencySubmissionPresentIdNV); + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: return typeof(VkSwapchainLatencyCreateInfoNV); + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: return typeof(VkLatencySurfaceCapabilitiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: return typeof(VkPhysicalDeviceCudaKernelLaunchFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: return typeof(VkPhysicalDeviceCudaKernelLaunchPropertiesNV); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: return typeof(VkDeviceQueueShaderCoreControlCreateInfoARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: return typeof(VkPhysicalDeviceSchedulingControlsFeaturesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: return typeof(VkPhysicalDeviceSchedulingControlsPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: return typeof(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: return typeof(VkPhysicalDeviceRenderPassStripedFeaturesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: return typeof(VkPhysicalDeviceRenderPassStripedPropertiesARM); + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: return typeof(VkRenderPassStripeInfoARM); + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: return typeof(VkRenderPassStripeBeginInfoARM); + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: return typeof(VkRenderPassStripeSubmitInfoARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: return typeof(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: return typeof(VkPhysicalDeviceShaderSubgroupRotateFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: return typeof(VkPhysicalDeviceShaderExpectAssumeFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: return typeof(VkPhysicalDeviceShaderFloatControls2Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: return typeof(VkPhysicalDeviceDynamicRenderingLocalReadFeatures); + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: return typeof(VkRenderingAttachmentLocationInfo); + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: return typeof(VkRenderingInputAttachmentIndexInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderQuadControlFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: return typeof(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: return typeof(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: return typeof(VkPhysicalDeviceMapMemoryPlacedPropertiesEXT); + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: return typeof(VkMemoryMapPlacedInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderBfloat16FeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: return typeof(VkPhysicalDeviceRawAccessChainsFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: return typeof(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: return typeof(VkPhysicalDeviceImageAlignmentControlFeaturesMESA); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: return typeof(VkPhysicalDeviceImageAlignmentControlPropertiesMESA); + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: return typeof(VkImageAlignmentControlCreateInfoMESA); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: return typeof(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: return typeof(VkPhysicalDeviceCooperativeMatrix2FeaturesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: return typeof(VkPhysicalDeviceCooperativeMatrix2PropertiesNV); + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: return typeof(VkCooperativeMatrixFlexibleDimensionsPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: return typeof(VkPhysicalDeviceHdrVividFeaturesHUAWEI); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: return typeof(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: return typeof(VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX); + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: return typeof(VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: return typeof(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: return typeof(VkPhysicalDeviceCooperativeVectorFeaturesNV); + case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: return typeof(VkCooperativeVectorPropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: return typeof(VkPhysicalDeviceCooperativeVectorPropertiesNV); + case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: return typeof(VkConvertCooperativeVectorMatrixInfoNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: return typeof(VkPhysicalDeviceTileShadingFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: return typeof(VkPhysicalDeviceTileShadingPropertiesQCOM); + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: return typeof(VkRenderPassTileShadingCreateInfoQCOM); + case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: return typeof(VkPerTileBeginInfoQCOM); + case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: return typeof(VkPerTileEndInfoQCOM); + case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: return typeof(VkDispatchTileInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: return typeof(VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: return typeof(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE); + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: return typeof(VkPipelineFragmentDensityMapLayeredCreateInfoVALVE); + case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV: return typeof(VkSetPresentConfigNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: return typeof(VkPhysicalDevicePresentMeteringFeaturesNV); + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: return typeof(VkExternalComputeQueueDeviceCreateInfoNV); + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: return typeof(VkExternalComputeQueueCreateInfoNV); + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: return typeof(VkExternalComputeQueueDataParamsNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: return typeof(VkPhysicalDeviceExternalComputeQueuePropertiesNV); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: return typeof(VkPhysicalDeviceFormatPackFeaturesARM); + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: return typeof(VkTensorDescriptionARM); + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: return typeof(VkTensorCreateInfoARM); + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: return typeof(VkTensorViewCreateInfoARM); + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: return typeof(VkTensorMemoryRequirementsInfoARM); + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: return typeof(VkBindTensorMemoryInfoARM); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: return typeof(VkWriteDescriptorSetTensorARM); + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: return typeof(VkTensorFormatPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: return typeof(VkPhysicalDeviceTensorPropertiesARM); + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: return typeof(VkTensorMemoryBarrierARM); + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: return typeof(VkTensorDependencyInfoARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: return typeof(VkPhysicalDeviceTensorFeaturesARM); + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: return typeof(VkDeviceTensorMemoryRequirementsARM); + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: return typeof(VkCopyTensorInfoARM); + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: return typeof(VkTensorCopyARM); + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: return typeof(VkMemoryDedicatedAllocateInfoTensorARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: return typeof(VkPhysicalDeviceDescriptorBufferTensorPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: return typeof(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM); + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: return typeof(VkTensorCaptureDescriptorDataInfoARM); + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: return typeof(VkTensorViewCaptureDescriptorDataInfoARM); + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: return typeof(VkDescriptorGetTensorInfoARM); + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: return typeof(VkFrameBoundaryTensorsARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: return typeof(VkPhysicalDeviceExternalTensorInfoARM); + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: return typeof(VkExternalTensorPropertiesARM); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: return typeof(VkExternalMemoryTensorCreateInfoARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: return typeof(VkPhysicalDeviceShaderFloat8FeaturesEXT); + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: return typeof(VkSurfaceCreateInfoOHOS); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: return typeof(VkPhysicalDeviceDataGraphFeaturesARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: return typeof(VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: return typeof(VkDataGraphPipelineConstantARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: return typeof(VkDataGraphPipelineResourceInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: return typeof(VkDataGraphPipelineCompilerControlCreateInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: return typeof(VkDataGraphPipelineCreateInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: return typeof(VkDataGraphPipelineShaderModuleCreateInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: return typeof(VkDataGraphPipelineSessionCreateInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: return typeof(VkDataGraphPipelineSessionBindPointRequirementsInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: return typeof(VkDataGraphPipelineSessionBindPointRequirementARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: return typeof(VkDataGraphPipelineSessionMemoryRequirementsInfoARM); + case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: return typeof(VkBindDataGraphPipelineSessionMemoryInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: return typeof(VkDataGraphPipelineInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: return typeof(VkDataGraphPipelinePropertyQueryResultARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: return typeof(VkDataGraphPipelineIdentifierCreateInfoARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: return typeof(VkDataGraphPipelineDispatchInfoARM); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: return typeof(VkQueueFamilyDataGraphPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: return typeof(VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: return typeof(VkQueueFamilyDataGraphProcessingEnginePropertiesARM); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: return typeof(VkDataGraphProcessingEngineCreateInfoARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: return typeof(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC); + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: return typeof(VkDataGraphPipelineBuiltinModelCreateInfoQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: return typeof(VkPhysicalDeviceDataGraphModelFeaturesQCOM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: return typeof(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR); + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS: return typeof(VkNativeBufferOHOS); + case VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS: return typeof(VkSwapchainImageCreateInfoOHOS); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS: return typeof(VkPhysicalDevicePresentationPropertiesOHOS); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: return typeof(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: return typeof(VkVideoEncodeRgbConversionCapabilitiesVALVE); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: return typeof(VkVideoEncodeProfileRgbConversionInfoVALVE); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: return typeof(VkVideoEncodeSessionRgbConversionCreateInfoVALVE); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: return typeof(VkPhysicalDeviceShader64BitIndexingFeaturesEXT); + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: return typeof(VkNativeBufferUsageOHOS); + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: return typeof(VkNativeBufferPropertiesOHOS); + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: return typeof(VkNativeBufferFormatPropertiesOHOS); + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: return typeof(VkImportNativeBufferInfoOHOS); + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: return typeof(VkMemoryGetNativeBufferInfoOHOS); + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: return typeof(VkExternalFormatOHOS); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: return typeof(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: return typeof(VkPhysicalDevicePerformanceCountersByRegionPropertiesARM); + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: return typeof(VkPerformanceCounterARM); + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: return typeof(VkPerformanceCounterDescriptionARM); + case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: return typeof(VkRenderPassPerformanceCountersByRegionBeginInfoARM); + default: return default; + } + } + } +} + +extension VkObjectType +{ + public Type Type + { + get + { + switch (this) + { + case VK_OBJECT_TYPE_INSTANCE: return typeof(VkInstance); + case VK_OBJECT_TYPE_PHYSICAL_DEVICE: return typeof(VkPhysicalDevice); + case VK_OBJECT_TYPE_DEVICE: return typeof(VkDevice); + case VK_OBJECT_TYPE_QUEUE: return typeof(VkQueue); + case VK_OBJECT_TYPE_COMMAND_BUFFER: return typeof(VkCommandBuffer); + case VK_OBJECT_TYPE_DEVICE_MEMORY: return typeof(VkDeviceMemory); + case VK_OBJECT_TYPE_COMMAND_POOL: return typeof(VkCommandPool); + case VK_OBJECT_TYPE_BUFFER: return typeof(VkBuffer); + case VK_OBJECT_TYPE_BUFFER_VIEW: return typeof(VkBufferView); + case VK_OBJECT_TYPE_IMAGE: return typeof(VkImage); + case VK_OBJECT_TYPE_IMAGE_VIEW: return typeof(VkImageView); + case VK_OBJECT_TYPE_SHADER_MODULE: return typeof(VkShaderModule); + case VK_OBJECT_TYPE_PIPELINE: return typeof(VkPipeline); + case VK_OBJECT_TYPE_PIPELINE_LAYOUT: return typeof(VkPipelineLayout); + case VK_OBJECT_TYPE_SAMPLER: return typeof(VkSampler); + case VK_OBJECT_TYPE_DESCRIPTOR_SET: return typeof(VkDescriptorSet); + case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: return typeof(VkDescriptorSetLayout); + case VK_OBJECT_TYPE_DESCRIPTOR_POOL: return typeof(VkDescriptorPool); + case VK_OBJECT_TYPE_FENCE: return typeof(VkFence); + case VK_OBJECT_TYPE_SEMAPHORE: return typeof(VkSemaphore); + case VK_OBJECT_TYPE_EVENT: return typeof(VkEvent); + case VK_OBJECT_TYPE_QUERY_POOL: return typeof(VkQueryPool); + case VK_OBJECT_TYPE_FRAMEBUFFER: return typeof(VkFramebuffer); + case VK_OBJECT_TYPE_RENDER_PASS: return typeof(VkRenderPass); + case VK_OBJECT_TYPE_PIPELINE_CACHE: return typeof(VkPipelineCache); + case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: return typeof(VkPipelineBinaryKHR); + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: return typeof(VkIndirectCommandsLayoutNV); + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: return typeof(VkIndirectCommandsLayoutEXT); + case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: return typeof(VkIndirectExecutionSetEXT); + case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: return typeof(VkDescriptorUpdateTemplate); + case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: return typeof(VkSamplerYcbcrConversion); + case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: return typeof(VkValidationCacheEXT); + case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: return typeof(VkAccelerationStructureKHR); + case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: return typeof(VkAccelerationStructureNV); + case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: return typeof(VkPerformanceConfigurationINTEL); + case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: return typeof(VkBufferCollectionFUCHSIA); + case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: return typeof(VkDeferredOperationKHR); + case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: return typeof(VkPrivateDataSlot); + case VK_OBJECT_TYPE_CU_MODULE_NVX: return typeof(VkCuModuleNVX); + case VK_OBJECT_TYPE_CU_FUNCTION_NVX: return typeof(VkCuFunctionNVX); + case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: return typeof(VkOpticalFlowSessionNV); + case VK_OBJECT_TYPE_MICROMAP_EXT: return typeof(VkMicromapEXT); + case VK_OBJECT_TYPE_SHADER_EXT: return typeof(VkShaderEXT); + case VK_OBJECT_TYPE_TENSOR_ARM: return typeof(VkTensorARM); + case VK_OBJECT_TYPE_TENSOR_VIEW_ARM: return typeof(VkTensorViewARM); + case VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: return typeof(VkDataGraphPipelineSessionARM); + case VK_OBJECT_TYPE_DISPLAY_KHR: return typeof(VkDisplayKHR); + case VK_OBJECT_TYPE_DISPLAY_MODE_KHR: return typeof(VkDisplayModeKHR); + case VK_OBJECT_TYPE_SURFACE_KHR: return typeof(VkSurfaceKHR); + case VK_OBJECT_TYPE_SWAPCHAIN_KHR: return typeof(VkSwapchainKHR); + case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: return typeof(VkDebugReportCallbackEXT); + case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: return typeof(VkDebugUtilsMessengerEXT); + case VK_OBJECT_TYPE_VIDEO_SESSION_KHR: return typeof(VkVideoSessionKHR); + case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: return typeof(VkVideoSessionParametersKHR); + case VK_OBJECT_TYPE_CUDA_MODULE_NV: return typeof(VkCudaModuleNV); + case VK_OBJECT_TYPE_CUDA_FUNCTION_NV: return typeof(VkCudaFunctionNV); + case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: return typeof(VkExternalComputeQueueNV); + default: return default; + } + } + } +} + diff --git a/src/Video.bf b/src/Video.bf new file mode 100644 index 0000000..6c96f27 --- /dev/null +++ b/src/Video.bf @@ -0,0 +1,3604 @@ +// This file was generated by Setup/Program.bf +// Based on video.xml + +using System; +using System.Interop; + +using Vulkan; + +namespace Vulkan.Video; + +// protect with VULKAN_VIDEO_CODEC_COMMON_H_ +static { public static uint32 VK_MAKE_VIDEO_STD_VERSION(uint32 major, uint32 minor, uint32 patch) => + ((((uint32)(major)) << 22) | (((uint32)(minor)) << 12) | ((uint32)(patch))); } + +// protect with VULKAN_VIDEO_CODEC_H264STD_H_ +static { public const uint32 STD_VIDEO_H264_CPB_CNT_LIST_SIZE = 32; } +static { public const uint32 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS = 6; } +static { public const uint32 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS = 16; } +static { public const uint32 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS = 6; } +static { public const uint32 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS = 64; } +static { public const uint32 STD_VIDEO_H264_MAX_NUM_LIST_REF = 32; } +static { public const uint32 STD_VIDEO_H264_MAX_CHROMA_PLANES = 2; } +static { public const uint8 STD_VIDEO_H264_NO_REFERENCE_PICTURE = 0xFF; } + +[AllowDuplicates] enum StdVideoH264ChromaFormatIdc : int32 +{ + [NoShow] STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + [NoShow] STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + [NoShow] STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + [NoShow] STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + [NoShow] STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Monochrome = 0, + _420 = 1, + _422 = 2, + _444 = 3, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264ProfileIdc : int32 +{ + [NoShow] STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, // Only constrained baseline is supported + [NoShow] STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + [NoShow] STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + [NoShow] STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + [NoShow] STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Baseline = 66, // Only constrained baseline is supported + Main = 77, + High = 100, + High444_Predictive = 244, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264LevelIdc : int32 +{ + [NoShow] STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, + [NoShow] STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, + // pretty names + _1_0 = 0, + _1_1 = 1, + _1_2 = 2, + _1_3 = 3, + _2_0 = 4, + _2_1 = 5, + _2_2 = 6, + _3_0 = 7, + _3_1 = 8, + _3_2 = 9, + _4_0 = 10, + _4_1 = 11, + _4_2 = 12, + _5_0 = 13, + _5_1 = 14, + _5_2 = 15, + _6_0 = 16, + _6_1 = 17, + _6_2 = 18, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264PocType : int32 +{ + [NoShow] STD_VIDEO_H264_POC_TYPE_0 = 0, + [NoShow] STD_VIDEO_H264_POC_TYPE_1 = 1, + [NoShow] STD_VIDEO_H264_POC_TYPE_2 = 2, + [NoShow] STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + _0 = 0, + _1 = 1, + _2 = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264AspectRatioIdc : int32 +{ + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + [NoShow] STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Unspecified = 0, + Square = 1, + _12_11 = 2, + _10_11 = 3, + _16_11 = 4, + _40_33 = 5, + _24_11 = 6, + _20_11 = 7, + _32_11 = 8, + _80_33 = 9, + _18_11 = 10, + _15_11 = 11, + _64_33 = 12, + _160_99 = 13, + _4_3 = 14, + _3_2 = 15, + _2_1 = 16, + ExtendedSar = 255, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264WeightedBipredIdc : int32 +{ + [NoShow] STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + [NoShow] STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, + [NoShow] STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, + [NoShow] STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Default = 0, + Explicit = 1, + Implicit = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264ModificationOfPicNumsIdc : int32 +{ + [NoShow] STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, + [NoShow] STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, + [NoShow] STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, + [NoShow] STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, + [NoShow] STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + // pretty names + ShortTermSubtract = 0, + ShortTermAdd = 1, + LongTerm = 2, + End = 3, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264MemMgmtControlOp : int32 +{ + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, + [NoShow] STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + // pretty names + End = 0, + UnmarkShortTerm = 1, + UnmarkLongTerm = 2, + MarkLongTerm = 3, + SetMaxLongTermIndex = 4, + UnmarkAll = 5, + MarkCurrentAsLongTerm = 6, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264CabacInitIdc : int32 +{ + [NoShow] STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, + [NoShow] STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, + [NoShow] STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, + [NoShow] STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + // pretty names + _0 = 0, + _1 = 1, + _2 = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264DisableDeblockingFilterIdc : int32 +{ + [NoShow] STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, + [NoShow] STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, + [NoShow] STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, + [NoShow] STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Disabled = 0, + Enabled = 1, + Partial = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264SliceType : int32 +{ + [NoShow] STD_VIDEO_H264_SLICE_TYPE_P = 0, + [NoShow] STD_VIDEO_H264_SLICE_TYPE_B = 1, + [NoShow] STD_VIDEO_H264_SLICE_TYPE_I = 2, + [NoShow] STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + P = 0, + B = 1, + I = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264PictureType : int32 +{ + [NoShow] STD_VIDEO_H264_PICTURE_TYPE_P = 0, + [NoShow] STD_VIDEO_H264_PICTURE_TYPE_B = 1, + [NoShow] STD_VIDEO_H264_PICTURE_TYPE_I = 2, + [NoShow] STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, + [NoShow] STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + P = 0, + B = 1, + I = 2, + Idr = 5, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH264NonVclNaluType : int32 +{ + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, + [NoShow] STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + Sps = 0, + Pps = 1, + Aud = 2, + Prefix = 3, + EndOfSequence = 4, + EndOfStream = 5, + Precoded = 6, + Invalid = 0x7FFFFFFF, +} + +[CRepr] struct StdVideoH264SpsVuiFlags : this() +{ + [Bitfield(.Public, .Bits(1), "aspect_ratio_info_present_flag")] + [Bitfield(.Public, .Bits(1), "overscan_info_present_flag")] + [Bitfield(.Public, .Bits(1), "overscan_appropriate_flag")] + [Bitfield(.Public, .Bits(1), "video_signal_type_present_flag")] + [Bitfield(.Public, .Bits(1), "video_full_range_flag")] + [Bitfield(.Public, .Bits(1), "color_description_present_flag")] + + [Bitfield(.Public, .Bits(1), "chroma_loc_info_present_flag")] + [Bitfield(.Public, .Bits(1), "timing_info_present_flag")] + [Bitfield(.Public, .Bits(1), "fixed_frame_rate_flag")] + [Bitfield(.Public, .Bits(1), "bitstream_restriction_flag")] + [Bitfield(.Public, .Bits(1), "nal_hrd_parameters_present_flag")] + [Bitfield(.Public, .Bits(1), "vcl_hrd_parameters_present_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 aspect_ratio_info_present_flag, uint32 overscan_info_present_flag, uint32 overscan_appropriate_flag, uint32 video_signal_type_present_flag, uint32 video_full_range_flag, uint32 color_description_present_flag, uint32 chroma_loc_info_present_flag, uint32 timing_info_present_flag, uint32 fixed_frame_rate_flag, uint32 bitstream_restriction_flag, uint32 nal_hrd_parameters_present_flag, uint32 vcl_hrd_parameters_present_flag) : this() + { + this.aspect_ratio_info_present_flag = aspect_ratio_info_present_flag; + this.overscan_info_present_flag = overscan_info_present_flag; + this.overscan_appropriate_flag = overscan_appropriate_flag; + this.video_signal_type_present_flag = video_signal_type_present_flag; + this.video_full_range_flag = video_full_range_flag; + this.color_description_present_flag = color_description_present_flag; + this.chroma_loc_info_present_flag = chroma_loc_info_present_flag; + this.timing_info_present_flag = timing_info_present_flag; + this.fixed_frame_rate_flag = fixed_frame_rate_flag; + this.bitstream_restriction_flag = bitstream_restriction_flag; + this.nal_hrd_parameters_present_flag = nal_hrd_parameters_present_flag; + this.vcl_hrd_parameters_present_flag = vcl_hrd_parameters_present_flag; + } +} + +// hrd_parameters +[CRepr] struct StdVideoH264HrdParameters : this() +{ + public uint8 cpb_cnt_minus1 = 0; + public uint8 bit_rate_scale = 0; + public uint8 cpb_size_scale = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint32[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] bit_rate_value_minus1 = .(); // cpb_cnt_minus1 number of valid elements + public uint32[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] cpb_size_value_minus1 = .(); // cpb_cnt_minus1 number of valid elements + public uint8[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] cbr_flag = .(); // cpb_cnt_minus1 number of valid elements + public uint32 initial_cpb_removal_delay_length_minus1 = 0; + public uint32 cpb_removal_delay_length_minus1 = 0; + public uint32 dpb_output_delay_length_minus1 = 0; + public uint32 time_offset_length = 0; + + public this(uint8 cpb_cnt_minus1, uint8 bit_rate_scale, uint8 cpb_size_scale, uint8 reserved1, uint32[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] bit_rate_value_minus1, uint32[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] cpb_size_value_minus1, uint8[STD_VIDEO_H264_CPB_CNT_LIST_SIZE] cbr_flag, uint32 initial_cpb_removal_delay_length_minus1, uint32 cpb_removal_delay_length_minus1, uint32 dpb_output_delay_length_minus1, uint32 time_offset_length) : this() + { + this.cpb_cnt_minus1 = cpb_cnt_minus1; + this.bit_rate_scale = bit_rate_scale; + this.cpb_size_scale = cpb_size_scale; + this.reserved1 = reserved1; + this.bit_rate_value_minus1 = bit_rate_value_minus1; + this.cpb_size_value_minus1 = cpb_size_value_minus1; + this.cbr_flag = cbr_flag; + this.initial_cpb_removal_delay_length_minus1 = initial_cpb_removal_delay_length_minus1; + this.cpb_removal_delay_length_minus1 = cpb_removal_delay_length_minus1; + this.dpb_output_delay_length_minus1 = dpb_output_delay_length_minus1; + this.time_offset_length = time_offset_length; + } +} + +[CRepr] struct StdVideoH264SequenceParameterSetVui : this() +{ + public StdVideoH264SpsVuiFlags flags = default; + public StdVideoH264AspectRatioIdc aspect_ratio_idc = default; + public uint16 sar_width = 0; + public uint16 sar_height = 0; + public uint8 video_format = 0; + public uint8 colour_primaries = 0; + public uint8 transfer_characteristics = 0; + public uint8 matrix_coefficients = 0; + public uint32 num_units_in_tick = 0; + public uint32 time_scale = 0; + public uint8 max_num_reorder_frames = 0; + public uint8 max_dec_frame_buffering = 0; + public uint8 chroma_sample_loc_type_top_field = 0; + public uint8 chroma_sample_loc_type_bottom_field = 0; + public uint32 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoH264HrdParameters* pHrdParameters = null; // must be a valid ptr to hrd_parameters, if nal_hrd_parameters_present_flag or vcl_hrd_parameters_present_flag are set + + public this(StdVideoH264SpsVuiFlags flags, StdVideoH264AspectRatioIdc aspect_ratio_idc, uint16 sar_width, uint16 sar_height, uint8 video_format, uint8 colour_primaries, uint8 transfer_characteristics, uint8 matrix_coefficients, uint32 num_units_in_tick, uint32 time_scale, uint8 max_num_reorder_frames, uint8 max_dec_frame_buffering, uint8 chroma_sample_loc_type_top_field, uint8 chroma_sample_loc_type_bottom_field, uint32 reserved1, StdVideoH264HrdParameters* pHrdParameters = null) : this() + { + this.flags = flags; + this.aspect_ratio_idc = aspect_ratio_idc; + this.sar_width = sar_width; + this.sar_height = sar_height; + this.video_format = video_format; + this.colour_primaries = colour_primaries; + this.transfer_characteristics = transfer_characteristics; + this.matrix_coefficients = matrix_coefficients; + this.num_units_in_tick = num_units_in_tick; + this.time_scale = time_scale; + this.max_num_reorder_frames = max_num_reorder_frames; + this.max_dec_frame_buffering = max_dec_frame_buffering; + this.chroma_sample_loc_type_top_field = chroma_sample_loc_type_top_field; + this.chroma_sample_loc_type_bottom_field = chroma_sample_loc_type_bottom_field; + this.reserved1 = reserved1; + this.pHrdParameters = pHrdParameters; + } +} + +[CRepr] struct StdVideoH264SpsFlags : this() +{ + [Bitfield(.Public, .Bits(1), "constraint_set0_flag")] + [Bitfield(.Public, .Bits(1), "constraint_set1_flag")] + [Bitfield(.Public, .Bits(1), "constraint_set2_flag")] + [Bitfield(.Public, .Bits(1), "constraint_set3_flag")] + [Bitfield(.Public, .Bits(1), "constraint_set4_flag")] + [Bitfield(.Public, .Bits(1), "constraint_set5_flag")] + [Bitfield(.Public, .Bits(1), "direct_8x8_inference_flag")] + [Bitfield(.Public, .Bits(1), "mb_adaptive_frame_field_flag")] + [Bitfield(.Public, .Bits(1), "frame_mbs_only_flag")] + [Bitfield(.Public, .Bits(1), "delta_pic_order_always_zero_flag")] + [Bitfield(.Public, .Bits(1), "separate_colour_plane_flag")] + [Bitfield(.Public, .Bits(1), "gaps_in_frame_num_value_allowed_flag")] + [Bitfield(.Public, .Bits(1), "qpprime_y_zero_transform_bypass_flag")] + [Bitfield(.Public, .Bits(1), "frame_cropping_flag")] + [Bitfield(.Public, .Bits(1), "seq_scaling_matrix_present_flag")] + [Bitfield(.Public, .Bits(1), "vui_parameters_present_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 constraint_set0_flag, uint32 constraint_set1_flag, uint32 constraint_set2_flag, uint32 constraint_set3_flag, uint32 constraint_set4_flag, uint32 constraint_set5_flag, uint32 direct_8x8_inference_flag, uint32 mb_adaptive_frame_field_flag, uint32 frame_mbs_only_flag, uint32 delta_pic_order_always_zero_flag, uint32 separate_colour_plane_flag, uint32 gaps_in_frame_num_value_allowed_flag, uint32 qpprime_y_zero_transform_bypass_flag, uint32 frame_cropping_flag, uint32 seq_scaling_matrix_present_flag, uint32 vui_parameters_present_flag) : this() + { + this.constraint_set0_flag = constraint_set0_flag; + this.constraint_set1_flag = constraint_set1_flag; + this.constraint_set2_flag = constraint_set2_flag; + this.constraint_set3_flag = constraint_set3_flag; + this.constraint_set4_flag = constraint_set4_flag; + this.constraint_set5_flag = constraint_set5_flag; + this.direct_8x8_inference_flag = direct_8x8_inference_flag; + this.mb_adaptive_frame_field_flag = mb_adaptive_frame_field_flag; + this.frame_mbs_only_flag = frame_mbs_only_flag; + this.delta_pic_order_always_zero_flag = delta_pic_order_always_zero_flag; + this.separate_colour_plane_flag = separate_colour_plane_flag; + this.gaps_in_frame_num_value_allowed_flag = gaps_in_frame_num_value_allowed_flag; + this.qpprime_y_zero_transform_bypass_flag = qpprime_y_zero_transform_bypass_flag; + this.frame_cropping_flag = frame_cropping_flag; + this.seq_scaling_matrix_present_flag = seq_scaling_matrix_present_flag; + this.vui_parameters_present_flag = vui_parameters_present_flag; + } +} + +[CRepr] struct StdVideoH264ScalingLists : this() +{ + + public uint16 scaling_list_present_mask = 0; + + public uint16 use_default_scaling_matrix_mask = 0; + public uint8[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS] ScalingList4x4 = .(); + public uint8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS] ScalingList8x8 = .(); + + public this(uint16 scaling_list_present_mask, uint16 use_default_scaling_matrix_mask, uint8[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS] ScalingList4x4, uint8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS] ScalingList8x8) : this() + { + this.scaling_list_present_mask = scaling_list_present_mask; + this.use_default_scaling_matrix_mask = use_default_scaling_matrix_mask; + this.ScalingList4x4 = ScalingList4x4; + this.ScalingList8x8 = ScalingList8x8; + } +} + +[CRepr] struct StdVideoH264SequenceParameterSet : this() +{ + public StdVideoH264SpsFlags flags = default; + public StdVideoH264ProfileIdc profile_idc = default; + public StdVideoH264LevelIdc level_idc = default; + public StdVideoH264ChromaFormatIdc chroma_format_idc = default; + public uint8 seq_parameter_set_id = 0; + public uint8 bit_depth_luma_minus8 = 0; + public uint8 bit_depth_chroma_minus8 = 0; + public uint8 log2_max_frame_num_minus4 = 0; + public StdVideoH264PocType pic_order_cnt_type = default; + public int32 offset_for_non_ref_pic = 0; + public int32 offset_for_top_to_bottom_field = 0; + public uint8 log2_max_pic_order_cnt_lsb_minus4 = 0; + public uint8 num_ref_frames_in_pic_order_cnt_cycle = 0; + public uint8 max_num_ref_frames = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint32 pic_width_in_mbs_minus1 = 0; + public uint32 pic_height_in_map_units_minus1 = 0; + public uint32 frame_crop_left_offset = 0; + public uint32 frame_crop_right_offset = 0; + public uint32 frame_crop_top_offset = 0; + public uint32 frame_crop_bottom_offset = 0; + public uint32 reserved2 = 0; // Reserved for future use and must be initialized with 0. + + public int32* pOffsetForRefFrame = null; + public Span offsetForRefFrame + { + get { return .(pOffsetForRefFrame, (.)num_ref_frames_in_pic_order_cnt_cycle); } + set mut { pOffsetForRefFrame = value.Ptr; num_ref_frames_in_pic_order_cnt_cycle = (.)value.Length; } + } + public StdVideoH264ScalingLists* pScalingLists = null; // Must be a valid pointer if seq_scaling_matrix_present_flag is set + public StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui = null; // Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set + + public this(StdVideoH264SpsFlags flags, StdVideoH264ProfileIdc profile_idc, StdVideoH264LevelIdc level_idc, StdVideoH264ChromaFormatIdc chroma_format_idc, uint8 seq_parameter_set_id, uint8 bit_depth_luma_minus8, uint8 bit_depth_chroma_minus8, uint8 log2_max_frame_num_minus4, StdVideoH264PocType pic_order_cnt_type, int32 offset_for_non_ref_pic, int32 offset_for_top_to_bottom_field, uint8 log2_max_pic_order_cnt_lsb_minus4, uint8 max_num_ref_frames, uint8 reserved1, uint32 pic_width_in_mbs_minus1, uint32 pic_height_in_map_units_minus1, uint32 frame_crop_left_offset, uint32 frame_crop_right_offset, uint32 frame_crop_top_offset, uint32 frame_crop_bottom_offset, uint32 reserved2, Span offsetForRefFrame, StdVideoH264ScalingLists* pScalingLists = null, StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui = null) : this() + { + this.flags = flags; + this.profile_idc = profile_idc; + this.level_idc = level_idc; + this.chroma_format_idc = chroma_format_idc; + this.seq_parameter_set_id = seq_parameter_set_id; + this.bit_depth_luma_minus8 = bit_depth_luma_minus8; + this.bit_depth_chroma_minus8 = bit_depth_chroma_minus8; + this.log2_max_frame_num_minus4 = log2_max_frame_num_minus4; + this.pic_order_cnt_type = pic_order_cnt_type; + this.offset_for_non_ref_pic = offset_for_non_ref_pic; + this.offset_for_top_to_bottom_field = offset_for_top_to_bottom_field; + this.log2_max_pic_order_cnt_lsb_minus4 = log2_max_pic_order_cnt_lsb_minus4; + this.max_num_ref_frames = max_num_ref_frames; + this.reserved1 = reserved1; + this.pic_width_in_mbs_minus1 = pic_width_in_mbs_minus1; + this.pic_height_in_map_units_minus1 = pic_height_in_map_units_minus1; + this.frame_crop_left_offset = frame_crop_left_offset; + this.frame_crop_right_offset = frame_crop_right_offset; + this.frame_crop_top_offset = frame_crop_top_offset; + this.frame_crop_bottom_offset = frame_crop_bottom_offset; + this.reserved2 = reserved2; + this.offsetForRefFrame = offsetForRefFrame; + this.pScalingLists = pScalingLists; + this.pSequenceParameterSetVui = pSequenceParameterSetVui; + } +} + +[CRepr] struct StdVideoH264PpsFlags : this() +{ + [Bitfield(.Public, .Bits(1), "transform_8x8_mode_flag")] + [Bitfield(.Public, .Bits(1), "redundant_pic_cnt_present_flag")] + [Bitfield(.Public, .Bits(1), "constrained_intra_pred_flag")] + [Bitfield(.Public, .Bits(1), "deblocking_filter_control_present_flag")] + [Bitfield(.Public, .Bits(1), "weighted_pred_flag")] + [Bitfield(.Public, .Bits(1), "bottom_field_pic_order_in_frame_present_flag")] + [Bitfield(.Public, .Bits(1), "entropy_coding_mode_flag")] + [Bitfield(.Public, .Bits(1), "pic_scaling_matrix_present_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 transform_8x8_mode_flag, uint32 redundant_pic_cnt_present_flag, uint32 constrained_intra_pred_flag, uint32 deblocking_filter_control_present_flag, uint32 weighted_pred_flag, uint32 bottom_field_pic_order_in_frame_present_flag, uint32 entropy_coding_mode_flag, uint32 pic_scaling_matrix_present_flag) : this() + { + this.transform_8x8_mode_flag = transform_8x8_mode_flag; + this.redundant_pic_cnt_present_flag = redundant_pic_cnt_present_flag; + this.constrained_intra_pred_flag = constrained_intra_pred_flag; + this.deblocking_filter_control_present_flag = deblocking_filter_control_present_flag; + this.weighted_pred_flag = weighted_pred_flag; + this.bottom_field_pic_order_in_frame_present_flag = bottom_field_pic_order_in_frame_present_flag; + this.entropy_coding_mode_flag = entropy_coding_mode_flag; + this.pic_scaling_matrix_present_flag = pic_scaling_matrix_present_flag; + } +} + +[CRepr] struct StdVideoH264PictureParameterSet : this() +{ + public StdVideoH264PpsFlags flags = default; + public uint8 seq_parameter_set_id = 0; + public uint8 pic_parameter_set_id = 0; + public uint8 num_ref_idx_l0_default_active_minus1 = 0; + public uint8 num_ref_idx_l1_default_active_minus1 = 0; + public StdVideoH264WeightedBipredIdc weighted_bipred_idc = default; + public int8 pic_init_qp_minus26 = 0; + public int8 pic_init_qs_minus26 = 0; + public int8 chroma_qp_index_offset = 0; + public int8 second_chroma_qp_index_offset = 0; + public StdVideoH264ScalingLists* pScalingLists = null; // Must be a valid pointer if StdVideoH264PpsFlags::pic_scaling_matrix_present_flag is set. + + public this(StdVideoH264PpsFlags flags, uint8 seq_parameter_set_id, uint8 pic_parameter_set_id, uint8 num_ref_idx_l0_default_active_minus1, uint8 num_ref_idx_l1_default_active_minus1, StdVideoH264WeightedBipredIdc weighted_bipred_idc, int8 pic_init_qp_minus26, int8 pic_init_qs_minus26, int8 chroma_qp_index_offset, int8 second_chroma_qp_index_offset, StdVideoH264ScalingLists* pScalingLists = null) : this() + { + this.flags = flags; + this.seq_parameter_set_id = seq_parameter_set_id; + this.pic_parameter_set_id = pic_parameter_set_id; + this.num_ref_idx_l0_default_active_minus1 = num_ref_idx_l0_default_active_minus1; + this.num_ref_idx_l1_default_active_minus1 = num_ref_idx_l1_default_active_minus1; + this.weighted_bipred_idc = weighted_bipred_idc; + this.pic_init_qp_minus26 = pic_init_qp_minus26; + this.pic_init_qs_minus26 = pic_init_qs_minus26; + this.chroma_qp_index_offset = chroma_qp_index_offset; + this.second_chroma_qp_index_offset = second_chroma_qp_index_offset; + this.pScalingLists = pScalingLists; + } +} + +// protect with VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_h264_decode"; } +static { public const uint32 STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE = 2; } + +[AllowDuplicates] enum StdVideoDecodeH264FieldOrderCount : int32 +{ + [NoShow] STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + [NoShow] STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + [NoShow] STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + // pretty names + Top = 0, + Bottom = 1, + Invalid = 0x7FFFFFFF, +} + +[CRepr] struct StdVideoDecodeH264PictureInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "field_pic_flag")] + [Bitfield(.Public, .Bits(1), "is_intra")] + [Bitfield(.Public, .Bits(1), "IdrPicFlag")] + [Bitfield(.Public, .Bits(1), "bottom_field_flag")] + [Bitfield(.Public, .Bits(1), "is_reference")] + [Bitfield(.Public, .Bits(1), "complementary_field_pair")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 field_pic_flag, uint32 is_intra, uint32 IdrPicFlag, uint32 bottom_field_flag, uint32 is_reference, uint32 complementary_field_pair) : this() + { + this.field_pic_flag = field_pic_flag; + this.is_intra = is_intra; + this.IdrPicFlag = IdrPicFlag; + this.bottom_field_flag = bottom_field_flag; + this.is_reference = is_reference; + this.complementary_field_pair = complementary_field_pair; + } +} + +// requires tag is for PicOrderCnt, which needs the enum type +[CRepr] struct StdVideoDecodeH264PictureInfo : this() +{ + public StdVideoDecodeH264PictureInfoFlags flags = default; + public uint8 seq_parameter_set_id = 0; // Selecting SPS id from the Sequence Parameters Set + public uint8 pic_parameter_set_id = 0; // Selecting PPS id from the Picture Parameters Set + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + public uint16 frame_num = 0; // 7.4.3 Slice header semantics + public uint16 idr_pic_id = 0; // 7.4.3 Slice header semantics + + public int32[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE] PicOrderCnt = .(); // TopFieldOrderCnt and BottomFieldOrderCnt fields. + + public this(StdVideoDecodeH264PictureInfoFlags flags, uint8 seq_parameter_set_id, uint8 pic_parameter_set_id, uint8 reserved1, uint8 reserved2, uint16 frame_num, uint16 idr_pic_id, int32[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE] PicOrderCnt) : this() + { + this.flags = flags; + this.seq_parameter_set_id = seq_parameter_set_id; + this.pic_parameter_set_id = pic_parameter_set_id; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.frame_num = frame_num; + this.idr_pic_id = idr_pic_id; + this.PicOrderCnt = PicOrderCnt; + } +} + +[CRepr] struct StdVideoDecodeH264ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "top_field_flag")] + [Bitfield(.Public, .Bits(1), "bottom_field_flag")] + [Bitfield(.Public, .Bits(1), "used_for_long_term_reference")] + [Bitfield(.Public, .Bits(1), "is_non_existing")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 top_field_flag, uint32 bottom_field_flag, uint32 used_for_long_term_reference, uint32 is_non_existing) : this() + { + this.top_field_flag = top_field_flag; + this.bottom_field_flag = bottom_field_flag; + this.used_for_long_term_reference = used_for_long_term_reference; + this.is_non_existing = is_non_existing; + } +} + +[CRepr] struct StdVideoDecodeH264ReferenceInfo : this() +{ + public StdVideoDecodeH264ReferenceInfoFlags flags = default; + + public uint16 FrameNum = 0; // 7.4.3.3 Decoded reference picture marking semantics + public uint16 reserved = 0; // for structure members 32-bit packing/alignment + public int32[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE] PicOrderCnt = .(); // TopFieldOrderCnt and BottomFieldOrderCnt fields. + + public this(StdVideoDecodeH264ReferenceInfoFlags flags, uint16 FrameNum, uint16 reserved, int32[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE] PicOrderCnt) : this() + { + this.flags = flags; + this.FrameNum = FrameNum; + this.reserved = reserved; + this.PicOrderCnt = PicOrderCnt; + } +} + +// protect with VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_h264_encode"; } + +[CRepr] struct StdVideoEncodeH264WeightTableFlags : this() +{ + public uint32 luma_weight_l0_flag = 0; // each bit n represents the nth entry in reference list l0, n <= num_ref_idx_l0_active_minus1 + public uint32 chroma_weight_l0_flag = 0; // each bit n represents the nth entry in reference list l0, n <= num_ref_idx_l0_active_minus1 + public uint32 luma_weight_l1_flag = 0; // each bit n represents the nth entry in reference list l1, n <= num_ref_idx_l1_active_minus1 + public uint32 chroma_weight_l1_flag = 0; // each bit n represents the nth entry in reference list l1, n <= num_ref_idx_l1_active_minus1 + + public this(uint32 luma_weight_l0_flag, uint32 chroma_weight_l0_flag, uint32 luma_weight_l1_flag, uint32 chroma_weight_l1_flag) : this() + { + this.luma_weight_l0_flag = luma_weight_l0_flag; + this.chroma_weight_l0_flag = chroma_weight_l0_flag; + this.luma_weight_l1_flag = luma_weight_l1_flag; + this.chroma_weight_l1_flag = chroma_weight_l1_flag; + } +} + +[CRepr] struct StdVideoEncodeH264WeightTable : this() +{ + + public StdVideoEncodeH264WeightTableFlags flags = default; + public uint8 luma_log2_weight_denom = 0; + public uint8 chroma_log2_weight_denom = 0; + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_weight_l0 = .(); // valid entry range is [0, num_ref_idx_l0_active_minus1] + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_offset_l0 = .(); // valid entry range is [0, num_ref_idx_l0_active_minus1] + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_weight_l0 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l0_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_offset_l0 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l0_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_weight_l1 = .(); // valid entry range is [0, num_ref_idx_l1_active_minus1] + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_offset_l1 = .(); // valid entry range is [0, num_ref_idx_l1_active_minus1] + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_weight_l1 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l1_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_offset_l1 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l1_active_minus1]; j = 0 for Cb, j = 1 for Cr + + public this(StdVideoEncodeH264WeightTableFlags flags, uint8 luma_log2_weight_denom, uint8 chroma_log2_weight_denom, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_weight_l0, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_offset_l0, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_weight_l0, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_offset_l0, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_weight_l1, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF] luma_offset_l1, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_weight_l1, int8[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES] chroma_offset_l1) : this() + { + this.flags = flags; + this.luma_log2_weight_denom = luma_log2_weight_denom; + this.chroma_log2_weight_denom = chroma_log2_weight_denom; + this.luma_weight_l0 = luma_weight_l0; + this.luma_offset_l0 = luma_offset_l0; + this.chroma_weight_l0 = chroma_weight_l0; + this.chroma_offset_l0 = chroma_offset_l0; + this.luma_weight_l1 = luma_weight_l1; + this.luma_offset_l1 = luma_offset_l1; + this.chroma_weight_l1 = chroma_weight_l1; + this.chroma_offset_l1 = chroma_offset_l1; + } +} + +[CRepr] struct StdVideoEncodeH264SliceHeaderFlags : this() +{ + [Bitfield(.Public, .Bits(1), "direct_spatial_mv_pred_flag")] + [Bitfield(.Public, .Bits(1), "num_ref_idx_active_override_flag")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 direct_spatial_mv_pred_flag, uint32 num_ref_idx_active_override_flag, uint32 reserved) : this() + { + this.direct_spatial_mv_pred_flag = direct_spatial_mv_pred_flag; + this.num_ref_idx_active_override_flag = num_ref_idx_active_override_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH264PictureInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "IdrPicFlag")] + [Bitfield(.Public, .Bits(1), "is_reference")] + [Bitfield(.Public, .Bits(1), "no_output_of_prior_pics_flag")] + [Bitfield(.Public, .Bits(1), "long_term_reference_flag")] + [Bitfield(.Public, .Bits(1), "adaptive_ref_pic_marking_mode_flag")] + [Bitfield(.Public, .Bits(27), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 IdrPicFlag, uint32 is_reference, uint32 no_output_of_prior_pics_flag, uint32 long_term_reference_flag, uint32 adaptive_ref_pic_marking_mode_flag, uint32 reserved) : this() + { + this.IdrPicFlag = IdrPicFlag; + this.is_reference = is_reference; + this.no_output_of_prior_pics_flag = no_output_of_prior_pics_flag; + this.long_term_reference_flag = long_term_reference_flag; + this.adaptive_ref_pic_marking_mode_flag = adaptive_ref_pic_marking_mode_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH264ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "used_for_long_term_reference")] + [Bitfield(.Public, .Bits(31), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 used_for_long_term_reference, uint32 reserved) : this() + { + this.used_for_long_term_reference = used_for_long_term_reference; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH264ReferenceListsInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "ref_pic_list_modification_flag_l0")] + [Bitfield(.Public, .Bits(1), "ref_pic_list_modification_flag_l1")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 ref_pic_list_modification_flag_l0, uint32 ref_pic_list_modification_flag_l1, uint32 reserved) : this() + { + this.ref_pic_list_modification_flag_l0 = ref_pic_list_modification_flag_l0; + this.ref_pic_list_modification_flag_l1 = ref_pic_list_modification_flag_l1; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH264RefListModEntry : this() +{ + public StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc = default; + public uint16 abs_diff_pic_num_minus1 = 0; + public uint16 long_term_pic_num = 0; + + public this(StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc, uint16 abs_diff_pic_num_minus1, uint16 long_term_pic_num) : this() + { + this.modification_of_pic_nums_idc = modification_of_pic_nums_idc; + this.abs_diff_pic_num_minus1 = abs_diff_pic_num_minus1; + this.long_term_pic_num = long_term_pic_num; + } +} + +[CRepr] struct StdVideoEncodeH264RefPicMarkingEntry : this() +{ + public StdVideoH264MemMgmtControlOp memory_management_control_operation = default; + public uint16 difference_of_pic_nums_minus1 = 0; + public uint16 long_term_pic_num = 0; + public uint16 long_term_frame_idx = 0; + public uint16 max_long_term_frame_idx_plus1 = 0; + + public this(StdVideoH264MemMgmtControlOp memory_management_control_operation, uint16 difference_of_pic_nums_minus1, uint16 long_term_pic_num, uint16 long_term_frame_idx, uint16 max_long_term_frame_idx_plus1) : this() + { + this.memory_management_control_operation = memory_management_control_operation; + this.difference_of_pic_nums_minus1 = difference_of_pic_nums_minus1; + this.long_term_pic_num = long_term_pic_num; + this.long_term_frame_idx = long_term_frame_idx; + this.max_long_term_frame_idx_plus1 = max_long_term_frame_idx_plus1; + } +} + +[CRepr] struct StdVideoEncodeH264ReferenceListsInfo : this() +{ + public StdVideoEncodeH264ReferenceListsInfoFlags flags = default; + public uint8 num_ref_idx_l0_active_minus1 = 0; + public uint8 num_ref_idx_l1_active_minus1 = 0; + public uint8[STD_VIDEO_H264_MAX_NUM_LIST_REF] RefPicList0 = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures or STD_VIDEO_H264_NO_REFERENCE_PICTURE + public uint8[STD_VIDEO_H264_MAX_NUM_LIST_REF] RefPicList1 = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures or STD_VIDEO_H264_NO_REFERENCE_PICTURE + public uint8 refList0ModOpCount = 0; + public uint8 refList1ModOpCount = 0; + public uint8 refPicMarkingOpCount = 0; + public uint8[7] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoEncodeH264RefListModEntry* pRefList0ModOperations = null; // Must be a valid pointer to an array with size refList0ModOpCount if ref_pic_list_modification_flag_l0 is set and contains the RefList0 modification parameters as defined in section 7.4.3.1 + public Span refList0ModOperations + { + get { return .(pRefList0ModOperations, (.)refList0ModOpCount); } + set mut { pRefList0ModOperations = value.Ptr; refList0ModOpCount = (.)value.Length; } + } + public StdVideoEncodeH264RefListModEntry* pRefList1ModOperations = null; // Must be a valid pointer to an array with size refList1ModOpCount if ref_pic_list_modification_flag_l1 is set and contains the RefList1 modification parameters as defined in section 7.4.3.1 + public Span refList1ModOperations + { + get { return .(pRefList1ModOperations, (.)refList1ModOpCount); } + set mut { pRefList1ModOperations = value.Ptr; refList1ModOpCount = (.)value.Length; } + } + public StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations = null; // Must be a valid pointer to an array with size refPicMarkingOpCount and contains the reference picture markings as defined in section 7.4.3.3 + public Span refPicMarkingOperations + { + get { return .(pRefPicMarkingOperations, (.)refPicMarkingOpCount); } + set mut { pRefPicMarkingOperations = value.Ptr; refPicMarkingOpCount = (.)value.Length; } + } + + public this(StdVideoEncodeH264ReferenceListsInfoFlags flags, uint8 num_ref_idx_l0_active_minus1, uint8 num_ref_idx_l1_active_minus1, uint8[STD_VIDEO_H264_MAX_NUM_LIST_REF] RefPicList0, uint8[STD_VIDEO_H264_MAX_NUM_LIST_REF] RefPicList1, uint8[7] reserved1, Span refList0ModOperations, Span refList1ModOperations, Span refPicMarkingOperations) : this() + { + this.flags = flags; + this.num_ref_idx_l0_active_minus1 = num_ref_idx_l0_active_minus1; + this.num_ref_idx_l1_active_minus1 = num_ref_idx_l1_active_minus1; + this.RefPicList0 = RefPicList0; + this.RefPicList1 = RefPicList1; + this.reserved1 = reserved1; + this.refList0ModOperations = refList0ModOperations; + this.refList1ModOperations = refList1ModOperations; + this.refPicMarkingOperations = refPicMarkingOperations; + } +} + +[CRepr] struct StdVideoEncodeH264PictureInfo : this() +{ + public StdVideoEncodeH264PictureInfoFlags flags = default; + public uint8 seq_parameter_set_id = 0; // Selecting SPS id from the Sequence Parameters Set + public uint8 pic_parameter_set_id = 0; // Selecting PPS from the Picture Parameters for all StdVideoEncodeH264SliceHeader(s) + public uint16 idr_pic_id = 0; + public StdVideoH264PictureType primary_pic_type = default; + public uint32 frame_num = 0; + public int32 PicOrderCnt = 0; // Picture order count, as defined in 8.2 + public uint8 temporal_id = 0; // Temporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1 + public uint8[3] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoEncodeH264ReferenceListsInfo* pRefLists = null; + + public this(StdVideoEncodeH264PictureInfoFlags flags, uint8 seq_parameter_set_id, uint8 pic_parameter_set_id, uint16 idr_pic_id, StdVideoH264PictureType primary_pic_type, uint32 frame_num, int32 PicOrderCnt, uint8 temporal_id, uint8[3] reserved1, StdVideoEncodeH264ReferenceListsInfo* pRefLists = null) : this() + { + this.flags = flags; + this.seq_parameter_set_id = seq_parameter_set_id; + this.pic_parameter_set_id = pic_parameter_set_id; + this.idr_pic_id = idr_pic_id; + this.primary_pic_type = primary_pic_type; + this.frame_num = frame_num; + this.PicOrderCnt = PicOrderCnt; + this.temporal_id = temporal_id; + this.reserved1 = reserved1; + this.pRefLists = pRefLists; + } +} + +[CRepr] struct StdVideoEncodeH264ReferenceInfo : this() +{ + public StdVideoEncodeH264ReferenceInfoFlags flags = default; + public StdVideoH264PictureType primary_pic_type = default; + public uint32 FrameNum = 0; // Frame number, as defined in 8.2 + public int32 PicOrderCnt = 0; // Picture order count, as defined in 8.2 + public uint16 long_term_pic_num = 0; + public uint16 long_term_frame_idx = 0; + public uint8 temporal_id = 0; // Temporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1 + + public this(StdVideoEncodeH264ReferenceInfoFlags flags, StdVideoH264PictureType primary_pic_type, uint32 FrameNum, int32 PicOrderCnt, uint16 long_term_pic_num, uint16 long_term_frame_idx, uint8 temporal_id) : this() + { + this.flags = flags; + this.primary_pic_type = primary_pic_type; + this.FrameNum = FrameNum; + this.PicOrderCnt = PicOrderCnt; + this.long_term_pic_num = long_term_pic_num; + this.long_term_frame_idx = long_term_frame_idx; + this.temporal_id = temporal_id; + } +} + +[CRepr] struct StdVideoEncodeH264SliceHeader : this() +{ + public StdVideoEncodeH264SliceHeaderFlags flags = default; + public uint32 first_mb_in_slice = 0; + public StdVideoH264SliceType slice_type = default; + public int8 slice_alpha_c0_offset_div2 = 0; + public int8 slice_beta_offset_div2 = 0; + public int8 slice_qp_delta = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoH264CabacInitIdc cabac_init_idc = default; + public StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc = default; + public StdVideoEncodeH264WeightTable* pWeightTable = null; + + public this(StdVideoEncodeH264SliceHeaderFlags flags, uint32 first_mb_in_slice, StdVideoH264SliceType slice_type, int8 slice_alpha_c0_offset_div2, int8 slice_beta_offset_div2, int8 slice_qp_delta, uint8 reserved1, StdVideoH264CabacInitIdc cabac_init_idc, StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc, StdVideoEncodeH264WeightTable* pWeightTable = null) : this() + { + this.flags = flags; + this.first_mb_in_slice = first_mb_in_slice; + this.slice_type = slice_type; + this.slice_alpha_c0_offset_div2 = slice_alpha_c0_offset_div2; + this.slice_beta_offset_div2 = slice_beta_offset_div2; + this.slice_qp_delta = slice_qp_delta; + this.reserved1 = reserved1; + this.cabac_init_idc = cabac_init_idc; + this.disable_deblocking_filter_idc = disable_deblocking_filter_idc; + this.pWeightTable = pWeightTable; + } +} + +// protect with VULKAN_VIDEO_CODEC_H265STD_H_ +static { public const uint32 STD_VIDEO_H265_CPB_CNT_LIST_SIZE = 32; } +static { public const uint32 STD_VIDEO_H265_SUBLAYERS_LIST_SIZE = 7; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS = 6; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS = 16; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS = 6; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS = 64; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS = 6; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS = 64; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS = 2; } +static { public const uint32 STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS = 64; } +static { public const uint32 STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE = 6; } +static { public const uint32 STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE = 19; } +static { public const uint32 STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE = 21; } +static { public const uint32 STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE = 3; } +static { public const uint32 STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE = 128; } +static { public const uint32 STD_VIDEO_H265_MAX_NUM_LIST_REF = 15; } +static { public const uint32 STD_VIDEO_H265_MAX_CHROMA_PLANES = 2; } +static { public const uint32 STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS = 64; } +static { public const uint32 STD_VIDEO_H265_MAX_DPB_SIZE = 16; } +static { public const uint32 STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS = 32; } +static { public const uint32 STD_VIDEO_H265_MAX_LONG_TERM_PICS = 16; } +static { public const uint32 STD_VIDEO_H265_MAX_DELTA_POC = 48; } +static { public const uint8 STD_VIDEO_H265_NO_REFERENCE_PICTURE = 0xFF; } + +[AllowDuplicates] enum StdVideoH265ChromaFormatIdc : int32 +{ + [NoShow] STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + [NoShow] STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + [NoShow] STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + [NoShow] STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + [NoShow] STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Monochrome = 0, + _420 = 1, + _422 = 2, + _444 = 3, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH265ProfileIdc : int32 +{ + [NoShow] STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + [NoShow] STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + [NoShow] STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + [NoShow] STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + [NoShow] STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + [NoShow] STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Main = 1, + Main10 = 2, + MainStillPicture = 3, + FormatRangeExtensions = 4, + SccExtensions = 9, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH265LevelIdc : int32 +{ + [NoShow] STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, + [NoShow] STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, + // pretty names + _1_0 = 0, + _2_0 = 1, + _2_1 = 2, + _3_0 = 3, + _3_1 = 4, + _4_0 = 5, + _4_1 = 6, + _5_0 = 7, + _5_1 = 8, + _5_2 = 9, + _6_0 = 10, + _6_1 = 11, + _6_2 = 12, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH265SliceType : int32 +{ + [NoShow] STD_VIDEO_H265_SLICE_TYPE_B = 0, + [NoShow] STD_VIDEO_H265_SLICE_TYPE_P = 1, + [NoShow] STD_VIDEO_H265_SLICE_TYPE_I = 2, + [NoShow] STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + B = 0, + P = 1, + I = 2, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH265PictureType : int32 +{ + [NoShow] STD_VIDEO_H265_PICTURE_TYPE_P = 0, + [NoShow] STD_VIDEO_H265_PICTURE_TYPE_B = 1, + [NoShow] STD_VIDEO_H265_PICTURE_TYPE_I = 2, + [NoShow] STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, + [NoShow] STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + P = 0, + B = 1, + I = 2, + Idr = 3, + Invalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoH265AspectRatioIdc : int32 +{ + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + [NoShow] STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + // pretty names + Unspecified = 0, + Square = 1, + _12_11 = 2, + _10_11 = 3, + _16_11 = 4, + _40_33 = 5, + _24_11 = 6, + _20_11 = 7, + _32_11 = 8, + _80_33 = 9, + _18_11 = 10, + _15_11 = 11, + _64_33 = 12, + _160_99 = 13, + _4_3 = 14, + _3_2 = 15, + _2_1 = 16, + ExtendedSar = 255, + Invalid = 0x7FFFFFFF, +} + +// sps_ or vps_ parameters, based on if the StdVideoH265DecPicBufMgr is used within the StdVideoH265SequenceParameterSet or StdVideoH265VideoParameterSet +[CRepr] struct StdVideoH265DecPicBufMgr : this() +{ + public uint32[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_latency_increase_plus1 = .(); // represents sps_max_latency_increase_plus1 or vps_max_latency_increase_plus1 + public uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_dec_pic_buffering_minus1 = .(); // represents sps_max_dec_pic_buffering_minus1 or vps_max_dec_pic_buffering_minus1 + public uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_num_reorder_pics = .(); // represents sps_max_num_reorder_pics or vps_max_num_reorder_pics + + public this(uint32[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_latency_increase_plus1, uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_dec_pic_buffering_minus1, uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] max_num_reorder_pics) : this() + { + this.max_latency_increase_plus1 = max_latency_increase_plus1; + this.max_dec_pic_buffering_minus1 = max_dec_pic_buffering_minus1; + this.max_num_reorder_pics = max_num_reorder_pics; + } +} + +// sub_layer_hrd_parameters +[CRepr] struct StdVideoH265SubLayerHrdParameters : this() +{ + public uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] bit_rate_value_minus1 = .(); + public uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] cpb_size_value_minus1 = .(); + public uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] cpb_size_du_value_minus1 = .(); + public uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] bit_rate_du_value_minus1 = .(); + public uint32 cbr_flag = 0; // each bit represents a range of CpbCounts (bit 0 - cpb_cnt_minus1) per sub-layer + + public this(uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] bit_rate_value_minus1, uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] cpb_size_value_minus1, uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] cpb_size_du_value_minus1, uint32[STD_VIDEO_H265_CPB_CNT_LIST_SIZE] bit_rate_du_value_minus1, uint32 cbr_flag) : this() + { + this.bit_rate_value_minus1 = bit_rate_value_minus1; + this.cpb_size_value_minus1 = cpb_size_value_minus1; + this.cpb_size_du_value_minus1 = cpb_size_du_value_minus1; + this.bit_rate_du_value_minus1 = bit_rate_du_value_minus1; + this.cbr_flag = cbr_flag; + } +} + +[CRepr] struct StdVideoH265HrdFlags : this() +{ + [Bitfield(.Public, .Bits(1), "nal_hrd_parameters_present_flag")] + [Bitfield(.Public, .Bits(1), "vcl_hrd_parameters_present_flag")] + [Bitfield(.Public, .Bits(1), "sub_pic_hrd_params_present_flag")] + [Bitfield(.Public, .Bits(1), "sub_pic_cpb_params_in_pic_timing_sei_flag")] + [Bitfield(.Public, .Bits(8), "fixed_pic_rate_general_flag")] + [Bitfield(.Public, .Bits(8), "fixed_pic_rate_within_cvs_flag")] + [Bitfield(.Public, .Bits(8), "low_delay_hrd_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 nal_hrd_parameters_present_flag, uint32 vcl_hrd_parameters_present_flag, uint32 sub_pic_hrd_params_present_flag, uint32 sub_pic_cpb_params_in_pic_timing_sei_flag, uint32 fixed_pic_rate_general_flag, uint32 fixed_pic_rate_within_cvs_flag, uint32 low_delay_hrd_flag) : this() + { + this.nal_hrd_parameters_present_flag = nal_hrd_parameters_present_flag; + this.vcl_hrd_parameters_present_flag = vcl_hrd_parameters_present_flag; + this.sub_pic_hrd_params_present_flag = sub_pic_hrd_params_present_flag; + this.sub_pic_cpb_params_in_pic_timing_sei_flag = sub_pic_cpb_params_in_pic_timing_sei_flag; + this.fixed_pic_rate_general_flag = fixed_pic_rate_general_flag; + this.fixed_pic_rate_within_cvs_flag = fixed_pic_rate_within_cvs_flag; + this.low_delay_hrd_flag = low_delay_hrd_flag; + } +} + +[CRepr] struct StdVideoH265HrdParameters : this() +{ + public StdVideoH265HrdFlags flags = default; + public uint8 tick_divisor_minus2 = 0; + public uint8 du_cpb_removal_delay_increment_length_minus1 = 0; + public uint8 dpb_output_delay_du_length_minus1 = 0; + public uint8 bit_rate_scale = 0; + public uint8 cpb_size_scale = 0; + public uint8 cpb_size_du_scale = 0; + public uint8 initial_cpb_removal_delay_length_minus1 = 0; + public uint8 au_cpb_removal_delay_length_minus1 = 0; + public uint8 dpb_output_delay_length_minus1 = 0; + public uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] cpb_cnt_minus1 = .(); + public uint16[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] elemental_duration_in_tc_minus1 = .(); + public uint16[3] reserved = .(); // Reserved for future use and must be initialized with 0. + public StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal = null; // if flags.nal_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively. + public StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl = null; // if flags.vcl_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively. + + public this(StdVideoH265HrdFlags flags, uint8 tick_divisor_minus2, uint8 du_cpb_removal_delay_increment_length_minus1, uint8 dpb_output_delay_du_length_minus1, uint8 bit_rate_scale, uint8 cpb_size_scale, uint8 cpb_size_du_scale, uint8 initial_cpb_removal_delay_length_minus1, uint8 au_cpb_removal_delay_length_minus1, uint8 dpb_output_delay_length_minus1, uint8[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] cpb_cnt_minus1, uint16[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE] elemental_duration_in_tc_minus1, uint16[3] reserved, StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal = null, StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl = null) : this() + { + this.flags = flags; + this.tick_divisor_minus2 = tick_divisor_minus2; + this.du_cpb_removal_delay_increment_length_minus1 = du_cpb_removal_delay_increment_length_minus1; + this.dpb_output_delay_du_length_minus1 = dpb_output_delay_du_length_minus1; + this.bit_rate_scale = bit_rate_scale; + this.cpb_size_scale = cpb_size_scale; + this.cpb_size_du_scale = cpb_size_du_scale; + this.initial_cpb_removal_delay_length_minus1 = initial_cpb_removal_delay_length_minus1; + this.au_cpb_removal_delay_length_minus1 = au_cpb_removal_delay_length_minus1; + this.dpb_output_delay_length_minus1 = dpb_output_delay_length_minus1; + this.cpb_cnt_minus1 = cpb_cnt_minus1; + this.elemental_duration_in_tc_minus1 = elemental_duration_in_tc_minus1; + this.reserved = reserved; + this.pSubLayerHrdParametersNal = pSubLayerHrdParametersNal; + this.pSubLayerHrdParametersVcl = pSubLayerHrdParametersVcl; + } +} + +[CRepr] struct StdVideoH265VpsFlags : this() +{ + [Bitfield(.Public, .Bits(1), "vps_temporal_id_nesting_flag")] + [Bitfield(.Public, .Bits(1), "vps_sub_layer_ordering_info_present_flag")] + [Bitfield(.Public, .Bits(1), "vps_timing_info_present_flag")] + [Bitfield(.Public, .Bits(1), "vps_poc_proportional_to_timing_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 vps_temporal_id_nesting_flag, uint32 vps_sub_layer_ordering_info_present_flag, uint32 vps_timing_info_present_flag, uint32 vps_poc_proportional_to_timing_flag) : this() + { + this.vps_temporal_id_nesting_flag = vps_temporal_id_nesting_flag; + this.vps_sub_layer_ordering_info_present_flag = vps_sub_layer_ordering_info_present_flag; + this.vps_timing_info_present_flag = vps_timing_info_present_flag; + this.vps_poc_proportional_to_timing_flag = vps_poc_proportional_to_timing_flag; + } +} + +[CRepr] struct StdVideoH265ProfileTierLevelFlags : this() +{ + [Bitfield(.Public, .Bits(1), "general_tier_flag")] + [Bitfield(.Public, .Bits(1), "general_progressive_source_flag")] + [Bitfield(.Public, .Bits(1), "general_interlaced_source_flag")] + [Bitfield(.Public, .Bits(1), "general_non_packed_constraint_flag")] + [Bitfield(.Public, .Bits(1), "general_frame_only_constraint_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 general_tier_flag, uint32 general_progressive_source_flag, uint32 general_interlaced_source_flag, uint32 general_non_packed_constraint_flag, uint32 general_frame_only_constraint_flag) : this() + { + this.general_tier_flag = general_tier_flag; + this.general_progressive_source_flag = general_progressive_source_flag; + this.general_interlaced_source_flag = general_interlaced_source_flag; + this.general_non_packed_constraint_flag = general_non_packed_constraint_flag; + this.general_frame_only_constraint_flag = general_frame_only_constraint_flag; + } +} + +// profile_tier_level +[CRepr] struct StdVideoH265ProfileTierLevel : this() +{ + public StdVideoH265ProfileTierLevelFlags flags = default; + public StdVideoH265ProfileIdc general_profile_idc = default; + public StdVideoH265LevelIdc general_level_idc = default; + + public this(StdVideoH265ProfileTierLevelFlags flags, StdVideoH265ProfileIdc general_profile_idc, StdVideoH265LevelIdc general_level_idc) : this() + { + this.flags = flags; + this.general_profile_idc = general_profile_idc; + this.general_level_idc = general_level_idc; + } +} + +[CRepr] struct StdVideoH265VideoParameterSet : this() +{ + public StdVideoH265VpsFlags flags = default; + public uint8 vps_video_parameter_set_id = 0; + public uint8 vps_max_sub_layers_minus1 = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + public uint32 vps_num_units_in_tick = 0; + public uint32 vps_time_scale = 0; + public uint32 vps_num_ticks_poc_diff_one_minus1 = 0; + public uint32 reserved3 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoH265DecPicBufMgr* pDecPicBufMgr = null; + public StdVideoH265HrdParameters* pHrdParameters = null; + public StdVideoH265ProfileTierLevel* pProfileTierLevel = null; + + public this(StdVideoH265VpsFlags flags, uint8 vps_video_parameter_set_id, uint8 vps_max_sub_layers_minus1, uint8 reserved1, uint8 reserved2, uint32 vps_num_units_in_tick, uint32 vps_time_scale, uint32 vps_num_ticks_poc_diff_one_minus1, uint32 reserved3, StdVideoH265DecPicBufMgr* pDecPicBufMgr = null, StdVideoH265HrdParameters* pHrdParameters = null, StdVideoH265ProfileTierLevel* pProfileTierLevel = null) : this() + { + this.flags = flags; + this.vps_video_parameter_set_id = vps_video_parameter_set_id; + this.vps_max_sub_layers_minus1 = vps_max_sub_layers_minus1; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.vps_num_units_in_tick = vps_num_units_in_tick; + this.vps_time_scale = vps_time_scale; + this.vps_num_ticks_poc_diff_one_minus1 = vps_num_ticks_poc_diff_one_minus1; + this.reserved3 = reserved3; + this.pDecPicBufMgr = pDecPicBufMgr; + this.pHrdParameters = pHrdParameters; + this.pProfileTierLevel = pProfileTierLevel; + } +} + +[CRepr] struct StdVideoH265ScalingLists : this() +{ + public uint8[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS] ScalingList4x4 = .(); // ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0) + public uint8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS] ScalingList8x8 = .(); // ScalingList[ 1 ][ MatrixID ][ i ] (sizeID = 1) + public uint8[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS] ScalingList16x16 = .(); // ScalingList[ 2 ][ Matri]xID ][ i ] (sizeID = 2) + public uint8[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS] ScalingList32x32 = .(); // ScalingList[ 3 ][ MatrixID ][ i ] (sizeID = 3) + public uint8[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS] ScalingListDCCoef16x16 = .(); // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8, sizeID = 2 + public uint8[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS] ScalingListDCCoef32x32 = .(); // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8. sizeID = 3 + + public this(uint8[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS] ScalingList4x4, uint8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS] ScalingList8x8, uint8[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS] ScalingList16x16, uint8[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS] ScalingList32x32, uint8[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS] ScalingListDCCoef16x16, uint8[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS] ScalingListDCCoef32x32) : this() + { + this.ScalingList4x4 = ScalingList4x4; + this.ScalingList8x8 = ScalingList8x8; + this.ScalingList16x16 = ScalingList16x16; + this.ScalingList32x32 = ScalingList32x32; + this.ScalingListDCCoef16x16 = ScalingListDCCoef16x16; + this.ScalingListDCCoef32x32 = ScalingListDCCoef32x32; + } +} + +[CRepr] struct StdVideoH265SpsVuiFlags : this() +{ + [Bitfield(.Public, .Bits(1), "aspect_ratio_info_present_flag")] + [Bitfield(.Public, .Bits(1), "overscan_info_present_flag")] + [Bitfield(.Public, .Bits(1), "overscan_appropriate_flag")] + [Bitfield(.Public, .Bits(1), "video_signal_type_present_flag")] + [Bitfield(.Public, .Bits(1), "video_full_range_flag")] + [Bitfield(.Public, .Bits(1), "colour_description_present_flag")] + [Bitfield(.Public, .Bits(1), "chroma_loc_info_present_flag")] + [Bitfield(.Public, .Bits(1), "neutral_chroma_indication_flag")] + [Bitfield(.Public, .Bits(1), "field_seq_flag")] + [Bitfield(.Public, .Bits(1), "frame_field_info_present_flag")] + [Bitfield(.Public, .Bits(1), "default_display_window_flag")] + [Bitfield(.Public, .Bits(1), "vui_timing_info_present_flag")] + [Bitfield(.Public, .Bits(1), "vui_poc_proportional_to_timing_flag")] + [Bitfield(.Public, .Bits(1), "vui_hrd_parameters_present_flag")] + [Bitfield(.Public, .Bits(1), "bitstream_restriction_flag")] + [Bitfield(.Public, .Bits(1), "tiles_fixed_structure_flag")] + [Bitfield(.Public, .Bits(1), "motion_vectors_over_pic_boundaries_flag")] + [Bitfield(.Public, .Bits(1), "restricted_ref_pic_lists_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 aspect_ratio_info_present_flag, uint32 overscan_info_present_flag, uint32 overscan_appropriate_flag, uint32 video_signal_type_present_flag, uint32 video_full_range_flag, uint32 colour_description_present_flag, uint32 chroma_loc_info_present_flag, uint32 neutral_chroma_indication_flag, uint32 field_seq_flag, uint32 frame_field_info_present_flag, uint32 default_display_window_flag, uint32 vui_timing_info_present_flag, uint32 vui_poc_proportional_to_timing_flag, uint32 vui_hrd_parameters_present_flag, uint32 bitstream_restriction_flag, uint32 tiles_fixed_structure_flag, uint32 motion_vectors_over_pic_boundaries_flag, uint32 restricted_ref_pic_lists_flag) : this() + { + this.aspect_ratio_info_present_flag = aspect_ratio_info_present_flag; + this.overscan_info_present_flag = overscan_info_present_flag; + this.overscan_appropriate_flag = overscan_appropriate_flag; + this.video_signal_type_present_flag = video_signal_type_present_flag; + this.video_full_range_flag = video_full_range_flag; + this.colour_description_present_flag = colour_description_present_flag; + this.chroma_loc_info_present_flag = chroma_loc_info_present_flag; + this.neutral_chroma_indication_flag = neutral_chroma_indication_flag; + this.field_seq_flag = field_seq_flag; + this.frame_field_info_present_flag = frame_field_info_present_flag; + this.default_display_window_flag = default_display_window_flag; + this.vui_timing_info_present_flag = vui_timing_info_present_flag; + this.vui_poc_proportional_to_timing_flag = vui_poc_proportional_to_timing_flag; + this.vui_hrd_parameters_present_flag = vui_hrd_parameters_present_flag; + this.bitstream_restriction_flag = bitstream_restriction_flag; + this.tiles_fixed_structure_flag = tiles_fixed_structure_flag; + this.motion_vectors_over_pic_boundaries_flag = motion_vectors_over_pic_boundaries_flag; + this.restricted_ref_pic_lists_flag = restricted_ref_pic_lists_flag; + } +} + +[CRepr] struct StdVideoH265SequenceParameterSetVui : this() +{ + public StdVideoH265SpsVuiFlags flags = default; + public StdVideoH265AspectRatioIdc aspect_ratio_idc = default; + public uint16 sar_width = 0; + public uint16 sar_height = 0; + public uint8 video_format = 0; + public uint8 colour_primaries = 0; + public uint8 transfer_characteristics = 0; + public uint8 matrix_coeffs = 0; + public uint8 chroma_sample_loc_type_top_field = 0; + public uint8 chroma_sample_loc_type_bottom_field = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + public uint16 def_disp_win_left_offset = 0; + public uint16 def_disp_win_right_offset = 0; + public uint16 def_disp_win_top_offset = 0; + public uint16 def_disp_win_bottom_offset = 0; + public uint32 vui_num_units_in_tick = 0; + public uint32 vui_time_scale = 0; + public uint32 vui_num_ticks_poc_diff_one_minus1 = 0; + public uint16 min_spatial_segmentation_idc = 0; + public uint16 reserved3 = 0; // Reserved for future use and must be initialized with 0. + public uint8 max_bytes_per_pic_denom = 0; + public uint8 max_bits_per_min_cu_denom = 0; + public uint8 log2_max_mv_length_horizontal = 0; + public uint8 log2_max_mv_length_vertical = 0; + public StdVideoH265HrdParameters* pHrdParameters = null; + + public this(StdVideoH265SpsVuiFlags flags, StdVideoH265AspectRatioIdc aspect_ratio_idc, uint16 sar_width, uint16 sar_height, uint8 video_format, uint8 colour_primaries, uint8 transfer_characteristics, uint8 matrix_coeffs, uint8 chroma_sample_loc_type_top_field, uint8 chroma_sample_loc_type_bottom_field, uint8 reserved1, uint8 reserved2, uint16 def_disp_win_left_offset, uint16 def_disp_win_right_offset, uint16 def_disp_win_top_offset, uint16 def_disp_win_bottom_offset, uint32 vui_num_units_in_tick, uint32 vui_time_scale, uint32 vui_num_ticks_poc_diff_one_minus1, uint16 min_spatial_segmentation_idc, uint16 reserved3, uint8 max_bytes_per_pic_denom, uint8 max_bits_per_min_cu_denom, uint8 log2_max_mv_length_horizontal, uint8 log2_max_mv_length_vertical, StdVideoH265HrdParameters* pHrdParameters = null) : this() + { + this.flags = flags; + this.aspect_ratio_idc = aspect_ratio_idc; + this.sar_width = sar_width; + this.sar_height = sar_height; + this.video_format = video_format; + this.colour_primaries = colour_primaries; + this.transfer_characteristics = transfer_characteristics; + this.matrix_coeffs = matrix_coeffs; + this.chroma_sample_loc_type_top_field = chroma_sample_loc_type_top_field; + this.chroma_sample_loc_type_bottom_field = chroma_sample_loc_type_bottom_field; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.def_disp_win_left_offset = def_disp_win_left_offset; + this.def_disp_win_right_offset = def_disp_win_right_offset; + this.def_disp_win_top_offset = def_disp_win_top_offset; + this.def_disp_win_bottom_offset = def_disp_win_bottom_offset; + this.vui_num_units_in_tick = vui_num_units_in_tick; + this.vui_time_scale = vui_time_scale; + this.vui_num_ticks_poc_diff_one_minus1 = vui_num_ticks_poc_diff_one_minus1; + this.min_spatial_segmentation_idc = min_spatial_segmentation_idc; + this.reserved3 = reserved3; + this.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + this.max_bits_per_min_cu_denom = max_bits_per_min_cu_denom; + this.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + this.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + this.pHrdParameters = pHrdParameters; + } +} + +[CRepr] struct StdVideoH265PredictorPaletteEntries : this() +{ + public uint16[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE] PredictorPaletteEntries = .(); + + public this(uint16[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE] PredictorPaletteEntries) : this() + { + this.PredictorPaletteEntries = PredictorPaletteEntries; + } +} + +[CRepr] struct StdVideoH265SpsFlags : this() +{ + [Bitfield(.Public, .Bits(1), "sps_temporal_id_nesting_flag")] + [Bitfield(.Public, .Bits(1), "separate_colour_plane_flag")] + [Bitfield(.Public, .Bits(1), "conformance_window_flag")] + [Bitfield(.Public, .Bits(1), "sps_sub_layer_ordering_info_present_flag")] + [Bitfield(.Public, .Bits(1), "scaling_list_enabled_flag")] + [Bitfield(.Public, .Bits(1), "sps_scaling_list_data_present_flag")] + [Bitfield(.Public, .Bits(1), "amp_enabled_flag")] + [Bitfield(.Public, .Bits(1), "sample_adaptive_offset_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pcm_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pcm_loop_filter_disabled_flag")] + [Bitfield(.Public, .Bits(1), "long_term_ref_pics_present_flag")] + [Bitfield(.Public, .Bits(1), "sps_temporal_mvp_enabled_flag")] + [Bitfield(.Public, .Bits(1), "strong_intra_smoothing_enabled_flag")] + [Bitfield(.Public, .Bits(1), "vui_parameters_present_flag")] + [Bitfield(.Public, .Bits(1), "sps_extension_present_flag")] + [Bitfield(.Public, .Bits(1), "sps_range_extension_flag")] + + [Bitfield(.Public, .Bits(1), "transform_skip_rotation_enabled_flag")] + [Bitfield(.Public, .Bits(1), "transform_skip_context_enabled_flag")] + [Bitfield(.Public, .Bits(1), "implicit_rdpcm_enabled_flag")] + [Bitfield(.Public, .Bits(1), "explicit_rdpcm_enabled_flag")] + [Bitfield(.Public, .Bits(1), "extended_precision_processing_flag")] + [Bitfield(.Public, .Bits(1), "intra_smoothing_disabled_flag")] + [Bitfield(.Public, .Bits(1), "high_precision_offsets_enabled_flag")] + [Bitfield(.Public, .Bits(1), "persistent_rice_adaptation_enabled_flag")] + [Bitfield(.Public, .Bits(1), "cabac_bypass_alignment_enabled_flag")] + + [Bitfield(.Public, .Bits(1), "sps_scc_extension_flag")] + [Bitfield(.Public, .Bits(1), "sps_curr_pic_ref_enabled_flag")] + [Bitfield(.Public, .Bits(1), "palette_mode_enabled_flag")] + [Bitfield(.Public, .Bits(1), "sps_palette_predictor_initializers_present_flag")] + [Bitfield(.Public, .Bits(1), "intra_boundary_filtering_disabled_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 sps_temporal_id_nesting_flag, uint32 separate_colour_plane_flag, uint32 conformance_window_flag, uint32 sps_sub_layer_ordering_info_present_flag, uint32 scaling_list_enabled_flag, uint32 sps_scaling_list_data_present_flag, uint32 amp_enabled_flag, uint32 sample_adaptive_offset_enabled_flag, uint32 pcm_enabled_flag, uint32 pcm_loop_filter_disabled_flag, uint32 long_term_ref_pics_present_flag, uint32 sps_temporal_mvp_enabled_flag, uint32 strong_intra_smoothing_enabled_flag, uint32 vui_parameters_present_flag, uint32 sps_extension_present_flag, uint32 sps_range_extension_flag, uint32 transform_skip_rotation_enabled_flag, uint32 transform_skip_context_enabled_flag, uint32 implicit_rdpcm_enabled_flag, uint32 explicit_rdpcm_enabled_flag, uint32 extended_precision_processing_flag, uint32 intra_smoothing_disabled_flag, uint32 high_precision_offsets_enabled_flag, uint32 persistent_rice_adaptation_enabled_flag, uint32 cabac_bypass_alignment_enabled_flag, uint32 sps_scc_extension_flag, uint32 sps_curr_pic_ref_enabled_flag, uint32 palette_mode_enabled_flag, uint32 sps_palette_predictor_initializers_present_flag, uint32 intra_boundary_filtering_disabled_flag) : this() + { + this.sps_temporal_id_nesting_flag = sps_temporal_id_nesting_flag; + this.separate_colour_plane_flag = separate_colour_plane_flag; + this.conformance_window_flag = conformance_window_flag; + this.sps_sub_layer_ordering_info_present_flag = sps_sub_layer_ordering_info_present_flag; + this.scaling_list_enabled_flag = scaling_list_enabled_flag; + this.sps_scaling_list_data_present_flag = sps_scaling_list_data_present_flag; + this.amp_enabled_flag = amp_enabled_flag; + this.sample_adaptive_offset_enabled_flag = sample_adaptive_offset_enabled_flag; + this.pcm_enabled_flag = pcm_enabled_flag; + this.pcm_loop_filter_disabled_flag = pcm_loop_filter_disabled_flag; + this.long_term_ref_pics_present_flag = long_term_ref_pics_present_flag; + this.sps_temporal_mvp_enabled_flag = sps_temporal_mvp_enabled_flag; + this.strong_intra_smoothing_enabled_flag = strong_intra_smoothing_enabled_flag; + this.vui_parameters_present_flag = vui_parameters_present_flag; + this.sps_extension_present_flag = sps_extension_present_flag; + this.sps_range_extension_flag = sps_range_extension_flag; + this.transform_skip_rotation_enabled_flag = transform_skip_rotation_enabled_flag; + this.transform_skip_context_enabled_flag = transform_skip_context_enabled_flag; + this.implicit_rdpcm_enabled_flag = implicit_rdpcm_enabled_flag; + this.explicit_rdpcm_enabled_flag = explicit_rdpcm_enabled_flag; + this.extended_precision_processing_flag = extended_precision_processing_flag; + this.intra_smoothing_disabled_flag = intra_smoothing_disabled_flag; + this.high_precision_offsets_enabled_flag = high_precision_offsets_enabled_flag; + this.persistent_rice_adaptation_enabled_flag = persistent_rice_adaptation_enabled_flag; + this.cabac_bypass_alignment_enabled_flag = cabac_bypass_alignment_enabled_flag; + this.sps_scc_extension_flag = sps_scc_extension_flag; + this.sps_curr_pic_ref_enabled_flag = sps_curr_pic_ref_enabled_flag; + this.palette_mode_enabled_flag = palette_mode_enabled_flag; + this.sps_palette_predictor_initializers_present_flag = sps_palette_predictor_initializers_present_flag; + this.intra_boundary_filtering_disabled_flag = intra_boundary_filtering_disabled_flag; + } +} + +[CRepr] struct StdVideoH265ShortTermRefPicSetFlags : this() +{ + [Bitfield(.Public, .Bits(1), "inter_ref_pic_set_prediction_flag")] + [Bitfield(.Public, .Bits(1), "delta_rps_sign")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 inter_ref_pic_set_prediction_flag, uint32 delta_rps_sign) : this() + { + this.inter_ref_pic_set_prediction_flag = inter_ref_pic_set_prediction_flag; + this.delta_rps_sign = delta_rps_sign; + } +} + +[CRepr] struct StdVideoH265ShortTermRefPicSet : this() +{ + public StdVideoH265ShortTermRefPicSetFlags flags = default; + public uint32 delta_idx_minus1 = 0; + public uint16 use_delta_flag = 0; // each bit represents a use_delta_flag[j] syntax + public uint16 abs_delta_rps_minus1 = 0; + public uint16 used_by_curr_pic_flag = 0; // each bit represents a used_by_curr_pic_flag[j] syntax + public uint16 used_by_curr_pic_s0_flag = 0; // each bit represents a used_by_curr_pic_s0_flag[i] syntax + public uint16 used_by_curr_pic_s1_flag = 0; // each bit represents a used_by_curr_pic_s1_flag[i] syntax + public uint16 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved3 = 0; // Reserved for future use and must be initialized with 0. + public uint8 num_negative_pics = 0; + public uint8 num_positive_pics = 0; + public uint16[STD_VIDEO_H265_MAX_DPB_SIZE] delta_poc_s0_minus1 = .(); + public uint16[STD_VIDEO_H265_MAX_DPB_SIZE] delta_poc_s1_minus1 = .(); + + public this(StdVideoH265ShortTermRefPicSetFlags flags, uint32 delta_idx_minus1, uint16 use_delta_flag, uint16 abs_delta_rps_minus1, uint16 used_by_curr_pic_flag, uint16 used_by_curr_pic_s0_flag, uint16 used_by_curr_pic_s1_flag, uint16 reserved1, uint8 reserved2, uint8 reserved3, uint8 num_negative_pics, uint8 num_positive_pics, uint16[STD_VIDEO_H265_MAX_DPB_SIZE] delta_poc_s0_minus1, uint16[STD_VIDEO_H265_MAX_DPB_SIZE] delta_poc_s1_minus1) : this() + { + this.flags = flags; + this.delta_idx_minus1 = delta_idx_minus1; + this.use_delta_flag = use_delta_flag; + this.abs_delta_rps_minus1 = abs_delta_rps_minus1; + this.used_by_curr_pic_flag = used_by_curr_pic_flag; + this.used_by_curr_pic_s0_flag = used_by_curr_pic_s0_flag; + this.used_by_curr_pic_s1_flag = used_by_curr_pic_s1_flag; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.reserved3 = reserved3; + this.num_negative_pics = num_negative_pics; + this.num_positive_pics = num_positive_pics; + this.delta_poc_s0_minus1 = delta_poc_s0_minus1; + this.delta_poc_s1_minus1 = delta_poc_s1_minus1; + } +} + +[CRepr] struct StdVideoH265LongTermRefPicsSps : this() +{ + public uint32 used_by_curr_pic_lt_sps_flag = 0; // each bit represents a used_by_curr_pic_lt_sps_flag[i] syntax + public uint32[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS] lt_ref_pic_poc_lsb_sps = .(); + + public this(uint32 used_by_curr_pic_lt_sps_flag, uint32[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS] lt_ref_pic_poc_lsb_sps) : this() + { + this.used_by_curr_pic_lt_sps_flag = used_by_curr_pic_lt_sps_flag; + this.lt_ref_pic_poc_lsb_sps = lt_ref_pic_poc_lsb_sps; + } +} + +[CRepr] struct StdVideoH265SequenceParameterSet : this() +{ + public StdVideoH265SpsFlags flags = default; + public StdVideoH265ChromaFormatIdc chroma_format_idc = default; + public uint32 pic_width_in_luma_samples = 0; + public uint32 pic_height_in_luma_samples = 0; + public uint8 sps_video_parameter_set_id = 0; + public uint8 sps_max_sub_layers_minus1 = 0; + public uint8 sps_seq_parameter_set_id = 0; + public uint8 bit_depth_luma_minus8 = 0; + public uint8 bit_depth_chroma_minus8 = 0; + public uint8 log2_max_pic_order_cnt_lsb_minus4 = 0; + public uint8 log2_min_luma_coding_block_size_minus3 = 0; + public uint8 log2_diff_max_min_luma_coding_block_size = 0; + public uint8 log2_min_luma_transform_block_size_minus2 = 0; + public uint8 log2_diff_max_min_luma_transform_block_size = 0; + public uint8 max_transform_hierarchy_depth_inter = 0; + public uint8 max_transform_hierarchy_depth_intra = 0; + public uint8 num_short_term_ref_pic_sets = 0; + public uint8 num_long_term_ref_pics_sps = 0; + public uint8 pcm_sample_bit_depth_luma_minus1 = 0; + public uint8 pcm_sample_bit_depth_chroma_minus1 = 0; + public uint8 log2_min_pcm_luma_coding_block_size_minus3 = 0; + public uint8 log2_diff_max_min_pcm_luma_coding_block_size = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + + public uint8 palette_max_size = 0; + public uint8 delta_palette_max_predictor_size = 0; + public uint8 motion_vector_resolution_control_idc = 0; + public uint8 sps_num_palette_predictor_initializers_minus1 = 0; + + public uint32 conf_win_left_offset = 0; + public uint32 conf_win_right_offset = 0; + public uint32 conf_win_top_offset = 0; + public uint32 conf_win_bottom_offset = 0; + public StdVideoH265ProfileTierLevel* pProfileTierLevel = null; + public StdVideoH265DecPicBufMgr* pDecPicBufMgr = null; + public StdVideoH265ScalingLists* pScalingLists = null; // Must be a valid pointer if sps_scaling_list_data_present_flag is set + public StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet = null; // Must be a valid pointer to an array with size num_short_term_ref_pic_sets if num_short_term_ref_pic_sets is not 0. + public Span shortTermRefPicSet + { + get { return .(pShortTermRefPicSet, (.)num_short_term_ref_pic_sets); } + set mut { pShortTermRefPicSet = value.Ptr; num_short_term_ref_pic_sets = (.)value.Length; } + } + public StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps = null; // Must be a valid pointer if long_term_ref_pics_present_flag is set + public StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui = null; // Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size + public StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries = null; // Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set + + public this(StdVideoH265SpsFlags flags, StdVideoH265ChromaFormatIdc chroma_format_idc, uint32 pic_width_in_luma_samples, uint32 pic_height_in_luma_samples, uint8 sps_video_parameter_set_id, uint8 sps_max_sub_layers_minus1, uint8 sps_seq_parameter_set_id, uint8 bit_depth_luma_minus8, uint8 bit_depth_chroma_minus8, uint8 log2_max_pic_order_cnt_lsb_minus4, uint8 log2_min_luma_coding_block_size_minus3, uint8 log2_diff_max_min_luma_coding_block_size, uint8 log2_min_luma_transform_block_size_minus2, uint8 log2_diff_max_min_luma_transform_block_size, uint8 max_transform_hierarchy_depth_inter, uint8 max_transform_hierarchy_depth_intra, uint8 num_long_term_ref_pics_sps, uint8 pcm_sample_bit_depth_luma_minus1, uint8 pcm_sample_bit_depth_chroma_minus1, uint8 log2_min_pcm_luma_coding_block_size_minus3, uint8 log2_diff_max_min_pcm_luma_coding_block_size, uint8 reserved1, uint8 reserved2, uint8 palette_max_size, uint8 delta_palette_max_predictor_size, uint8 motion_vector_resolution_control_idc, uint8 sps_num_palette_predictor_initializers_minus1, uint32 conf_win_left_offset, uint32 conf_win_right_offset, uint32 conf_win_top_offset, uint32 conf_win_bottom_offset, StdVideoH265ProfileTierLevel* pProfileTierLevel, StdVideoH265DecPicBufMgr* pDecPicBufMgr, StdVideoH265ScalingLists* pScalingLists, Span shortTermRefPicSet, StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps = null, StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui = null, StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries = null) : this() + { + this.flags = flags; + this.chroma_format_idc = chroma_format_idc; + this.pic_width_in_luma_samples = pic_width_in_luma_samples; + this.pic_height_in_luma_samples = pic_height_in_luma_samples; + this.sps_video_parameter_set_id = sps_video_parameter_set_id; + this.sps_max_sub_layers_minus1 = sps_max_sub_layers_minus1; + this.sps_seq_parameter_set_id = sps_seq_parameter_set_id; + this.bit_depth_luma_minus8 = bit_depth_luma_minus8; + this.bit_depth_chroma_minus8 = bit_depth_chroma_minus8; + this.log2_max_pic_order_cnt_lsb_minus4 = log2_max_pic_order_cnt_lsb_minus4; + this.log2_min_luma_coding_block_size_minus3 = log2_min_luma_coding_block_size_minus3; + this.log2_diff_max_min_luma_coding_block_size = log2_diff_max_min_luma_coding_block_size; + this.log2_min_luma_transform_block_size_minus2 = log2_min_luma_transform_block_size_minus2; + this.log2_diff_max_min_luma_transform_block_size = log2_diff_max_min_luma_transform_block_size; + this.max_transform_hierarchy_depth_inter = max_transform_hierarchy_depth_inter; + this.max_transform_hierarchy_depth_intra = max_transform_hierarchy_depth_intra; + this.num_long_term_ref_pics_sps = num_long_term_ref_pics_sps; + this.pcm_sample_bit_depth_luma_minus1 = pcm_sample_bit_depth_luma_minus1; + this.pcm_sample_bit_depth_chroma_minus1 = pcm_sample_bit_depth_chroma_minus1; + this.log2_min_pcm_luma_coding_block_size_minus3 = log2_min_pcm_luma_coding_block_size_minus3; + this.log2_diff_max_min_pcm_luma_coding_block_size = log2_diff_max_min_pcm_luma_coding_block_size; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.palette_max_size = palette_max_size; + this.delta_palette_max_predictor_size = delta_palette_max_predictor_size; + this.motion_vector_resolution_control_idc = motion_vector_resolution_control_idc; + this.sps_num_palette_predictor_initializers_minus1 = sps_num_palette_predictor_initializers_minus1; + this.conf_win_left_offset = conf_win_left_offset; + this.conf_win_right_offset = conf_win_right_offset; + this.conf_win_top_offset = conf_win_top_offset; + this.conf_win_bottom_offset = conf_win_bottom_offset; + this.pProfileTierLevel = pProfileTierLevel; + this.pDecPicBufMgr = pDecPicBufMgr; + this.pScalingLists = pScalingLists; + this.shortTermRefPicSet = shortTermRefPicSet; + this.pLongTermRefPicsSps = pLongTermRefPicsSps; + this.pSequenceParameterSetVui = pSequenceParameterSetVui; + this.pPredictorPaletteEntries = pPredictorPaletteEntries; + } +} + +[CRepr] struct StdVideoH265PpsFlags : this() +{ + [Bitfield(.Public, .Bits(1), "dependent_slice_segments_enabled_flag")] + [Bitfield(.Public, .Bits(1), "output_flag_present_flag")] + [Bitfield(.Public, .Bits(1), "sign_data_hiding_enabled_flag")] + [Bitfield(.Public, .Bits(1), "cabac_init_present_flag")] + [Bitfield(.Public, .Bits(1), "constrained_intra_pred_flag")] + [Bitfield(.Public, .Bits(1), "transform_skip_enabled_flag")] + [Bitfield(.Public, .Bits(1), "cu_qp_delta_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pps_slice_chroma_qp_offsets_present_flag")] + [Bitfield(.Public, .Bits(1), "weighted_pred_flag")] + [Bitfield(.Public, .Bits(1), "weighted_bipred_flag")] + [Bitfield(.Public, .Bits(1), "transquant_bypass_enabled_flag")] + [Bitfield(.Public, .Bits(1), "tiles_enabled_flag")] + [Bitfield(.Public, .Bits(1), "entropy_coding_sync_enabled_flag")] + [Bitfield(.Public, .Bits(1), "uniform_spacing_flag")] + [Bitfield(.Public, .Bits(1), "loop_filter_across_tiles_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pps_loop_filter_across_slices_enabled_flag")] + [Bitfield(.Public, .Bits(1), "deblocking_filter_control_present_flag")] + [Bitfield(.Public, .Bits(1), "deblocking_filter_override_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pps_deblocking_filter_disabled_flag")] + [Bitfield(.Public, .Bits(1), "pps_scaling_list_data_present_flag")] + [Bitfield(.Public, .Bits(1), "lists_modification_present_flag")] + [Bitfield(.Public, .Bits(1), "slice_segment_header_extension_present_flag")] + [Bitfield(.Public, .Bits(1), "pps_extension_present_flag")] + + [Bitfield(.Public, .Bits(1), "cross_component_prediction_enabled_flag")] + [Bitfield(.Public, .Bits(1), "chroma_qp_offset_list_enabled_flag")] + + [Bitfield(.Public, .Bits(1), "pps_curr_pic_ref_enabled_flag")] + [Bitfield(.Public, .Bits(1), "residual_adaptive_colour_transform_enabled_flag")] + [Bitfield(.Public, .Bits(1), "pps_slice_act_qp_offsets_present_flag")] + [Bitfield(.Public, .Bits(1), "pps_palette_predictor_initializers_present_flag")] + [Bitfield(.Public, .Bits(1), "monochrome_palette_flag")] + [Bitfield(.Public, .Bits(1), "pps_range_extension_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 dependent_slice_segments_enabled_flag, uint32 output_flag_present_flag, uint32 sign_data_hiding_enabled_flag, uint32 cabac_init_present_flag, uint32 constrained_intra_pred_flag, uint32 transform_skip_enabled_flag, uint32 cu_qp_delta_enabled_flag, uint32 pps_slice_chroma_qp_offsets_present_flag, uint32 weighted_pred_flag, uint32 weighted_bipred_flag, uint32 transquant_bypass_enabled_flag, uint32 tiles_enabled_flag, uint32 entropy_coding_sync_enabled_flag, uint32 uniform_spacing_flag, uint32 loop_filter_across_tiles_enabled_flag, uint32 pps_loop_filter_across_slices_enabled_flag, uint32 deblocking_filter_control_present_flag, uint32 deblocking_filter_override_enabled_flag, uint32 pps_deblocking_filter_disabled_flag, uint32 pps_scaling_list_data_present_flag, uint32 lists_modification_present_flag, uint32 slice_segment_header_extension_present_flag, uint32 pps_extension_present_flag, uint32 cross_component_prediction_enabled_flag, uint32 chroma_qp_offset_list_enabled_flag, uint32 pps_curr_pic_ref_enabled_flag, uint32 residual_adaptive_colour_transform_enabled_flag, uint32 pps_slice_act_qp_offsets_present_flag, uint32 pps_palette_predictor_initializers_present_flag, uint32 monochrome_palette_flag, uint32 pps_range_extension_flag) : this() + { + this.dependent_slice_segments_enabled_flag = dependent_slice_segments_enabled_flag; + this.output_flag_present_flag = output_flag_present_flag; + this.sign_data_hiding_enabled_flag = sign_data_hiding_enabled_flag; + this.cabac_init_present_flag = cabac_init_present_flag; + this.constrained_intra_pred_flag = constrained_intra_pred_flag; + this.transform_skip_enabled_flag = transform_skip_enabled_flag; + this.cu_qp_delta_enabled_flag = cu_qp_delta_enabled_flag; + this.pps_slice_chroma_qp_offsets_present_flag = pps_slice_chroma_qp_offsets_present_flag; + this.weighted_pred_flag = weighted_pred_flag; + this.weighted_bipred_flag = weighted_bipred_flag; + this.transquant_bypass_enabled_flag = transquant_bypass_enabled_flag; + this.tiles_enabled_flag = tiles_enabled_flag; + this.entropy_coding_sync_enabled_flag = entropy_coding_sync_enabled_flag; + this.uniform_spacing_flag = uniform_spacing_flag; + this.loop_filter_across_tiles_enabled_flag = loop_filter_across_tiles_enabled_flag; + this.pps_loop_filter_across_slices_enabled_flag = pps_loop_filter_across_slices_enabled_flag; + this.deblocking_filter_control_present_flag = deblocking_filter_control_present_flag; + this.deblocking_filter_override_enabled_flag = deblocking_filter_override_enabled_flag; + this.pps_deblocking_filter_disabled_flag = pps_deblocking_filter_disabled_flag; + this.pps_scaling_list_data_present_flag = pps_scaling_list_data_present_flag; + this.lists_modification_present_flag = lists_modification_present_flag; + this.slice_segment_header_extension_present_flag = slice_segment_header_extension_present_flag; + this.pps_extension_present_flag = pps_extension_present_flag; + this.cross_component_prediction_enabled_flag = cross_component_prediction_enabled_flag; + this.chroma_qp_offset_list_enabled_flag = chroma_qp_offset_list_enabled_flag; + this.pps_curr_pic_ref_enabled_flag = pps_curr_pic_ref_enabled_flag; + this.residual_adaptive_colour_transform_enabled_flag = residual_adaptive_colour_transform_enabled_flag; + this.pps_slice_act_qp_offsets_present_flag = pps_slice_act_qp_offsets_present_flag; + this.pps_palette_predictor_initializers_present_flag = pps_palette_predictor_initializers_present_flag; + this.monochrome_palette_flag = monochrome_palette_flag; + this.pps_range_extension_flag = pps_range_extension_flag; + } +} + +[CRepr] struct StdVideoH265PictureParameterSet : this() +{ + public StdVideoH265PpsFlags flags = default; + public uint8 pps_pic_parameter_set_id = 0; + public uint8 pps_seq_parameter_set_id = 0; + public uint8 sps_video_parameter_set_id = 0; + public uint8 num_extra_slice_header_bits = 0; + public uint8 num_ref_idx_l0_default_active_minus1 = 0; + public uint8 num_ref_idx_l1_default_active_minus1 = 0; + public int8 init_qp_minus26 = 0; + public uint8 diff_cu_qp_delta_depth = 0; + public int8 pps_cb_qp_offset = 0; + public int8 pps_cr_qp_offset = 0; + public int8 pps_beta_offset_div2 = 0; + public int8 pps_tc_offset_div2 = 0; + public uint8 log2_parallel_merge_level_minus2 = 0; + + public uint8 log2_max_transform_skip_block_size_minus2 = 0; + public uint8 diff_cu_chroma_qp_offset_depth = 0; + public uint8 chroma_qp_offset_list_len_minus1 = 0; + public int8[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE] cb_qp_offset_list = .(); + public int8[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE] cr_qp_offset_list = .(); + public uint8 log2_sao_offset_scale_luma = 0; + public uint8 log2_sao_offset_scale_chroma = 0; + + public int8 pps_act_y_qp_offset_plus5 = 0; + public int8 pps_act_cb_qp_offset_plus5 = 0; + public int8 pps_act_cr_qp_offset_plus3 = 0; + public uint8 pps_num_palette_predictor_initializers = 0; + public uint8 luma_bit_depth_entry_minus8 = 0; + public uint8 chroma_bit_depth_entry_minus8 = 0; + public uint8 num_tile_columns_minus1 = 0; + public uint8 num_tile_rows_minus1 = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint8 reserved2 = 0; // Reserved for future use and must be initialized with 0. + public uint16[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE] column_width_minus1 = .(); + public uint16[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE] row_height_minus1 = .(); + public uint32 reserved3 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoH265ScalingLists* pScalingLists = null; // Must be a valid pointer if pps_scaling_list_data_present_flag is set + public StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries = null; // Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set + + public this(StdVideoH265PpsFlags flags, uint8 pps_pic_parameter_set_id, uint8 pps_seq_parameter_set_id, uint8 sps_video_parameter_set_id, uint8 num_extra_slice_header_bits, uint8 num_ref_idx_l0_default_active_minus1, uint8 num_ref_idx_l1_default_active_minus1, int8 init_qp_minus26, uint8 diff_cu_qp_delta_depth, int8 pps_cb_qp_offset, int8 pps_cr_qp_offset, int8 pps_beta_offset_div2, int8 pps_tc_offset_div2, uint8 log2_parallel_merge_level_minus2, uint8 log2_max_transform_skip_block_size_minus2, uint8 diff_cu_chroma_qp_offset_depth, uint8 chroma_qp_offset_list_len_minus1, int8[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE] cb_qp_offset_list, int8[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE] cr_qp_offset_list, uint8 log2_sao_offset_scale_luma, uint8 log2_sao_offset_scale_chroma, int8 pps_act_y_qp_offset_plus5, int8 pps_act_cb_qp_offset_plus5, int8 pps_act_cr_qp_offset_plus3, uint8 pps_num_palette_predictor_initializers, uint8 luma_bit_depth_entry_minus8, uint8 chroma_bit_depth_entry_minus8, uint8 num_tile_columns_minus1, uint8 num_tile_rows_minus1, uint8 reserved1, uint8 reserved2, uint16[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE] column_width_minus1, uint16[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE] row_height_minus1, uint32 reserved3, StdVideoH265ScalingLists* pScalingLists = null, StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries = null) : this() + { + this.flags = flags; + this.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + this.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + this.sps_video_parameter_set_id = sps_video_parameter_set_id; + this.num_extra_slice_header_bits = num_extra_slice_header_bits; + this.num_ref_idx_l0_default_active_minus1 = num_ref_idx_l0_default_active_minus1; + this.num_ref_idx_l1_default_active_minus1 = num_ref_idx_l1_default_active_minus1; + this.init_qp_minus26 = init_qp_minus26; + this.diff_cu_qp_delta_depth = diff_cu_qp_delta_depth; + this.pps_cb_qp_offset = pps_cb_qp_offset; + this.pps_cr_qp_offset = pps_cr_qp_offset; + this.pps_beta_offset_div2 = pps_beta_offset_div2; + this.pps_tc_offset_div2 = pps_tc_offset_div2; + this.log2_parallel_merge_level_minus2 = log2_parallel_merge_level_minus2; + this.log2_max_transform_skip_block_size_minus2 = log2_max_transform_skip_block_size_minus2; + this.diff_cu_chroma_qp_offset_depth = diff_cu_chroma_qp_offset_depth; + this.chroma_qp_offset_list_len_minus1 = chroma_qp_offset_list_len_minus1; + this.cb_qp_offset_list = cb_qp_offset_list; + this.cr_qp_offset_list = cr_qp_offset_list; + this.log2_sao_offset_scale_luma = log2_sao_offset_scale_luma; + this.log2_sao_offset_scale_chroma = log2_sao_offset_scale_chroma; + this.pps_act_y_qp_offset_plus5 = pps_act_y_qp_offset_plus5; + this.pps_act_cb_qp_offset_plus5 = pps_act_cb_qp_offset_plus5; + this.pps_act_cr_qp_offset_plus3 = pps_act_cr_qp_offset_plus3; + this.pps_num_palette_predictor_initializers = pps_num_palette_predictor_initializers; + this.luma_bit_depth_entry_minus8 = luma_bit_depth_entry_minus8; + this.chroma_bit_depth_entry_minus8 = chroma_bit_depth_entry_minus8; + this.num_tile_columns_minus1 = num_tile_columns_minus1; + this.num_tile_rows_minus1 = num_tile_rows_minus1; + this.reserved1 = reserved1; + this.reserved2 = reserved2; + this.column_width_minus1 = column_width_minus1; + this.row_height_minus1 = row_height_minus1; + this.reserved3 = reserved3; + this.pScalingLists = pScalingLists; + this.pPredictorPaletteEntries = pPredictorPaletteEntries; + } +} + +// protect with VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_h265_decode"; } +static { public const uint32 STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE = 8; } + +[CRepr] struct StdVideoDecodeH265PictureInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "IrapPicFlag")] + [Bitfield(.Public, .Bits(1), "IdrPicFlag")] + [Bitfield(.Public, .Bits(1), "IsReference")] + [Bitfield(.Public, .Bits(1), "short_term_ref_pic_set_sps_flag")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 IrapPicFlag, uint32 IdrPicFlag, uint32 IsReference, uint32 short_term_ref_pic_set_sps_flag) : this() + { + this.IrapPicFlag = IrapPicFlag; + this.IdrPicFlag = IdrPicFlag; + this.IsReference = IsReference; + this.short_term_ref_pic_set_sps_flag = short_term_ref_pic_set_sps_flag; + } +} + +[CRepr] struct StdVideoDecodeH265PictureInfo : this() +{ + public StdVideoDecodeH265PictureInfoFlags flags = default; + public uint8 sps_video_parameter_set_id = 0; // Selecting VPS id from the Video Parameters Set + public uint8 pps_seq_parameter_set_id = 0; // Selecting SPS id from the Sequence Parameters Set + public uint8 pps_pic_parameter_set_id = 0; // Selecting PPS id from the Picture Parameters Set + public uint8 NumDeltaPocsOfRefRpsIdx = 0; // NumDeltaPocs[ RefRpsIdx ] when short_term_ref_pic_set_sps_flag = 1, otherwise 0 + public int32 PicOrderCntVal = 0; + public uint16 NumBitsForSTRefPicSetInSlice = 0; // number of bits used in st_ref_pic_set() when short_term_ref_pic_set_sps_flag is 0otherwise set to 0. + public uint16 reserved = 0; + public uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetStCurrBefore = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures representing pReferenceSlots in VkVideoDecodeInfoKHR or STD_VIDEO_H265_NO_REFERENCE_PICTURE + public uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetStCurrAfter = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures representing pReferenceSlots in VkVideoDecodeInfoKHR or STD_VIDEO_H265_NO_REFERENCE_PICTURE + public uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetLtCurr = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures representing pReferenceSlots in VkVideoDecodeInfoKHR or STD_VIDEO_H265_NO_REFERENCE_PICTURE + + public this(StdVideoDecodeH265PictureInfoFlags flags, uint8 sps_video_parameter_set_id, uint8 pps_seq_parameter_set_id, uint8 pps_pic_parameter_set_id, uint8 NumDeltaPocsOfRefRpsIdx, int32 PicOrderCntVal, uint16 NumBitsForSTRefPicSetInSlice, uint16 reserved, uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetStCurrBefore, uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetStCurrAfter, uint8[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE] RefPicSetLtCurr) : this() + { + this.flags = flags; + this.sps_video_parameter_set_id = sps_video_parameter_set_id; + this.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + this.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + this.NumDeltaPocsOfRefRpsIdx = NumDeltaPocsOfRefRpsIdx; + this.PicOrderCntVal = PicOrderCntVal; + this.NumBitsForSTRefPicSetInSlice = NumBitsForSTRefPicSetInSlice; + this.reserved = reserved; + this.RefPicSetStCurrBefore = RefPicSetStCurrBefore; + this.RefPicSetStCurrAfter = RefPicSetStCurrAfter; + this.RefPicSetLtCurr = RefPicSetLtCurr; + } +} + +[CRepr] struct StdVideoDecodeH265ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "used_for_long_term_reference")] + [Bitfield(.Public, .Bits(1), "unused_for_reference")] + private uint32 __bitfields_remainder = 0; + + public this(uint32 used_for_long_term_reference, uint32 unused_for_reference) : this() + { + this.used_for_long_term_reference = used_for_long_term_reference; + this.unused_for_reference = unused_for_reference; + } +} + +[CRepr] struct StdVideoDecodeH265ReferenceInfo : this() +{ + public StdVideoDecodeH265ReferenceInfoFlags flags = default; + public int32 PicOrderCntVal = 0; + + public this(StdVideoDecodeH265ReferenceInfoFlags flags, int32 PicOrderCntVal) : this() + { + this.flags = flags; + this.PicOrderCntVal = PicOrderCntVal; + } +} + +// protect with VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_h265_encode"; } + +[CRepr] struct StdVideoEncodeH265WeightTableFlags : this() +{ + public uint16 luma_weight_l0_flag = 0; // each bit n represents the nth entry in reference list l0, n <= num_ref_idx_l0_active_minus1 + public uint16 chroma_weight_l0_flag = 0; // each bit n represents the nth entry in reference list l0, n <= num_ref_idx_l0_active_minus1 + public uint16 luma_weight_l1_flag = 0; // each bit n represents the nth entry in reference list l1, n <= num_ref_idx_l1_active_minus1 + public uint16 chroma_weight_l1_flag = 0; // each bit n represents the nth entry in reference list l1, n <= num_ref_idx_l1_active_minus1 + + public this(uint16 luma_weight_l0_flag, uint16 chroma_weight_l0_flag, uint16 luma_weight_l1_flag, uint16 chroma_weight_l1_flag) : this() + { + this.luma_weight_l0_flag = luma_weight_l0_flag; + this.chroma_weight_l0_flag = chroma_weight_l0_flag; + this.luma_weight_l1_flag = luma_weight_l1_flag; + this.chroma_weight_l1_flag = chroma_weight_l1_flag; + } +} + +[CRepr] struct StdVideoEncodeH265WeightTable : this() +{ + + public StdVideoEncodeH265WeightTableFlags flags = default; + public uint8 luma_log2_weight_denom = 0; // [0, 7] + public int8 delta_chroma_log2_weight_denom = 0; + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] delta_luma_weight_l0 = .(); // comment + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] luma_offset_l0 = .(); // comment + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_weight_l0 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l0_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_offset_l0 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l0_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] delta_luma_weight_l1 = .(); + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] luma_offset_l1 = .(); + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_weight_l1 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l1_active_minus1]; j = 0 for Cb, j = 1 for Cr + public int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_offset_l1 = .(); // [i][j]: valid entry range for i is [0, num_ref_idx_l1_active_minus1]; j = 0 for Cb, j = 1 for Cr + + public this(StdVideoEncodeH265WeightTableFlags flags, uint8 luma_log2_weight_denom, int8 delta_chroma_log2_weight_denom, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] delta_luma_weight_l0, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] luma_offset_l0, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_weight_l0, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_offset_l0, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] delta_luma_weight_l1, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF] luma_offset_l1, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_weight_l1, int8[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES] delta_chroma_offset_l1) : this() + { + this.flags = flags; + this.luma_log2_weight_denom = luma_log2_weight_denom; + this.delta_chroma_log2_weight_denom = delta_chroma_log2_weight_denom; + this.delta_luma_weight_l0 = delta_luma_weight_l0; + this.luma_offset_l0 = luma_offset_l0; + this.delta_chroma_weight_l0 = delta_chroma_weight_l0; + this.delta_chroma_offset_l0 = delta_chroma_offset_l0; + this.delta_luma_weight_l1 = delta_luma_weight_l1; + this.luma_offset_l1 = luma_offset_l1; + this.delta_chroma_weight_l1 = delta_chroma_weight_l1; + this.delta_chroma_offset_l1 = delta_chroma_offset_l1; + } +} + +[CRepr] struct StdVideoEncodeH265SliceSegmentHeaderFlags : this() +{ + [Bitfield(.Public, .Bits(1), "first_slice_segment_in_pic_flag")] + [Bitfield(.Public, .Bits(1), "dependent_slice_segment_flag")] + [Bitfield(.Public, .Bits(1), "slice_sao_luma_flag")] + [Bitfield(.Public, .Bits(1), "slice_sao_chroma_flag")] + [Bitfield(.Public, .Bits(1), "num_ref_idx_active_override_flag")] + [Bitfield(.Public, .Bits(1), "mvd_l1_zero_flag")] + [Bitfield(.Public, .Bits(1), "cabac_init_flag")] + [Bitfield(.Public, .Bits(1), "cu_chroma_qp_offset_enabled_flag")] + [Bitfield(.Public, .Bits(1), "deblocking_filter_override_flag")] + [Bitfield(.Public, .Bits(1), "slice_deblocking_filter_disabled_flag")] + [Bitfield(.Public, .Bits(1), "collocated_from_l0_flag")] + [Bitfield(.Public, .Bits(1), "slice_loop_filter_across_slices_enabled_flag")] + [Bitfield(.Public, .Bits(20), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 first_slice_segment_in_pic_flag, uint32 dependent_slice_segment_flag, uint32 slice_sao_luma_flag, uint32 slice_sao_chroma_flag, uint32 num_ref_idx_active_override_flag, uint32 mvd_l1_zero_flag, uint32 cabac_init_flag, uint32 cu_chroma_qp_offset_enabled_flag, uint32 deblocking_filter_override_flag, uint32 slice_deblocking_filter_disabled_flag, uint32 collocated_from_l0_flag, uint32 slice_loop_filter_across_slices_enabled_flag, uint32 reserved) : this() + { + this.first_slice_segment_in_pic_flag = first_slice_segment_in_pic_flag; + this.dependent_slice_segment_flag = dependent_slice_segment_flag; + this.slice_sao_luma_flag = slice_sao_luma_flag; + this.slice_sao_chroma_flag = slice_sao_chroma_flag; + this.num_ref_idx_active_override_flag = num_ref_idx_active_override_flag; + this.mvd_l1_zero_flag = mvd_l1_zero_flag; + this.cabac_init_flag = cabac_init_flag; + this.cu_chroma_qp_offset_enabled_flag = cu_chroma_qp_offset_enabled_flag; + this.deblocking_filter_override_flag = deblocking_filter_override_flag; + this.slice_deblocking_filter_disabled_flag = slice_deblocking_filter_disabled_flag; + this.collocated_from_l0_flag = collocated_from_l0_flag; + this.slice_loop_filter_across_slices_enabled_flag = slice_loop_filter_across_slices_enabled_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH265SliceSegmentHeader : this() +{ + public StdVideoEncodeH265SliceSegmentHeaderFlags flags = default; + public StdVideoH265SliceType slice_type = default; + public uint32 slice_segment_address = 0; + public uint8 collocated_ref_idx = 0; + public uint8 MaxNumMergeCand = 0; + public int8 slice_cb_qp_offset = 0; // [-12, 12] + public int8 slice_cr_qp_offset = 0; // [-12, 12] + public int8 slice_beta_offset_div2 = 0; // [-6, 6] + public int8 slice_tc_offset_div2 = 0; // [-6, 6] + public int8 slice_act_y_qp_offset = 0; + public int8 slice_act_cb_qp_offset = 0; + public int8 slice_act_cr_qp_offset = 0; + public int8 slice_qp_delta = 0; + public uint16 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoEncodeH265WeightTable* pWeightTable = null; + + public this(StdVideoEncodeH265SliceSegmentHeaderFlags flags, StdVideoH265SliceType slice_type, uint32 slice_segment_address, uint8 collocated_ref_idx, uint8 MaxNumMergeCand, int8 slice_cb_qp_offset, int8 slice_cr_qp_offset, int8 slice_beta_offset_div2, int8 slice_tc_offset_div2, int8 slice_act_y_qp_offset, int8 slice_act_cb_qp_offset, int8 slice_act_cr_qp_offset, int8 slice_qp_delta, uint16 reserved1, StdVideoEncodeH265WeightTable* pWeightTable = null) : this() + { + this.flags = flags; + this.slice_type = slice_type; + this.slice_segment_address = slice_segment_address; + this.collocated_ref_idx = collocated_ref_idx; + this.MaxNumMergeCand = MaxNumMergeCand; + this.slice_cb_qp_offset = slice_cb_qp_offset; + this.slice_cr_qp_offset = slice_cr_qp_offset; + this.slice_beta_offset_div2 = slice_beta_offset_div2; + this.slice_tc_offset_div2 = slice_tc_offset_div2; + this.slice_act_y_qp_offset = slice_act_y_qp_offset; + this.slice_act_cb_qp_offset = slice_act_cb_qp_offset; + this.slice_act_cr_qp_offset = slice_act_cr_qp_offset; + this.slice_qp_delta = slice_qp_delta; + this.reserved1 = reserved1; + this.pWeightTable = pWeightTable; + } +} + +[CRepr] struct StdVideoEncodeH265ReferenceListsInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "ref_pic_list_modification_flag_l0")] + [Bitfield(.Public, .Bits(1), "ref_pic_list_modification_flag_l1")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 ref_pic_list_modification_flag_l0, uint32 ref_pic_list_modification_flag_l1, uint32 reserved) : this() + { + this.ref_pic_list_modification_flag_l0 = ref_pic_list_modification_flag_l0; + this.ref_pic_list_modification_flag_l1 = ref_pic_list_modification_flag_l1; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH265ReferenceListsInfo : this() +{ + public StdVideoEncodeH265ReferenceListsInfoFlags flags = default; + public uint8 num_ref_idx_l0_active_minus1 = 0; + public uint8 num_ref_idx_l1_active_minus1 = 0; + public uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] RefPicList0 = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures or STD_VIDEO_H265_NO_REFERENCE_PICTURE + public uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] RefPicList1 = .(); // slotIndex as used in VkVideoReferenceSlotInfoKHR structures or STD_VIDEO_H265_NO_REFERENCE_PICTURE + public uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] list_entry_l0 = .(); + public uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] list_entry_l1 = .(); + + public this(StdVideoEncodeH265ReferenceListsInfoFlags flags, uint8 num_ref_idx_l0_active_minus1, uint8 num_ref_idx_l1_active_minus1, uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] RefPicList0, uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] RefPicList1, uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] list_entry_l0, uint8[STD_VIDEO_H265_MAX_NUM_LIST_REF] list_entry_l1) : this() + { + this.flags = flags; + this.num_ref_idx_l0_active_minus1 = num_ref_idx_l0_active_minus1; + this.num_ref_idx_l1_active_minus1 = num_ref_idx_l1_active_minus1; + this.RefPicList0 = RefPicList0; + this.RefPicList1 = RefPicList1; + this.list_entry_l0 = list_entry_l0; + this.list_entry_l1 = list_entry_l1; + } +} + +[CRepr] struct StdVideoEncodeH265PictureInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "is_reference")] + [Bitfield(.Public, .Bits(1), "IrapPicFlag")] + [Bitfield(.Public, .Bits(1), "used_for_long_term_reference")] + [Bitfield(.Public, .Bits(1), "discardable_flag")] + [Bitfield(.Public, .Bits(1), "cross_layer_bla_flag")] + [Bitfield(.Public, .Bits(1), "pic_output_flag")] + [Bitfield(.Public, .Bits(1), "no_output_of_prior_pics_flag")] + [Bitfield(.Public, .Bits(1), "short_term_ref_pic_set_sps_flag")] + [Bitfield(.Public, .Bits(1), "slice_temporal_mvp_enabled_flag")] + [Bitfield(.Public, .Bits(23), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 is_reference, uint32 IrapPicFlag, uint32 used_for_long_term_reference, uint32 discardable_flag, uint32 cross_layer_bla_flag, uint32 pic_output_flag, uint32 no_output_of_prior_pics_flag, uint32 short_term_ref_pic_set_sps_flag, uint32 slice_temporal_mvp_enabled_flag, uint32 reserved) : this() + { + this.is_reference = is_reference; + this.IrapPicFlag = IrapPicFlag; + this.used_for_long_term_reference = used_for_long_term_reference; + this.discardable_flag = discardable_flag; + this.cross_layer_bla_flag = cross_layer_bla_flag; + this.pic_output_flag = pic_output_flag; + this.no_output_of_prior_pics_flag = no_output_of_prior_pics_flag; + this.short_term_ref_pic_set_sps_flag = short_term_ref_pic_set_sps_flag; + this.slice_temporal_mvp_enabled_flag = slice_temporal_mvp_enabled_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH265LongTermRefPics : this() +{ + public uint8 num_long_term_sps = 0; + public uint8 num_long_term_pics = 0; + public uint8[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS] lt_idx_sps = .(); + public uint8[STD_VIDEO_H265_MAX_LONG_TERM_PICS] poc_lsb_lt = .(); + public uint16 used_by_curr_pic_lt_flag = 0; // each bit represents a used_by_curr_pic_lt_flag[i] syntax + public uint8[STD_VIDEO_H265_MAX_DELTA_POC] delta_poc_msb_present_flag = .(); + public uint8[STD_VIDEO_H265_MAX_DELTA_POC] delta_poc_msb_cycle_lt = .(); + + public this(uint8 num_long_term_sps, uint8 num_long_term_pics, uint8[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS] lt_idx_sps, uint8[STD_VIDEO_H265_MAX_LONG_TERM_PICS] poc_lsb_lt, uint16 used_by_curr_pic_lt_flag, uint8[STD_VIDEO_H265_MAX_DELTA_POC] delta_poc_msb_present_flag, uint8[STD_VIDEO_H265_MAX_DELTA_POC] delta_poc_msb_cycle_lt) : this() + { + this.num_long_term_sps = num_long_term_sps; + this.num_long_term_pics = num_long_term_pics; + this.lt_idx_sps = lt_idx_sps; + this.poc_lsb_lt = poc_lsb_lt; + this.used_by_curr_pic_lt_flag = used_by_curr_pic_lt_flag; + this.delta_poc_msb_present_flag = delta_poc_msb_present_flag; + this.delta_poc_msb_cycle_lt = delta_poc_msb_cycle_lt; + } +} + +[CRepr] struct StdVideoEncodeH265PictureInfo : this() +{ + public StdVideoEncodeH265PictureInfoFlags flags = default; + public StdVideoH265PictureType pic_type = default; + public uint8 sps_video_parameter_set_id = 0; // Selecting VPS id from the Video Parameters Set + public uint8 pps_seq_parameter_set_id = 0; // Selecting SPS id from the Sequence Parameters Set + public uint8 pps_pic_parameter_set_id = 0; // Selecting PPS id from the Picture Parameters Set + public uint8 short_term_ref_pic_set_idx = 0; + public int32 PicOrderCntVal = 0; // Picture order count derived as specified in 8.3.1 + public uint8 TemporalId = 0; // Temporal ID, as defined in 7.4.2.2 + public uint8[7] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoEncodeH265ReferenceListsInfo* pRefLists = null; + public StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet = null; // Must be a valid pointer if short_term_ref_pic_set_sps_flag is not set + public StdVideoEncodeH265LongTermRefPics* pLongTermRefPics = null; // Must be a valid pointer if long_term_ref_pics_present_flag is set + + public this(StdVideoEncodeH265PictureInfoFlags flags, StdVideoH265PictureType pic_type, uint8 sps_video_parameter_set_id, uint8 pps_seq_parameter_set_id, uint8 pps_pic_parameter_set_id, uint8 short_term_ref_pic_set_idx, int32 PicOrderCntVal, uint8 TemporalId, uint8[7] reserved1, StdVideoEncodeH265ReferenceListsInfo* pRefLists = null, StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet = null, StdVideoEncodeH265LongTermRefPics* pLongTermRefPics = null) : this() + { + this.flags = flags; + this.pic_type = pic_type; + this.sps_video_parameter_set_id = sps_video_parameter_set_id; + this.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + this.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + this.short_term_ref_pic_set_idx = short_term_ref_pic_set_idx; + this.PicOrderCntVal = PicOrderCntVal; + this.TemporalId = TemporalId; + this.reserved1 = reserved1; + this.pRefLists = pRefLists; + this.pShortTermRefPicSet = pShortTermRefPicSet; + this.pLongTermRefPics = pLongTermRefPics; + } +} + +[CRepr] struct StdVideoEncodeH265ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "used_for_long_term_reference")] + [Bitfield(.Public, .Bits(1), "unused_for_reference")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 used_for_long_term_reference, uint32 unused_for_reference, uint32 reserved) : this() + { + this.used_for_long_term_reference = used_for_long_term_reference; + this.unused_for_reference = unused_for_reference; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeH265ReferenceInfo : this() +{ + public StdVideoEncodeH265ReferenceInfoFlags flags = default; + public StdVideoH265PictureType pic_type = default; + public int32 PicOrderCntVal = 0; // Picture order count derived as specified in 8.3.1 + public uint8 TemporalId = 0; // Temporal ID, as defined in 7.4.2.2 + + public this(StdVideoEncodeH265ReferenceInfoFlags flags, StdVideoH265PictureType pic_type, int32 PicOrderCntVal, uint8 TemporalId) : this() + { + this.flags = flags; + this.pic_type = pic_type; + this.PicOrderCntVal = PicOrderCntVal; + this.TemporalId = TemporalId; + } +} + +// protect with VULKAN_VIDEO_CODEC_VP9STD_H_ +static { public const uint32 STD_VIDEO_VP9_NUM_REF_FRAMES = 8; } +static { public const uint32 STD_VIDEO_VP9_REFS_PER_FRAME = 3; } +static { public const uint32 STD_VIDEO_VP9_MAX_REF_FRAMES = 4; } +static { public const uint32 STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS = 2; } +static { public const uint32 STD_VIDEO_VP9_MAX_SEGMENTS = 8; } +static { public const uint32 STD_VIDEO_VP9_SEG_LVL_MAX = 4; } +static { public const uint32 STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS = 7; } +static { public const uint32 STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB = 3; } + +[AllowDuplicates] enum StdVideoVP9Profile : int32 +{ + [NoShow] STD_VIDEO_VP9_PROFILE_0 = 0, + [NoShow] STD_VIDEO_VP9_PROFILE_1 = 1, + [NoShow] STD_VIDEO_VP9_PROFILE_2 = 2, + [NoShow] STD_VIDEO_VP9_PROFILE_3 = 3, + [NoShow] STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_Profile0 = 0, + StdVideoVp9_Profile1 = 1, + StdVideoVp9_Profile2 = 2, + StdVideoVp9_Profile3 = 3, + StdVideoVp9_ProfileInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoVP9Level : int32 +{ + [NoShow] STD_VIDEO_VP9_LEVEL_1_0 = 0, + [NoShow] STD_VIDEO_VP9_LEVEL_1_1 = 1, + [NoShow] STD_VIDEO_VP9_LEVEL_2_0 = 2, + [NoShow] STD_VIDEO_VP9_LEVEL_2_1 = 3, + [NoShow] STD_VIDEO_VP9_LEVEL_3_0 = 4, + [NoShow] STD_VIDEO_VP9_LEVEL_3_1 = 5, + [NoShow] STD_VIDEO_VP9_LEVEL_4_0 = 6, + [NoShow] STD_VIDEO_VP9_LEVEL_4_1 = 7, + [NoShow] STD_VIDEO_VP9_LEVEL_5_0 = 8, + [NoShow] STD_VIDEO_VP9_LEVEL_5_1 = 9, + [NoShow] STD_VIDEO_VP9_LEVEL_5_2 = 10, + [NoShow] STD_VIDEO_VP9_LEVEL_6_0 = 11, + [NoShow] STD_VIDEO_VP9_LEVEL_6_1 = 12, + [NoShow] STD_VIDEO_VP9_LEVEL_6_2 = 13, + [NoShow] STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_Level1_0 = 0, + StdVideoVp9_Level1_1 = 1, + StdVideoVp9_Level2_0 = 2, + StdVideoVp9_Level2_1 = 3, + StdVideoVp9_Level3_0 = 4, + StdVideoVp9_Level3_1 = 5, + StdVideoVp9_Level4_0 = 6, + StdVideoVp9_Level4_1 = 7, + StdVideoVp9_Level5_0 = 8, + StdVideoVp9_Level5_1 = 9, + StdVideoVp9_Level5_2 = 10, + StdVideoVp9_Level6_0 = 11, + StdVideoVp9_Level6_1 = 12, + StdVideoVp9_Level6_2 = 13, + StdVideoVp9_LevelInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoVP9FrameType : int32 +{ + [NoShow] STD_VIDEO_VP9_FRAME_TYPE_KEY = 0, + [NoShow] STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1, + [NoShow] STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_FrameTypeKey = 0, + StdVideoVp9_FrameTypeNonKey = 1, + StdVideoVp9_FrameTypeInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoVP9ReferenceName : int32 +{ + [NoShow] STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0, + [NoShow] STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1, + [NoShow] STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2, + [NoShow] STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3, + [NoShow] STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_ReferenceNameIntraFrame = 0, + StdVideoVp9_ReferenceNameLastFrame = 1, + StdVideoVp9_ReferenceNameGoldenFrame = 2, + StdVideoVp9_ReferenceNameAltrefFrame = 3, + StdVideoVp9_ReferenceNameInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoVP9InterpolationFilter : int32 +{ + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0, + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3, + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4, + [NoShow] STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_InterpolationFilterEighttap = 0, + StdVideoVp9_InterpolationFilterEighttapSmooth = 1, + StdVideoVp9_InterpolationFilterEighttapSharp = 2, + StdVideoVp9_InterpolationFilterBilinear = 3, + StdVideoVp9_InterpolationFilterSwitchable = 4, + StdVideoVp9_InterpolationFilterInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoVP9ColorSpace : int32 +{ + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_RGB = 7, + [NoShow] STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoVp9_ColorSpaceUnknown = 0, + StdVideoVp9_ColorSpaceBt601 = 1, + StdVideoVp9_ColorSpaceBt709 = 2, + StdVideoVp9_ColorSpaceSmpte170 = 3, + StdVideoVp9_ColorSpaceSmpte240 = 4, + StdVideoVp9_ColorSpaceBt2020 = 5, + StdVideoVp9_ColorSpaceReserved = 6, + StdVideoVp9_ColorSpaceRgb = 7, + StdVideoVp9_ColorSpaceInvalid = 0x7FFFFFFF, +} + +[CRepr] struct StdVideoVP9ColorConfigFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "color_range")] + [Bitfield(.Public, .Bits(31), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 color_range, uint32 reserved) : this() + { + this.color_range = color_range; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoVP9ColorConfig : this() +{ + + public StdVideoVP9ColorConfigFlags flags = default; + public uint8 BitDepth = 0; + public uint8 subsampling_x = 0; + public uint8 subsampling_y = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoVP9ColorSpace color_space = default; + + public this(StdVideoVP9ColorConfigFlags flags, uint8 BitDepth, uint8 subsampling_x, uint8 subsampling_y, uint8 reserved1, StdVideoVP9ColorSpace color_space) : this() + { + this.flags = flags; + this.BitDepth = BitDepth; + this.subsampling_x = subsampling_x; + this.subsampling_y = subsampling_y; + this.reserved1 = reserved1; + this.color_space = color_space; + } +} + +[CRepr] struct StdVideoVP9LoopFilterFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "loop_filter_delta_enabled")] + [Bitfield(.Public, .Bits(1), "loop_filter_delta_update")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 loop_filter_delta_enabled, uint32 loop_filter_delta_update, uint32 reserved) : this() + { + this.loop_filter_delta_enabled = loop_filter_delta_enabled; + this.loop_filter_delta_update = loop_filter_delta_update; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoVP9LoopFilter : this() +{ + + public StdVideoVP9LoopFilterFlags flags = default; + public uint8 loop_filter_level = 0; + public uint8 loop_filter_sharpness = 0; + public uint8 update_ref_delta = 0; + public int8[STD_VIDEO_VP9_MAX_REF_FRAMES] loop_filter_ref_deltas = .(); + public uint8 update_mode_delta = 0; + public int8[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS] loop_filter_mode_deltas = .(); + + public this(StdVideoVP9LoopFilterFlags flags, uint8 loop_filter_level, uint8 loop_filter_sharpness, uint8 update_ref_delta, int8[STD_VIDEO_VP9_MAX_REF_FRAMES] loop_filter_ref_deltas, uint8 update_mode_delta, int8[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS] loop_filter_mode_deltas) : this() + { + this.flags = flags; + this.loop_filter_level = loop_filter_level; + this.loop_filter_sharpness = loop_filter_sharpness; + this.update_ref_delta = update_ref_delta; + this.loop_filter_ref_deltas = loop_filter_ref_deltas; + this.update_mode_delta = update_mode_delta; + this.loop_filter_mode_deltas = loop_filter_mode_deltas; + } +} + +[CRepr] struct StdVideoVP9SegmentationFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "segmentation_update_map")] + [Bitfield(.Public, .Bits(1), "segmentation_temporal_update")] + [Bitfield(.Public, .Bits(1), "segmentation_update_data")] + [Bitfield(.Public, .Bits(1), "segmentation_abs_or_delta_update")] + [Bitfield(.Public, .Bits(28), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 segmentation_update_map, uint32 segmentation_temporal_update, uint32 segmentation_update_data, uint32 segmentation_abs_or_delta_update, uint32 reserved) : this() + { + this.segmentation_update_map = segmentation_update_map; + this.segmentation_temporal_update = segmentation_temporal_update; + this.segmentation_update_data = segmentation_update_data; + this.segmentation_abs_or_delta_update = segmentation_abs_or_delta_update; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoVP9Segmentation : this() +{ + + public StdVideoVP9SegmentationFlags flags = default; + public uint8[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS] segmentation_tree_probs = .(); + public uint8[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB] segmentation_pred_prob = .(); + public uint8[STD_VIDEO_VP9_MAX_SEGMENTS] FeatureEnabled = .(); + + public int16[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX] FeatureData = .(); + + public this(StdVideoVP9SegmentationFlags flags, uint8[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS] segmentation_tree_probs, uint8[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB] segmentation_pred_prob, uint8[STD_VIDEO_VP9_MAX_SEGMENTS] FeatureEnabled, int16[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX] FeatureData) : this() + { + this.flags = flags; + this.segmentation_tree_probs = segmentation_tree_probs; + this.segmentation_pred_prob = segmentation_pred_prob; + this.FeatureEnabled = FeatureEnabled; + this.FeatureData = FeatureData; + } +} + +// protect with VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_vp9_decode"; } + +[CRepr] struct StdVideoDecodeVP9PictureInfoFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "error_resilient_mode")] + [Bitfield(.Public, .Bits(1), "intra_only")] + [Bitfield(.Public, .Bits(1), "allow_high_precision_mv")] + [Bitfield(.Public, .Bits(1), "refresh_frame_context")] + [Bitfield(.Public, .Bits(1), "frame_parallel_decoding_mode")] + [Bitfield(.Public, .Bits(1), "segmentation_enabled")] + [Bitfield(.Public, .Bits(1), "show_frame")] + [Bitfield(.Public, .Bits(1), "UsePrevFrameMvs")] + [Bitfield(.Public, .Bits(24), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 error_resilient_mode, uint32 intra_only, uint32 allow_high_precision_mv, uint32 refresh_frame_context, uint32 frame_parallel_decoding_mode, uint32 segmentation_enabled, uint32 show_frame, uint32 UsePrevFrameMvs, uint32 reserved) : this() + { + this.error_resilient_mode = error_resilient_mode; + this.intra_only = intra_only; + this.allow_high_precision_mv = allow_high_precision_mv; + this.refresh_frame_context = refresh_frame_context; + this.frame_parallel_decoding_mode = frame_parallel_decoding_mode; + this.segmentation_enabled = segmentation_enabled; + this.show_frame = show_frame; + this.UsePrevFrameMvs = UsePrevFrameMvs; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoDecodeVP9PictureInfo : this() +{ + + public StdVideoDecodeVP9PictureInfoFlags flags = default; + public StdVideoVP9Profile profile = default; + + public StdVideoVP9FrameType frame_type = default; + public uint8 frame_context_idx = 0; + public uint8 reset_frame_context = 0; + public uint8 refresh_frame_flags = 0; + public uint8 ref_frame_sign_bias_mask = 0; + public StdVideoVP9InterpolationFilter interpolation_filter = default; + public uint8 base_q_idx = 0; + public int8 delta_q_y_dc = 0; + public int8 delta_q_uv_dc = 0; + public int8 delta_q_uv_ac = 0; + public uint8 tile_cols_log2 = 0; + public uint8 tile_rows_log2 = 0; + public uint16[3] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoVP9ColorConfig* pColorConfig = null; + public StdVideoVP9LoopFilter* pLoopFilter = null; + public StdVideoVP9Segmentation* pSegmentation = null; + + public this(StdVideoDecodeVP9PictureInfoFlags flags, StdVideoVP9Profile profile, StdVideoVP9FrameType frame_type, uint8 frame_context_idx, uint8 reset_frame_context, uint8 refresh_frame_flags, uint8 ref_frame_sign_bias_mask, StdVideoVP9InterpolationFilter interpolation_filter, uint8 base_q_idx, int8 delta_q_y_dc, int8 delta_q_uv_dc, int8 delta_q_uv_ac, uint8 tile_cols_log2, uint8 tile_rows_log2, uint16[3] reserved1, StdVideoVP9ColorConfig* pColorConfig, StdVideoVP9LoopFilter* pLoopFilter, StdVideoVP9Segmentation* pSegmentation = null) : this() + { + this.flags = flags; + this.profile = profile; + this.frame_type = frame_type; + this.frame_context_idx = frame_context_idx; + this.reset_frame_context = reset_frame_context; + this.refresh_frame_flags = refresh_frame_flags; + this.ref_frame_sign_bias_mask = ref_frame_sign_bias_mask; + this.interpolation_filter = interpolation_filter; + this.base_q_idx = base_q_idx; + this.delta_q_y_dc = delta_q_y_dc; + this.delta_q_uv_dc = delta_q_uv_dc; + this.delta_q_uv_ac = delta_q_uv_ac; + this.tile_cols_log2 = tile_cols_log2; + this.tile_rows_log2 = tile_rows_log2; + this.reserved1 = reserved1; + this.pColorConfig = pColorConfig; + this.pLoopFilter = pLoopFilter; + this.pSegmentation = pSegmentation; + } +} + +// protect with VULKAN_VIDEO_CODEC_AV1STD_H_ +static { public const uint32 STD_VIDEO_AV1_NUM_REF_FRAMES = 8; } +static { public const uint32 STD_VIDEO_AV1_REFS_PER_FRAME = 7; } +static { public const uint32 STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME = 8; } +static { public const uint32 STD_VIDEO_AV1_MAX_TILE_COLS = 64; } +static { public const uint32 STD_VIDEO_AV1_MAX_TILE_ROWS = 64; } +static { public const uint32 STD_VIDEO_AV1_MAX_SEGMENTS = 8; } +static { public const uint32 STD_VIDEO_AV1_SEG_LVL_MAX = 8; } +static { public const uint8 STD_VIDEO_AV1_PRIMARY_REF_NONE = 7; } +static { public const uint8 STD_VIDEO_AV1_SELECT_INTEGER_MV = 2; } +static { public const uint32 STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS = 2; } +static { public const uint32 STD_VIDEO_AV1_SKIP_MODE_FRAMES = 2; } +static { public const uint32 STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS = 4; } +static { public const uint32 STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS = 2; } +static { public const uint32 STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS = 8; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_PLANES = 3; } +static { public const uint32 STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS = 6; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_Y_POINTS = 14; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_CB_POINTS = 10; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_CR_POINTS = 10; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_POS_LUMA = 24; } +static { public const uint32 STD_VIDEO_AV1_MAX_NUM_POS_CHROMA = 25; } + +[AllowDuplicates] enum StdVideoAV1Profile : int32 +{ + [NoShow] STD_VIDEO_AV1_PROFILE_MAIN = 0, + [NoShow] STD_VIDEO_AV1_PROFILE_HIGH = 1, + [NoShow] STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, + [NoShow] STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_ProfileMain = 0, + StdVideoAv1_ProfileHigh = 1, + StdVideoAv1_ProfileProfessional = 2, + StdVideoAv1_ProfileInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1Level : int32 +{ + [NoShow] STD_VIDEO_AV1_LEVEL_2_0 = 0, + [NoShow] STD_VIDEO_AV1_LEVEL_2_1 = 1, + [NoShow] STD_VIDEO_AV1_LEVEL_2_2 = 2, + [NoShow] STD_VIDEO_AV1_LEVEL_2_3 = 3, + [NoShow] STD_VIDEO_AV1_LEVEL_3_0 = 4, + [NoShow] STD_VIDEO_AV1_LEVEL_3_1 = 5, + [NoShow] STD_VIDEO_AV1_LEVEL_3_2 = 6, + [NoShow] STD_VIDEO_AV1_LEVEL_3_3 = 7, + [NoShow] STD_VIDEO_AV1_LEVEL_4_0 = 8, + [NoShow] STD_VIDEO_AV1_LEVEL_4_1 = 9, + [NoShow] STD_VIDEO_AV1_LEVEL_4_2 = 10, + [NoShow] STD_VIDEO_AV1_LEVEL_4_3 = 11, + [NoShow] STD_VIDEO_AV1_LEVEL_5_0 = 12, + [NoShow] STD_VIDEO_AV1_LEVEL_5_1 = 13, + [NoShow] STD_VIDEO_AV1_LEVEL_5_2 = 14, + [NoShow] STD_VIDEO_AV1_LEVEL_5_3 = 15, + [NoShow] STD_VIDEO_AV1_LEVEL_6_0 = 16, + [NoShow] STD_VIDEO_AV1_LEVEL_6_1 = 17, + [NoShow] STD_VIDEO_AV1_LEVEL_6_2 = 18, + [NoShow] STD_VIDEO_AV1_LEVEL_6_3 = 19, + [NoShow] STD_VIDEO_AV1_LEVEL_7_0 = 20, + [NoShow] STD_VIDEO_AV1_LEVEL_7_1 = 21, + [NoShow] STD_VIDEO_AV1_LEVEL_7_2 = 22, + [NoShow] STD_VIDEO_AV1_LEVEL_7_3 = 23, + [NoShow] STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_Level2_0 = 0, + StdVideoAv1_Level2_1 = 1, + StdVideoAv1_Level2_2 = 2, + StdVideoAv1_Level2_3 = 3, + StdVideoAv1_Level3_0 = 4, + StdVideoAv1_Level3_1 = 5, + StdVideoAv1_Level3_2 = 6, + StdVideoAv1_Level3_3 = 7, + StdVideoAv1_Level4_0 = 8, + StdVideoAv1_Level4_1 = 9, + StdVideoAv1_Level4_2 = 10, + StdVideoAv1_Level4_3 = 11, + StdVideoAv1_Level5_0 = 12, + StdVideoAv1_Level5_1 = 13, + StdVideoAv1_Level5_2 = 14, + StdVideoAv1_Level5_3 = 15, + StdVideoAv1_Level6_0 = 16, + StdVideoAv1_Level6_1 = 17, + StdVideoAv1_Level6_2 = 18, + StdVideoAv1_Level6_3 = 19, + StdVideoAv1_Level7_0 = 20, + StdVideoAv1_Level7_1 = 21, + StdVideoAv1_Level7_2 = 22, + StdVideoAv1_Level7_3 = 23, + StdVideoAv1_LevelInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1FrameType : int32 +{ + [NoShow] STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, + [NoShow] STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, + [NoShow] STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, + [NoShow] STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, + [NoShow] STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_FrameTypeKey = 0, + StdVideoAv1_FrameTypeInter = 1, + StdVideoAv1_FrameTypeIntraOnly = 2, + StdVideoAv1_FrameTypeSwitch = 3, + StdVideoAv1_FrameTypeInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1ReferenceName : int32 +{ + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, + [NoShow] STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_ReferenceNameIntraFrame = 0, + StdVideoAv1_ReferenceNameLastFrame = 1, + StdVideoAv1_ReferenceNameLast2_Frame = 2, + StdVideoAv1_ReferenceNameLast3_Frame = 3, + StdVideoAv1_ReferenceNameGoldenFrame = 4, + StdVideoAv1_ReferenceNameBwdrefFrame = 5, + StdVideoAv1_ReferenceNameAltref2_Frame = 6, + StdVideoAv1_ReferenceNameAltrefFrame = 7, + StdVideoAv1_ReferenceNameInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1InterpolationFilter : int32 +{ + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, + [NoShow] STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_InterpolationFilterEighttap = 0, + StdVideoAv1_InterpolationFilterEighttapSmooth = 1, + StdVideoAv1_InterpolationFilterEighttapSharp = 2, + StdVideoAv1_InterpolationFilterBilinear = 3, + StdVideoAv1_InterpolationFilterSwitchable = 4, + StdVideoAv1_InterpolationFilterInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1TxMode : int32 +{ + [NoShow] STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, + [NoShow] STD_VIDEO_AV1_TX_MODE_LARGEST = 1, + [NoShow] STD_VIDEO_AV1_TX_MODE_SELECT = 2, + [NoShow] STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_TxModeOnly4x4 = 0, + StdVideoAv1_TxModeLargest = 1, + StdVideoAv1_TxModeSelect = 2, + StdVideoAv1_TxModeInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1FrameRestorationType : int32 +{ + [NoShow] STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, + [NoShow] STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, + [NoShow] STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, + [NoShow] STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, + [NoShow] STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_FrameRestorationTypeNone = 0, + StdVideoAv1_FrameRestorationTypeWiener = 1, + StdVideoAv1_FrameRestorationTypeSgrproj = 2, + StdVideoAv1_FrameRestorationTypeSwitchable = 3, + StdVideoAv1_FrameRestorationTypeInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1ColorPrimaries : int32 +{ + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, + [NoShow] STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_ColorPrimariesBt709 = 1, + StdVideoAv1_ColorPrimariesUnspecified = 2, + StdVideoAv1_ColorPrimariesBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, + StdVideoAv1_ColorPrimariesBt470_M = 4, + StdVideoAv1_ColorPrimariesBt470_BG = 5, + StdVideoAv1_ColorPrimariesBt601 = 6, + StdVideoAv1_ColorPrimariesSmpte240 = 7, + StdVideoAv1_ColorPrimariesGenericFilm = 8, + StdVideoAv1_ColorPrimariesBt2020 = 9, + StdVideoAv1_ColorPrimariesXyz = 10, + StdVideoAv1_ColorPrimariesSmpte431 = 11, + StdVideoAv1_ColorPrimariesSmpte432 = 12, + StdVideoAv1_ColorPrimariesEbu3213 = 22, + StdVideoAv1_ColorPrimariesInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1TransferCharacteristics : int32 +{ + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, + [NoShow] STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_TransferCharacteristicsReserved0 = 0, + StdVideoAv1_TransferCharacteristicsBt709 = 1, + StdVideoAv1_TransferCharacteristicsUnspecified = 2, + StdVideoAv1_TransferCharacteristicsReserved3 = 3, + StdVideoAv1_TransferCharacteristicsBt470_M = 4, + StdVideoAv1_TransferCharacteristicsBt470_BG = 5, + StdVideoAv1_TransferCharacteristicsBt601 = 6, + StdVideoAv1_TransferCharacteristicsSmpte240 = 7, + StdVideoAv1_TransferCharacteristicsLinear = 8, + StdVideoAv1_TransferCharacteristicsLog100 = 9, + StdVideoAv1_TransferCharacteristicsLog100_Sqrt10 = 10, + StdVideoAv1_TransferCharacteristicsIec61966 = 11, + StdVideoAv1_TransferCharacteristicsBt1361 = 12, + StdVideoAv1_TransferCharacteristicsSrgb = 13, + StdVideoAv1_TransferCharacteristicsBt2020_10 = 14, + StdVideoAv1_TransferCharacteristicsBt2020_12 = 15, + StdVideoAv1_TransferCharacteristicsSmpte2084 = 16, + StdVideoAv1_TransferCharacteristicsSmpte428 = 17, + StdVideoAv1_TransferCharacteristicsHlg = 18, + StdVideoAv1_TransferCharacteristicsInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1MatrixCoefficients : int32 +{ + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, + [NoShow] STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_MatrixCoefficientsIdentity = 0, + StdVideoAv1_MatrixCoefficientsBt709 = 1, + StdVideoAv1_MatrixCoefficientsUnspecified = 2, + StdVideoAv1_MatrixCoefficientsReserved3 = 3, + StdVideoAv1_MatrixCoefficientsFcc = 4, + StdVideoAv1_MatrixCoefficientsBt470_BG = 5, + StdVideoAv1_MatrixCoefficientsBt601 = 6, + StdVideoAv1_MatrixCoefficientsSmpte240 = 7, + StdVideoAv1_MatrixCoefficientsSmpteYcgco = 8, + StdVideoAv1_MatrixCoefficientsBt2020_Ncl = 9, + StdVideoAv1_MatrixCoefficientsBt2020_Cl = 10, + StdVideoAv1_MatrixCoefficientsSmpte2085 = 11, + StdVideoAv1_MatrixCoefficientsChromatNcl = 12, + StdVideoAv1_MatrixCoefficientsChromatCl = 13, + StdVideoAv1_MatrixCoefficientsIctcp = 14, + StdVideoAv1_MatrixCoefficientsInvalid = 0x7FFFFFFF, +} + +[AllowDuplicates] enum StdVideoAV1ChromaSamplePosition : int32 +{ + [NoShow] STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + [NoShow] STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + [NoShow] STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, + [NoShow] STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, + [NoShow] STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, + // pretty names + StdVideoAv1_ChromaSamplePositionUnknown = 0, + StdVideoAv1_ChromaSamplePositionVertical = 1, + StdVideoAv1_ChromaSamplePositionColocated = 2, + StdVideoAv1_ChromaSamplePositionReserved = 3, + StdVideoAv1_ChromaSamplePositionInvalid = 0x7FFFFFFF, +} + +[CRepr] struct StdVideoAV1ColorConfigFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "mono_chrome")] + [Bitfield(.Public, .Bits(1), "color_range")] + [Bitfield(.Public, .Bits(1), "separate_uv_delta_q")] + [Bitfield(.Public, .Bits(1), "color_description_present_flag")] + [Bitfield(.Public, .Bits(28), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 mono_chrome, uint32 color_range, uint32 separate_uv_delta_q, uint32 color_description_present_flag, uint32 reserved) : this() + { + this.mono_chrome = mono_chrome; + this.color_range = color_range; + this.separate_uv_delta_q = separate_uv_delta_q; + this.color_description_present_flag = color_description_present_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1ColorConfig : this() +{ + + public StdVideoAV1ColorConfigFlags flags = default; + public uint8 BitDepth = 0; + public uint8 subsampling_x = 0; + public uint8 subsampling_y = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoAV1ColorPrimaries color_primaries = default; + public StdVideoAV1TransferCharacteristics transfer_characteristics = default; + public StdVideoAV1MatrixCoefficients matrix_coefficients = default; + public StdVideoAV1ChromaSamplePosition chroma_sample_position = default; + + public this(StdVideoAV1ColorConfigFlags flags, uint8 BitDepth, uint8 subsampling_x, uint8 subsampling_y, uint8 reserved1, StdVideoAV1ColorPrimaries color_primaries, StdVideoAV1TransferCharacteristics transfer_characteristics, StdVideoAV1MatrixCoefficients matrix_coefficients, StdVideoAV1ChromaSamplePosition chroma_sample_position) : this() + { + this.flags = flags; + this.BitDepth = BitDepth; + this.subsampling_x = subsampling_x; + this.subsampling_y = subsampling_y; + this.reserved1 = reserved1; + this.color_primaries = color_primaries; + this.transfer_characteristics = transfer_characteristics; + this.matrix_coefficients = matrix_coefficients; + this.chroma_sample_position = chroma_sample_position; + } +} + +[CRepr] struct StdVideoAV1TimingInfoFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "equal_picture_interval")] + [Bitfield(.Public, .Bits(31), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 equal_picture_interval, uint32 reserved) : this() + { + this.equal_picture_interval = equal_picture_interval; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1TimingInfo : this() +{ + + public StdVideoAV1TimingInfoFlags flags = default; + public uint32 num_units_in_display_tick = 0; + public uint32 time_scale = 0; + public uint32 num_ticks_per_picture_minus_1 = 0; + + public this(StdVideoAV1TimingInfoFlags flags, uint32 num_units_in_display_tick, uint32 time_scale, uint32 num_ticks_per_picture_minus_1) : this() + { + this.flags = flags; + this.num_units_in_display_tick = num_units_in_display_tick; + this.time_scale = time_scale; + this.num_ticks_per_picture_minus_1 = num_ticks_per_picture_minus_1; + } +} + +[CRepr] struct StdVideoAV1LoopFilterFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "loop_filter_delta_enabled")] + [Bitfield(.Public, .Bits(1), "loop_filter_delta_update")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 loop_filter_delta_enabled, uint32 loop_filter_delta_update, uint32 reserved) : this() + { + this.loop_filter_delta_enabled = loop_filter_delta_enabled; + this.loop_filter_delta_update = loop_filter_delta_update; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1LoopFilter : this() +{ + + public StdVideoAV1LoopFilterFlags flags = default; + public uint8[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS] loop_filter_level = .(); + public uint8 loop_filter_sharpness = 0; + public uint8 update_ref_delta = 0; + public int8[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME] loop_filter_ref_deltas = .(); + public uint8 update_mode_delta = 0; + public int8[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS] loop_filter_mode_deltas = .(); + + public this(StdVideoAV1LoopFilterFlags flags, uint8[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS] loop_filter_level, uint8 loop_filter_sharpness, uint8 update_ref_delta, int8[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME] loop_filter_ref_deltas, uint8 update_mode_delta, int8[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS] loop_filter_mode_deltas) : this() + { + this.flags = flags; + this.loop_filter_level = loop_filter_level; + this.loop_filter_sharpness = loop_filter_sharpness; + this.update_ref_delta = update_ref_delta; + this.loop_filter_ref_deltas = loop_filter_ref_deltas; + this.update_mode_delta = update_mode_delta; + this.loop_filter_mode_deltas = loop_filter_mode_deltas; + } +} + +[CRepr] struct StdVideoAV1QuantizationFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "using_qmatrix")] + [Bitfield(.Public, .Bits(1), "diff_uv_delta")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 using_qmatrix, uint32 diff_uv_delta, uint32 reserved) : this() + { + this.using_qmatrix = using_qmatrix; + this.diff_uv_delta = diff_uv_delta; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1Quantization : this() +{ + + public StdVideoAV1QuantizationFlags flags = default; + public uint8 base_q_idx = 0; + public int8 DeltaQYDc = 0; + public int8 DeltaQUDc = 0; + public int8 DeltaQUAc = 0; + public int8 DeltaQVDc = 0; + public int8 DeltaQVAc = 0; + public uint8 qm_y = 0; + public uint8 qm_u = 0; + public uint8 qm_v = 0; + + public this(StdVideoAV1QuantizationFlags flags, uint8 base_q_idx, int8 DeltaQYDc, int8 DeltaQUDc, int8 DeltaQUAc, int8 DeltaQVDc, int8 DeltaQVAc, uint8 qm_y, uint8 qm_u, uint8 qm_v) : this() + { + this.flags = flags; + this.base_q_idx = base_q_idx; + this.DeltaQYDc = DeltaQYDc; + this.DeltaQUDc = DeltaQUDc; + this.DeltaQUAc = DeltaQUAc; + this.DeltaQVDc = DeltaQVDc; + this.DeltaQVAc = DeltaQVAc; + this.qm_y = qm_y; + this.qm_u = qm_u; + this.qm_v = qm_v; + } +} + +[CRepr] struct StdVideoAV1Segmentation : this() +{ + + public uint8[STD_VIDEO_AV1_MAX_SEGMENTS] FeatureEnabled = .(); // Each element contains 8 (SEG_LVL_MAX) bits, one bit for each feature within the segment + public int16[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX] FeatureData = .(); + + public this(uint8[STD_VIDEO_AV1_MAX_SEGMENTS] FeatureEnabled, int16[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX] FeatureData) : this() + { + this.FeatureEnabled = FeatureEnabled; + this.FeatureData = FeatureData; + } +} + +[CRepr] struct StdVideoAV1TileInfoFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "uniform_tile_spacing_flag")] + [Bitfield(.Public, .Bits(31), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 uniform_tile_spacing_flag, uint32 reserved) : this() + { + this.uniform_tile_spacing_flag = uniform_tile_spacing_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1TileInfo : this() +{ + + public StdVideoAV1TileInfoFlags flags = default; + public uint8 TileCols = 0; + public uint8 TileRows = 0; + public uint16 context_update_tile_id = 0; + public uint8 tile_size_bytes_minus_1 = 0; + public uint8[7] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public uint16* pMiColStarts = null; // TileCols number of elements + public uint16* pMiRowStarts = null; // TileRows number of elements + public uint16* pWidthInSbsMinus1 = null; // TileCols number of elements + public uint16* pHeightInSbsMinus1 = null; // TileRows number of elements + + public this(StdVideoAV1TileInfoFlags flags, uint8 TileCols, uint8 TileRows, uint16 context_update_tile_id, uint8 tile_size_bytes_minus_1, uint8[7] reserved1, uint16* pMiColStarts, uint16* pMiRowStarts, uint16* pWidthInSbsMinus1, uint16* pHeightInSbsMinus1) : this() + { + this.flags = flags; + this.TileCols = TileCols; + this.TileRows = TileRows; + this.context_update_tile_id = context_update_tile_id; + this.tile_size_bytes_minus_1 = tile_size_bytes_minus_1; + this.reserved1 = reserved1; + this.pMiColStarts = pMiColStarts; + this.pMiRowStarts = pMiRowStarts; + this.pWidthInSbsMinus1 = pWidthInSbsMinus1; + this.pHeightInSbsMinus1 = pHeightInSbsMinus1; + } +} + +[CRepr] struct StdVideoAV1CDEF : this() +{ + + public uint8 cdef_damping_minus_3 = 0; + public uint8 cdef_bits = 0; + public uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_y_pri_strength = .(); + public uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_y_sec_strength = .(); + public uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_uv_pri_strength = .(); + public uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_uv_sec_strength = .(); + + public this(uint8 cdef_damping_minus_3, uint8 cdef_bits, uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_y_pri_strength, uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_y_sec_strength, uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_uv_pri_strength, uint8[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] cdef_uv_sec_strength) : this() + { + this.cdef_damping_minus_3 = cdef_damping_minus_3; + this.cdef_bits = cdef_bits; + this.cdef_y_pri_strength = cdef_y_pri_strength; + this.cdef_y_sec_strength = cdef_y_sec_strength; + this.cdef_uv_pri_strength = cdef_uv_pri_strength; + this.cdef_uv_sec_strength = cdef_uv_sec_strength; + } +} + +[CRepr] struct StdVideoAV1LoopRestoration : this() +{ + + public StdVideoAV1FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES] FrameRestorationType = .(); + public uint16[STD_VIDEO_AV1_MAX_NUM_PLANES] LoopRestorationSize = .(); + + public this(StdVideoAV1FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES] FrameRestorationType, uint16[STD_VIDEO_AV1_MAX_NUM_PLANES] LoopRestorationSize) : this() + { + this.FrameRestorationType = FrameRestorationType; + this.LoopRestorationSize = LoopRestorationSize; + } +} + +[CRepr] struct StdVideoAV1GlobalMotion : this() +{ + + public uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] GmType = .(); + public int32[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS] gm_params = .(); + + public this(uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] GmType, int32[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS] gm_params) : this() + { + this.GmType = GmType; + this.gm_params = gm_params; + } +} + +[CRepr] struct StdVideoAV1FilmGrainFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "chroma_scaling_from_luma")] + [Bitfield(.Public, .Bits(1), "overlap_flag")] + [Bitfield(.Public, .Bits(1), "clip_to_restricted_range")] + [Bitfield(.Public, .Bits(1), "update_grain")] + [Bitfield(.Public, .Bits(28), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 chroma_scaling_from_luma, uint32 overlap_flag, uint32 clip_to_restricted_range, uint32 update_grain, uint32 reserved) : this() + { + this.chroma_scaling_from_luma = chroma_scaling_from_luma; + this.overlap_flag = overlap_flag; + this.clip_to_restricted_range = clip_to_restricted_range; + this.update_grain = update_grain; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1FilmGrain : this() +{ + + public StdVideoAV1FilmGrainFlags flags = default; + public uint8 grain_scaling_minus_8 = 0; + public uint8 ar_coeff_lag = 0; + public uint8 ar_coeff_shift_minus_6 = 0; + public uint8 grain_scale_shift = 0; + public uint16 grain_seed = 0; + public uint8 film_grain_params_ref_idx = 0; + public uint8 num_y_points = 0; + public uint8[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] point_y_value = .(); + public uint8[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] point_y_scaling = .(); + public uint8 num_cb_points = 0; + public uint8[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] point_cb_value = .(); + public uint8[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] point_cb_scaling = .(); + public uint8 num_cr_points = 0; + public uint8[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] point_cr_value = .(); + public uint8[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] point_cr_scaling = .(); + public int8[STD_VIDEO_AV1_MAX_NUM_POS_LUMA] ar_coeffs_y_plus_128 = .(); + public int8[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] ar_coeffs_cb_plus_128 = .(); + public int8[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] ar_coeffs_cr_plus_128 = .(); + public uint8 cb_mult = 0; + public uint8 cb_luma_mult = 0; + public uint16 cb_offset = 0; + public uint8 cr_mult = 0; + public uint8 cr_luma_mult = 0; + public uint16 cr_offset = 0; + + public this(StdVideoAV1FilmGrainFlags flags, uint8 grain_scaling_minus_8, uint8 ar_coeff_lag, uint8 ar_coeff_shift_minus_6, uint8 grain_scale_shift, uint16 grain_seed, uint8 film_grain_params_ref_idx, uint8 num_y_points, uint8[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] point_y_value, uint8[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] point_y_scaling, uint8 num_cb_points, uint8[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] point_cb_value, uint8[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] point_cb_scaling, uint8 num_cr_points, uint8[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] point_cr_value, uint8[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] point_cr_scaling, int8[STD_VIDEO_AV1_MAX_NUM_POS_LUMA] ar_coeffs_y_plus_128, int8[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] ar_coeffs_cb_plus_128, int8[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] ar_coeffs_cr_plus_128, uint8 cb_mult, uint8 cb_luma_mult, uint16 cb_offset, uint8 cr_mult, uint8 cr_luma_mult, uint16 cr_offset) : this() + { + this.flags = flags; + this.grain_scaling_minus_8 = grain_scaling_minus_8; + this.ar_coeff_lag = ar_coeff_lag; + this.ar_coeff_shift_minus_6 = ar_coeff_shift_minus_6; + this.grain_scale_shift = grain_scale_shift; + this.grain_seed = grain_seed; + this.film_grain_params_ref_idx = film_grain_params_ref_idx; + this.num_y_points = num_y_points; + this.point_y_value = point_y_value; + this.point_y_scaling = point_y_scaling; + this.num_cb_points = num_cb_points; + this.point_cb_value = point_cb_value; + this.point_cb_scaling = point_cb_scaling; + this.num_cr_points = num_cr_points; + this.point_cr_value = point_cr_value; + this.point_cr_scaling = point_cr_scaling; + this.ar_coeffs_y_plus_128 = ar_coeffs_y_plus_128; + this.ar_coeffs_cb_plus_128 = ar_coeffs_cb_plus_128; + this.ar_coeffs_cr_plus_128 = ar_coeffs_cr_plus_128; + this.cb_mult = cb_mult; + this.cb_luma_mult = cb_luma_mult; + this.cb_offset = cb_offset; + this.cr_mult = cr_mult; + this.cr_luma_mult = cr_luma_mult; + this.cr_offset = cr_offset; + } +} + +[CRepr] struct StdVideoAV1SequenceHeaderFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "still_picture")] + [Bitfield(.Public, .Bits(1), "reduced_still_picture_header")] + [Bitfield(.Public, .Bits(1), "use_128x128_superblock")] + [Bitfield(.Public, .Bits(1), "enable_filter_intra")] + [Bitfield(.Public, .Bits(1), "enable_intra_edge_filter")] + [Bitfield(.Public, .Bits(1), "enable_interintra_compound")] + [Bitfield(.Public, .Bits(1), "enable_masked_compound")] + [Bitfield(.Public, .Bits(1), "enable_warped_motion")] + [Bitfield(.Public, .Bits(1), "enable_dual_filter")] + [Bitfield(.Public, .Bits(1), "enable_order_hint")] + [Bitfield(.Public, .Bits(1), "enable_jnt_comp")] + [Bitfield(.Public, .Bits(1), "enable_ref_frame_mvs")] + [Bitfield(.Public, .Bits(1), "frame_id_numbers_present_flag")] + [Bitfield(.Public, .Bits(1), "enable_superres")] + [Bitfield(.Public, .Bits(1), "enable_cdef")] + [Bitfield(.Public, .Bits(1), "enable_restoration")] + [Bitfield(.Public, .Bits(1), "film_grain_params_present")] + [Bitfield(.Public, .Bits(1), "timing_info_present_flag")] + [Bitfield(.Public, .Bits(1), "initial_display_delay_present_flag")] + [Bitfield(.Public, .Bits(13), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 still_picture, uint32 reduced_still_picture_header, uint32 use_128x128_superblock, uint32 enable_filter_intra, uint32 enable_intra_edge_filter, uint32 enable_interintra_compound, uint32 enable_masked_compound, uint32 enable_warped_motion, uint32 enable_dual_filter, uint32 enable_order_hint, uint32 enable_jnt_comp, uint32 enable_ref_frame_mvs, uint32 frame_id_numbers_present_flag, uint32 enable_superres, uint32 enable_cdef, uint32 enable_restoration, uint32 film_grain_params_present, uint32 timing_info_present_flag, uint32 initial_display_delay_present_flag, uint32 reserved) : this() + { + this.still_picture = still_picture; + this.reduced_still_picture_header = reduced_still_picture_header; + this.use_128x128_superblock = use_128x128_superblock; + this.enable_filter_intra = enable_filter_intra; + this.enable_intra_edge_filter = enable_intra_edge_filter; + this.enable_interintra_compound = enable_interintra_compound; + this.enable_masked_compound = enable_masked_compound; + this.enable_warped_motion = enable_warped_motion; + this.enable_dual_filter = enable_dual_filter; + this.enable_order_hint = enable_order_hint; + this.enable_jnt_comp = enable_jnt_comp; + this.enable_ref_frame_mvs = enable_ref_frame_mvs; + this.frame_id_numbers_present_flag = frame_id_numbers_present_flag; + this.enable_superres = enable_superres; + this.enable_cdef = enable_cdef; + this.enable_restoration = enable_restoration; + this.film_grain_params_present = film_grain_params_present; + this.timing_info_present_flag = timing_info_present_flag; + this.initial_display_delay_present_flag = initial_display_delay_present_flag; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoAV1SequenceHeader : this() +{ + + public StdVideoAV1SequenceHeaderFlags flags = default; + public StdVideoAV1Profile seq_profile = default; + public uint8 frame_width_bits_minus_1 = 0; + public uint8 frame_height_bits_minus_1 = 0; + public uint16 max_frame_width_minus_1 = 0; + public uint16 max_frame_height_minus_1 = 0; + public uint8 delta_frame_id_length_minus_2 = 0; + public uint8 additional_frame_id_length_minus_1 = 0; + public uint8 order_hint_bits_minus_1 = 0; + public uint8 seq_force_integer_mv = 0; // The final value of of seq_force_integer_mv per the value of seq_choose_integer_mv. + public uint8 seq_force_screen_content_tools = 0; // The final value of of seq_force_screen_content_tools per the value of seq_choose_screen_content_tools. + public uint8[5] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoAV1ColorConfig* pColorConfig = null; + public StdVideoAV1TimingInfo* pTimingInfo = null; + + public this(StdVideoAV1SequenceHeaderFlags flags, StdVideoAV1Profile seq_profile, uint8 frame_width_bits_minus_1, uint8 frame_height_bits_minus_1, uint16 max_frame_width_minus_1, uint16 max_frame_height_minus_1, uint8 delta_frame_id_length_minus_2, uint8 additional_frame_id_length_minus_1, uint8 order_hint_bits_minus_1, uint8 seq_force_integer_mv, uint8 seq_force_screen_content_tools, uint8[5] reserved1, StdVideoAV1ColorConfig* pColorConfig, StdVideoAV1TimingInfo* pTimingInfo = null) : this() + { + this.flags = flags; + this.seq_profile = seq_profile; + this.frame_width_bits_minus_1 = frame_width_bits_minus_1; + this.frame_height_bits_minus_1 = frame_height_bits_minus_1; + this.max_frame_width_minus_1 = max_frame_width_minus_1; + this.max_frame_height_minus_1 = max_frame_height_minus_1; + this.delta_frame_id_length_minus_2 = delta_frame_id_length_minus_2; + this.additional_frame_id_length_minus_1 = additional_frame_id_length_minus_1; + this.order_hint_bits_minus_1 = order_hint_bits_minus_1; + this.seq_force_integer_mv = seq_force_integer_mv; + this.seq_force_screen_content_tools = seq_force_screen_content_tools; + this.reserved1 = reserved1; + this.pColorConfig = pColorConfig; + this.pTimingInfo = pTimingInfo; + } +} + +// protect with VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_av1_decode"; } + +[CRepr] struct StdVideoDecodeAV1PictureInfoFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "error_resilient_mode")] + [Bitfield(.Public, .Bits(1), "disable_cdf_update")] + [Bitfield(.Public, .Bits(1), "use_superres")] + [Bitfield(.Public, .Bits(1), "render_and_frame_size_different")] + [Bitfield(.Public, .Bits(1), "allow_screen_content_tools")] + [Bitfield(.Public, .Bits(1), "is_filter_switchable")] + [Bitfield(.Public, .Bits(1), "force_integer_mv")] + [Bitfield(.Public, .Bits(1), "frame_size_override_flag")] + [Bitfield(.Public, .Bits(1), "buffer_removal_time_present_flag")] + [Bitfield(.Public, .Bits(1), "allow_intrabc")] + [Bitfield(.Public, .Bits(1), "frame_refs_short_signaling")] + [Bitfield(.Public, .Bits(1), "allow_high_precision_mv")] + [Bitfield(.Public, .Bits(1), "is_motion_mode_switchable")] + [Bitfield(.Public, .Bits(1), "use_ref_frame_mvs")] + [Bitfield(.Public, .Bits(1), "disable_frame_end_update_cdf")] + [Bitfield(.Public, .Bits(1), "allow_warped_motion")] + [Bitfield(.Public, .Bits(1), "reduced_tx_set")] + [Bitfield(.Public, .Bits(1), "reference_select")] + [Bitfield(.Public, .Bits(1), "skip_mode_present")] + [Bitfield(.Public, .Bits(1), "delta_q_present")] + [Bitfield(.Public, .Bits(1), "delta_lf_present")] + [Bitfield(.Public, .Bits(1), "delta_lf_multi")] + [Bitfield(.Public, .Bits(1), "segmentation_enabled")] + [Bitfield(.Public, .Bits(1), "segmentation_update_map")] + [Bitfield(.Public, .Bits(1), "segmentation_temporal_update")] + [Bitfield(.Public, .Bits(1), "segmentation_update_data")] + [Bitfield(.Public, .Bits(1), "UsesLr")] + [Bitfield(.Public, .Bits(1), "usesChromaLr")] + [Bitfield(.Public, .Bits(1), "apply_grain")] + [Bitfield(.Public, .Bits(3), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 error_resilient_mode, uint32 disable_cdf_update, uint32 use_superres, uint32 render_and_frame_size_different, uint32 allow_screen_content_tools, uint32 is_filter_switchable, uint32 force_integer_mv, uint32 frame_size_override_flag, uint32 buffer_removal_time_present_flag, uint32 allow_intrabc, uint32 frame_refs_short_signaling, uint32 allow_high_precision_mv, uint32 is_motion_mode_switchable, uint32 use_ref_frame_mvs, uint32 disable_frame_end_update_cdf, uint32 allow_warped_motion, uint32 reduced_tx_set, uint32 reference_select, uint32 skip_mode_present, uint32 delta_q_present, uint32 delta_lf_present, uint32 delta_lf_multi, uint32 segmentation_enabled, uint32 segmentation_update_map, uint32 segmentation_temporal_update, uint32 segmentation_update_data, uint32 UsesLr, uint32 usesChromaLr, uint32 apply_grain, uint32 reserved) : this() + { + this.error_resilient_mode = error_resilient_mode; + this.disable_cdf_update = disable_cdf_update; + this.use_superres = use_superres; + this.render_and_frame_size_different = render_and_frame_size_different; + this.allow_screen_content_tools = allow_screen_content_tools; + this.is_filter_switchable = is_filter_switchable; + this.force_integer_mv = force_integer_mv; + this.frame_size_override_flag = frame_size_override_flag; + this.buffer_removal_time_present_flag = buffer_removal_time_present_flag; + this.allow_intrabc = allow_intrabc; + this.frame_refs_short_signaling = frame_refs_short_signaling; + this.allow_high_precision_mv = allow_high_precision_mv; + this.is_motion_mode_switchable = is_motion_mode_switchable; + this.use_ref_frame_mvs = use_ref_frame_mvs; + this.disable_frame_end_update_cdf = disable_frame_end_update_cdf; + this.allow_warped_motion = allow_warped_motion; + this.reduced_tx_set = reduced_tx_set; + this.reference_select = reference_select; + this.skip_mode_present = skip_mode_present; + this.delta_q_present = delta_q_present; + this.delta_lf_present = delta_lf_present; + this.delta_lf_multi = delta_lf_multi; + this.segmentation_enabled = segmentation_enabled; + this.segmentation_update_map = segmentation_update_map; + this.segmentation_temporal_update = segmentation_temporal_update; + this.segmentation_update_data = segmentation_update_data; + this.UsesLr = UsesLr; + this.usesChromaLr = usesChromaLr; + this.apply_grain = apply_grain; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoDecodeAV1PictureInfo : this() +{ + + public StdVideoDecodeAV1PictureInfoFlags flags = default; + public StdVideoAV1FrameType frame_type = default; + public uint32 current_frame_id = 0; + public uint8 OrderHint = 0; + public uint8 primary_ref_frame = 0; + public uint8 refresh_frame_flags = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public StdVideoAV1InterpolationFilter interpolation_filter = default; + public StdVideoAV1TxMode TxMode = default; + public uint8 delta_q_res = 0; + public uint8 delta_lf_res = 0; + public uint8[STD_VIDEO_AV1_SKIP_MODE_FRAMES] SkipModeFrame = .(); + public uint8 coded_denom = 0; + public uint8[3] reserved2 = .(); // Reserved for future use and must be initialized with 0. + public uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] OrderHints = .(); + public uint32[STD_VIDEO_AV1_NUM_REF_FRAMES] expectedFrameId = .(); + public StdVideoAV1TileInfo* pTileInfo = null; + public StdVideoAV1Quantization* pQuantization = null; + public StdVideoAV1Segmentation* pSegmentation = null; + public StdVideoAV1LoopFilter* pLoopFilter = null; + public StdVideoAV1CDEF* pCDEF = null; + public StdVideoAV1LoopRestoration* pLoopRestoration = null; + public StdVideoAV1GlobalMotion* pGlobalMotion = null; + public StdVideoAV1FilmGrain* pFilmGrain = null; + + public this(StdVideoDecodeAV1PictureInfoFlags flags, StdVideoAV1FrameType frame_type, uint32 current_frame_id, uint8 OrderHint, uint8 primary_ref_frame, uint8 refresh_frame_flags, uint8 reserved1, StdVideoAV1InterpolationFilter interpolation_filter, StdVideoAV1TxMode TxMode, uint8 delta_q_res, uint8 delta_lf_res, uint8[STD_VIDEO_AV1_SKIP_MODE_FRAMES] SkipModeFrame, uint8 coded_denom, uint8[3] reserved2, uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] OrderHints, uint32[STD_VIDEO_AV1_NUM_REF_FRAMES] expectedFrameId, StdVideoAV1TileInfo* pTileInfo, StdVideoAV1Quantization* pQuantization, StdVideoAV1Segmentation* pSegmentation, StdVideoAV1LoopFilter* pLoopFilter, StdVideoAV1CDEF* pCDEF, StdVideoAV1LoopRestoration* pLoopRestoration, StdVideoAV1GlobalMotion* pGlobalMotion, StdVideoAV1FilmGrain* pFilmGrain = null) : this() + { + this.flags = flags; + this.frame_type = frame_type; + this.current_frame_id = current_frame_id; + this.OrderHint = OrderHint; + this.primary_ref_frame = primary_ref_frame; + this.refresh_frame_flags = refresh_frame_flags; + this.reserved1 = reserved1; + this.interpolation_filter = interpolation_filter; + this.TxMode = TxMode; + this.delta_q_res = delta_q_res; + this.delta_lf_res = delta_lf_res; + this.SkipModeFrame = SkipModeFrame; + this.coded_denom = coded_denom; + this.reserved2 = reserved2; + this.OrderHints = OrderHints; + this.expectedFrameId = expectedFrameId; + this.pTileInfo = pTileInfo; + this.pQuantization = pQuantization; + this.pSegmentation = pSegmentation; + this.pLoopFilter = pLoopFilter; + this.pCDEF = pCDEF; + this.pLoopRestoration = pLoopRestoration; + this.pGlobalMotion = pGlobalMotion; + this.pFilmGrain = pFilmGrain; + } +} + +[CRepr] struct StdVideoDecodeAV1ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "disable_frame_end_update_cdf")] + [Bitfield(.Public, .Bits(1), "segmentation_enabled")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 disable_frame_end_update_cdf, uint32 segmentation_enabled, uint32 reserved) : this() + { + this.disable_frame_end_update_cdf = disable_frame_end_update_cdf; + this.segmentation_enabled = segmentation_enabled; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoDecodeAV1ReferenceInfo : this() +{ + public StdVideoDecodeAV1ReferenceInfoFlags flags = default; + public uint8 frame_type = 0; + public uint8 RefFrameSignBias = 0; + public uint8 OrderHint = 0; + public uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] SavedOrderHints = .(); + + public this(StdVideoDecodeAV1ReferenceInfoFlags flags, uint8 frame_type, uint8 RefFrameSignBias, uint8 OrderHint, uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] SavedOrderHints) : this() + { + this.flags = flags; + this.frame_type = frame_type; + this.RefFrameSignBias = RefFrameSignBias; + this.OrderHint = OrderHint; + this.SavedOrderHints = SavedOrderHints; + } +} + +// protect with VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 = VK_MAKE_VIDEO_STD_VERSION(1, 0, 0); } + +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0; } +static { public const let VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME = "VK_STD_vulkan_video_codec_av1_encode"; } + +[CRepr] struct StdVideoEncodeAV1DecoderModelInfo : this() +{ + public uint8 buffer_delay_length_minus_1 = 0; + public uint8 buffer_removal_time_length_minus_1 = 0; + public uint8 frame_presentation_time_length_minus_1 = 0; + public uint8 reserved1 = 0; // Reserved for future use and must be initialized with 0. + public uint32 num_units_in_decoding_tick = 0; + + public this(uint8 buffer_delay_length_minus_1, uint8 buffer_removal_time_length_minus_1, uint8 frame_presentation_time_length_minus_1, uint8 reserved1, uint32 num_units_in_decoding_tick) : this() + { + this.buffer_delay_length_minus_1 = buffer_delay_length_minus_1; + this.buffer_removal_time_length_minus_1 = buffer_removal_time_length_minus_1; + this.frame_presentation_time_length_minus_1 = frame_presentation_time_length_minus_1; + this.reserved1 = reserved1; + this.num_units_in_decoding_tick = num_units_in_decoding_tick; + } +} + +[CRepr] struct StdVideoEncodeAV1ExtensionHeader : this() +{ + + public uint8 temporal_id = 0; + public uint8 spatial_id = 0; + + public this(uint8 temporal_id, uint8 spatial_id) : this() + { + this.temporal_id = temporal_id; + this.spatial_id = spatial_id; + } +} + +[CRepr] struct StdVideoEncodeAV1OperatingPointInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "decoder_model_present_for_this_op")] + [Bitfield(.Public, .Bits(1), "low_delay_mode_flag")] + [Bitfield(.Public, .Bits(1), "initial_display_delay_present_for_this_op")] + [Bitfield(.Public, .Bits(29), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 decoder_model_present_for_this_op, uint32 low_delay_mode_flag, uint32 initial_display_delay_present_for_this_op, uint32 reserved) : this() + { + this.decoder_model_present_for_this_op = decoder_model_present_for_this_op; + this.low_delay_mode_flag = low_delay_mode_flag; + this.initial_display_delay_present_for_this_op = initial_display_delay_present_for_this_op; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeAV1OperatingPointInfo : this() +{ + public StdVideoEncodeAV1OperatingPointInfoFlags flags = default; + public uint16 operating_point_idc = 0; + public uint8 seq_level_idx = 0; + public uint8 seq_tier = 0; + public uint32 decoder_buffer_delay = 0; + public uint32 encoder_buffer_delay = 0; + public uint8 initial_display_delay_minus_1 = 0; + + public this(StdVideoEncodeAV1OperatingPointInfoFlags flags, uint16 operating_point_idc, uint8 seq_level_idx, uint8 seq_tier, uint32 decoder_buffer_delay, uint32 encoder_buffer_delay, uint8 initial_display_delay_minus_1) : this() + { + this.flags = flags; + this.operating_point_idc = operating_point_idc; + this.seq_level_idx = seq_level_idx; + this.seq_tier = seq_tier; + this.decoder_buffer_delay = decoder_buffer_delay; + this.encoder_buffer_delay = encoder_buffer_delay; + this.initial_display_delay_minus_1 = initial_display_delay_minus_1; + } +} + +[CRepr] struct StdVideoEncodeAV1PictureInfoFlags : this() +{ + + [Bitfield(.Public, .Bits(1), "error_resilient_mode")] + [Bitfield(.Public, .Bits(1), "disable_cdf_update")] + [Bitfield(.Public, .Bits(1), "use_superres")] + [Bitfield(.Public, .Bits(1), "render_and_frame_size_different")] + [Bitfield(.Public, .Bits(1), "allow_screen_content_tools")] + [Bitfield(.Public, .Bits(1), "is_filter_switchable")] + [Bitfield(.Public, .Bits(1), "force_integer_mv")] + [Bitfield(.Public, .Bits(1), "frame_size_override_flag")] + [Bitfield(.Public, .Bits(1), "buffer_removal_time_present_flag")] + [Bitfield(.Public, .Bits(1), "allow_intrabc")] + [Bitfield(.Public, .Bits(1), "frame_refs_short_signaling")] + [Bitfield(.Public, .Bits(1), "allow_high_precision_mv")] + [Bitfield(.Public, .Bits(1), "is_motion_mode_switchable")] + [Bitfield(.Public, .Bits(1), "use_ref_frame_mvs")] + [Bitfield(.Public, .Bits(1), "disable_frame_end_update_cdf")] + [Bitfield(.Public, .Bits(1), "allow_warped_motion")] + [Bitfield(.Public, .Bits(1), "reduced_tx_set")] + [Bitfield(.Public, .Bits(1), "skip_mode_present")] + [Bitfield(.Public, .Bits(1), "delta_q_present")] + [Bitfield(.Public, .Bits(1), "delta_lf_present")] + [Bitfield(.Public, .Bits(1), "delta_lf_multi")] + [Bitfield(.Public, .Bits(1), "segmentation_enabled")] + [Bitfield(.Public, .Bits(1), "segmentation_update_map")] + [Bitfield(.Public, .Bits(1), "segmentation_temporal_update")] + [Bitfield(.Public, .Bits(1), "segmentation_update_data")] + [Bitfield(.Public, .Bits(1), "UsesLr")] + [Bitfield(.Public, .Bits(1), "usesChromaLr")] + [Bitfield(.Public, .Bits(1), "show_frame")] + [Bitfield(.Public, .Bits(1), "showable_frame")] + [Bitfield(.Public, .Bits(3), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 error_resilient_mode, uint32 disable_cdf_update, uint32 use_superres, uint32 render_and_frame_size_different, uint32 allow_screen_content_tools, uint32 is_filter_switchable, uint32 force_integer_mv, uint32 frame_size_override_flag, uint32 buffer_removal_time_present_flag, uint32 allow_intrabc, uint32 frame_refs_short_signaling, uint32 allow_high_precision_mv, uint32 is_motion_mode_switchable, uint32 use_ref_frame_mvs, uint32 disable_frame_end_update_cdf, uint32 allow_warped_motion, uint32 reduced_tx_set, uint32 skip_mode_present, uint32 delta_q_present, uint32 delta_lf_present, uint32 delta_lf_multi, uint32 segmentation_enabled, uint32 segmentation_update_map, uint32 segmentation_temporal_update, uint32 segmentation_update_data, uint32 UsesLr, uint32 usesChromaLr, uint32 show_frame, uint32 showable_frame, uint32 reserved) : this() + { + this.error_resilient_mode = error_resilient_mode; + this.disable_cdf_update = disable_cdf_update; + this.use_superres = use_superres; + this.render_and_frame_size_different = render_and_frame_size_different; + this.allow_screen_content_tools = allow_screen_content_tools; + this.is_filter_switchable = is_filter_switchable; + this.force_integer_mv = force_integer_mv; + this.frame_size_override_flag = frame_size_override_flag; + this.buffer_removal_time_present_flag = buffer_removal_time_present_flag; + this.allow_intrabc = allow_intrabc; + this.frame_refs_short_signaling = frame_refs_short_signaling; + this.allow_high_precision_mv = allow_high_precision_mv; + this.is_motion_mode_switchable = is_motion_mode_switchable; + this.use_ref_frame_mvs = use_ref_frame_mvs; + this.disable_frame_end_update_cdf = disable_frame_end_update_cdf; + this.allow_warped_motion = allow_warped_motion; + this.reduced_tx_set = reduced_tx_set; + this.skip_mode_present = skip_mode_present; + this.delta_q_present = delta_q_present; + this.delta_lf_present = delta_lf_present; + this.delta_lf_multi = delta_lf_multi; + this.segmentation_enabled = segmentation_enabled; + this.segmentation_update_map = segmentation_update_map; + this.segmentation_temporal_update = segmentation_temporal_update; + this.segmentation_update_data = segmentation_update_data; + this.UsesLr = UsesLr; + this.usesChromaLr = usesChromaLr; + this.show_frame = show_frame; + this.showable_frame = showable_frame; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeAV1PictureInfo : this() +{ + + public StdVideoEncodeAV1PictureInfoFlags flags = default; + public StdVideoAV1FrameType frame_type = default; + public uint32 frame_presentation_time = 0; + public uint32 current_frame_id = 0; + public uint8 order_hint = 0; + public uint8 primary_ref_frame = 0; + public uint8 refresh_frame_flags = 0; + public uint8 coded_denom = 0; + public uint16 render_width_minus_1 = 0; + public uint16 render_height_minus_1 = 0; + public StdVideoAV1InterpolationFilter interpolation_filter = default; + public StdVideoAV1TxMode TxMode = default; + public uint8 delta_q_res = 0; + public uint8 delta_lf_res = 0; + public uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] ref_order_hint = .(); + public int8[STD_VIDEO_AV1_REFS_PER_FRAME] ref_frame_idx = .(); + public uint8[3] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public uint32[STD_VIDEO_AV1_REFS_PER_FRAME] delta_frame_id_minus_1 = .(); + public StdVideoAV1TileInfo* pTileInfo = null; + public StdVideoAV1Quantization* pQuantization = null; + public StdVideoAV1Segmentation* pSegmentation = null; + public StdVideoAV1LoopFilter* pLoopFilter = null; + public StdVideoAV1CDEF* pCDEF = null; + public StdVideoAV1LoopRestoration* pLoopRestoration = null; + public StdVideoAV1GlobalMotion* pGlobalMotion = null; + public StdVideoEncodeAV1ExtensionHeader* pExtensionHeader = null; + public uint32* pBufferRemovalTimes = null; + + public this(StdVideoEncodeAV1PictureInfoFlags flags, StdVideoAV1FrameType frame_type, uint32 frame_presentation_time, uint32 current_frame_id, uint8 order_hint, uint8 primary_ref_frame, uint8 refresh_frame_flags, uint8 coded_denom, uint16 render_width_minus_1, uint16 render_height_minus_1, StdVideoAV1InterpolationFilter interpolation_filter, StdVideoAV1TxMode TxMode, uint8 delta_q_res, uint8 delta_lf_res, uint8[STD_VIDEO_AV1_NUM_REF_FRAMES] ref_order_hint, int8[STD_VIDEO_AV1_REFS_PER_FRAME] ref_frame_idx, uint8[3] reserved1, uint32[STD_VIDEO_AV1_REFS_PER_FRAME] delta_frame_id_minus_1, StdVideoAV1TileInfo* pTileInfo, StdVideoAV1Quantization* pQuantization, StdVideoAV1Segmentation* pSegmentation, StdVideoAV1LoopFilter* pLoopFilter, StdVideoAV1CDEF* pCDEF, StdVideoAV1LoopRestoration* pLoopRestoration, StdVideoAV1GlobalMotion* pGlobalMotion, StdVideoEncodeAV1ExtensionHeader* pExtensionHeader = null, uint32* pBufferRemovalTimes = null) : this() + { + this.flags = flags; + this.frame_type = frame_type; + this.frame_presentation_time = frame_presentation_time; + this.current_frame_id = current_frame_id; + this.order_hint = order_hint; + this.primary_ref_frame = primary_ref_frame; + this.refresh_frame_flags = refresh_frame_flags; + this.coded_denom = coded_denom; + this.render_width_minus_1 = render_width_minus_1; + this.render_height_minus_1 = render_height_minus_1; + this.interpolation_filter = interpolation_filter; + this.TxMode = TxMode; + this.delta_q_res = delta_q_res; + this.delta_lf_res = delta_lf_res; + this.ref_order_hint = ref_order_hint; + this.ref_frame_idx = ref_frame_idx; + this.reserved1 = reserved1; + this.delta_frame_id_minus_1 = delta_frame_id_minus_1; + this.pTileInfo = pTileInfo; + this.pQuantization = pQuantization; + this.pSegmentation = pSegmentation; + this.pLoopFilter = pLoopFilter; + this.pCDEF = pCDEF; + this.pLoopRestoration = pLoopRestoration; + this.pGlobalMotion = pGlobalMotion; + this.pExtensionHeader = pExtensionHeader; + this.pBufferRemovalTimes = pBufferRemovalTimes; + } +} + +[CRepr] struct StdVideoEncodeAV1ReferenceInfoFlags : this() +{ + [Bitfield(.Public, .Bits(1), "disable_frame_end_update_cdf")] + [Bitfield(.Public, .Bits(1), "segmentation_enabled")] + [Bitfield(.Public, .Bits(30), "reserved")] + private uint32 __bitfields_reserved = 0; + + public this(uint32 disable_frame_end_update_cdf, uint32 segmentation_enabled, uint32 reserved) : this() + { + this.disable_frame_end_update_cdf = disable_frame_end_update_cdf; + this.segmentation_enabled = segmentation_enabled; + this.reserved = reserved; + } +} + +[CRepr] struct StdVideoEncodeAV1ReferenceInfo : this() +{ + public StdVideoEncodeAV1ReferenceInfoFlags flags = default; + public uint32 RefFrameId = 0; + public StdVideoAV1FrameType frame_type = default; + public uint8 OrderHint = 0; + public uint8[3] reserved1 = .(); // Reserved for future use and must be initialized with 0. + public StdVideoEncodeAV1ExtensionHeader* pExtensionHeader = null; + + public this(StdVideoEncodeAV1ReferenceInfoFlags flags, uint32 RefFrameId, StdVideoAV1FrameType frame_type, uint8 OrderHint, uint8[3] reserved1, StdVideoEncodeAV1ExtensionHeader* pExtensionHeader = null) : this() + { + this.flags = flags; + this.RefFrameId = RefFrameId; + this.frame_type = frame_type; + this.OrderHint = OrderHint; + this.reserved1 = reserved1; + this.pExtensionHeader = pExtensionHeader; + } +} diff --git a/src/Vulkan.bf b/src/Vulkan.bf new file mode 100644 index 0000000..20c1d9f --- /dev/null +++ b/src/Vulkan.bf @@ -0,0 +1,36423 @@ +// This file was generated by Setup/Program.bf +// Based on vk.xml + +using System; +using System.Interop; + +using Vulkan.Video; +using Vulkan.External; + +namespace Vulkan; + +// Vulkan base API interface definitions +// Header boilerplate +// Fundamental types used by many commands and structures +typealias VkDeviceAddress = uint64; +typealias VkDeviceSize = uint64; + +[CRepr] struct VkExtent2D : this() +{ + public uint32 width = 0; + public uint32 height = 0; + + public this(uint32 width, uint32 height) : this() + { + this.width = width; + this.height = height; + } +} + +[CRepr] struct VkExtent3D : this() +{ + public uint32 width = 0; + public uint32 height = 0; + public uint32 depth = 0; + + public this(uint32 width, uint32 height, uint32 depth) : this() + { + this.width = width; + this.height = height; + this.depth = depth; + } +} + +typealias VkFlags = uint32; + +[CRepr] struct VkOffset2D : this() +{ + public int32 x = 0; + public int32 y = 0; + + public this(int32 x, int32 y) : this() + { + this.x = x; + this.y = y; + } +} + +[CRepr] struct VkOffset3D : this() +{ + public int32 x = 0; + public int32 y = 0; + public int32 z = 0; + + public this(int32 x, int32 y, int32 z) : this() + { + this.x = x; + this.y = y; + this.z = z; + } +} + +[CRepr] struct VkRect2D : this() +{ + public VkOffset2D offset = default; + public VkExtent2D extent = default; + + public this(VkOffset2D offset, VkExtent2D extent) : this() + { + this.offset = offset; + this.extent = extent; + } +} + +[AllowDuplicates] enum VkResult : int32 +{ + [NoShow] VK_SUCCESS = 0, // Command completed successfully + [NoShow] VK_NOT_READY = 1, // A fence or query has not yet completed + [NoShow] VK_TIMEOUT = 2, // A wait operation has not completed in the specified time + [NoShow] VK_EVENT_SET = 3, // An event is signaled + [NoShow] VK_EVENT_RESET = 4, // An event is unsignaled + [NoShow] VK_INCOMPLETE = 5, // A return array was too small for the result + [NoShow] VK_ERROR_OUT_OF_HOST_MEMORY = -1, // A host memory allocation has failed + [NoShow] VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, // A device memory allocation has failed + [NoShow] VK_ERROR_INITIALIZATION_FAILED = -3, // Initialization of an object has failed + [NoShow] VK_ERROR_DEVICE_LOST = -4, // The logical device has been lost. See <> + [NoShow] VK_ERROR_MEMORY_MAP_FAILED = -5, // Mapping of a memory object has failed + [NoShow] VK_ERROR_LAYER_NOT_PRESENT = -6, // Layer specified does not exist + [NoShow] VK_ERROR_EXTENSION_NOT_PRESENT = -7, // Extension specified does not exist + [NoShow] VK_ERROR_FEATURE_NOT_PRESENT = -8, // Requested feature is not available on this device + [NoShow] VK_ERROR_INCOMPATIBLE_DRIVER = -9, // Unable to find a Vulkan driver + [NoShow] VK_ERROR_TOO_MANY_OBJECTS = -10, // Too many objects of the type have already been created + [NoShow] VK_ERROR_FORMAT_NOT_SUPPORTED = -11, // Requested format is not supported on this device + [NoShow] VK_ERROR_FRAGMENTED_POOL = -12, // A requested pool allocation has failed due to fragmentation of the pool's memory + [NoShow] VK_ERROR_UNKNOWN = -13, // An unknown error has occurred, due to an implementation or application bug + [NoShow] VK_ERROR_VALIDATION_FAILED = -1000011001, + [NoShow] VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + [NoShow] VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + [NoShow] VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + [NoShow] VK_ERROR_FRAGMENTATION = -1000161000, + [NoShow] VK_PIPELINE_COMPILE_REQUIRED = 1000297000, + [NoShow] VK_ERROR_NOT_PERMITTED = -1000174001, + [NoShow] VK_ERROR_SURFACE_LOST_KHR = -1000000000, + [NoShow] VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + [NoShow] VK_SUBOPTIMAL_KHR = 1000001003, + [NoShow] VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + [NoShow] VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + [NoShow] VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED, + [NoShow] VK_ERROR_INVALID_SHADER_NV = -1000012000, + [NoShow] VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + [NoShow] VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + [NoShow] VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + [NoShow] VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + [NoShow] VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + [NoShow] VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, + [NoShow] VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + [NoShow] VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + [NoShow] VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + [NoShow] VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, + [NoShow] VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED, + [NoShow] VK_ERROR_NOT_PERMITTED_KHR = VK_ERROR_NOT_PERMITTED, + [NoShow] VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT = -1000208000, + [NoShow] VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + [NoShow] VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + [NoShow] VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + [NoShow] VK_THREAD_IDLE_KHR = 1000268000, + [NoShow] VK_THREAD_DONE_KHR = 1000268001, + [NoShow] VK_OPERATION_DEFERRED_KHR = 1000268002, + [NoShow] VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, + [NoShow] VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + [NoShow] VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + [NoShow] VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, + [NoShow] VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + [NoShow] VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + [NoShow] VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, + [NoShow] VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, + [NoShow] VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, + // pretty names + VkSuccess = 0, // Command completed successfully + VkNotReady = 1, // A fence or query has not yet completed + VkTimeout = 2, // A wait operation has not completed in the specified time + VkEventSet = 3, // An event is signaled + VkEventReset = 4, // An event is unsignaled + VkIncomplete = 5, // A return array was too small for the result + VkErrorOutOfHostMemory = -1, // A host memory allocation has failed + VkErrorOutOfDeviceMemory = -2, // A device memory allocation has failed + VkErrorInitializationFailed = -3, // Initialization of an object has failed + VkErrorDeviceLost = -4, // The logical device has been lost. See <> + VkErrorMemoryMapFailed = -5, // Mapping of a memory object has failed + VkErrorLayerNotPresent = -6, // Layer specified does not exist + VkErrorExtensionNotPresent = -7, // Extension specified does not exist + VkErrorFeatureNotPresent = -8, // Requested feature is not available on this device + VkErrorIncompatibleDriver = -9, // Unable to find a Vulkan driver + VkErrorTooManyObjects = -10, // Too many objects of the type have already been created + VkErrorFormatNotSupported = -11, // Requested format is not supported on this device + VkErrorFragmentedPool = -12, // A requested pool allocation has failed due to fragmentation of the pool's memory + VkErrorUnknown = -13, // An unknown error has occurred, due to an implementation or application bug + VkErrorValidationFailed = -1000011001, + VkErrorOutOfPoolMemory = -1000069000, + VkErrorInvalidExternalHandle = -1000072003, + VkErrorInvalidOpaqueCaptureAddress = -1000257000, + VkErrorFragmentation = -1000161000, + VkPipelineCompileRequired = 1000297000, + VkErrorNotPermitted = -1000174001, + VkErrorSurfaceLostKHR = -1000000000, + VkErrorNativeWindowInUseKHR = -1000000001, + VkSuboptimalKHR = 1000001003, + VkErrorOutOfDateKHR = -1000001004, + VkErrorIncompatibleDisplayKHR = -1000003001, + VkErrorValidationFailedEXT = VkErrorValidationFailed, + VkErrorInvalidShaderNV = -1000012000, + VkErrorImageUsageNotSupportedKHR = -1000023000, + VkErrorVideoPictureLayoutNotSupportedKHR = -1000023001, + VkErrorVideoProfileOperationNotSupportedKHR = -1000023002, + VkErrorVideoProfileFormatNotSupportedKHR = -1000023003, + VkErrorVideoProfileCodecNotSupportedKHR = -1000023004, + VkErrorVideoStdVersionNotSupportedKHR = -1000023005, + VkErrorOutOfPoolMemoryKHR = VkErrorOutOfPoolMemory, + VkErrorInvalidExternalHandleKHR = VkErrorInvalidExternalHandle, + VkErrorInvalidDrmFormatModifierPlaneLayoutEXT = -1000158000, + VkErrorFragmentationEXT = VkErrorFragmentation, + VkErrorNotPermittedEXT = VkErrorNotPermitted, + VkErrorNotPermittedKHR = VkErrorNotPermitted, + VkErrorPresentTimingQueueFullEXT = -1000208000, + VkErrorInvalidDeviceAddressEXT = VkErrorInvalidOpaqueCaptureAddress, + VkErrorFullScreenExclusiveModeLostEXT = -1000255000, + VkErrorInvalidOpaqueCaptureAddressKHR = VkErrorInvalidOpaqueCaptureAddress, + VkThreadIdleKHR = 1000268000, + VkThreadDoneKHR = 1000268001, + VkOperationDeferredKHR = 1000268002, + VkOperationNotDeferredKHR = 1000268003, + VkPipelineCompileRequiredEXT = VkPipelineCompileRequired, + VkErrorPipelineCompileRequiredEXT = VkPipelineCompileRequired, + VkErrorInvalidVideoStdParametersKHR = -1000299000, + VkErrorCompressionExhaustedEXT = -1000338000, + VkIncompatibleShaderBinaryEXT = 1000482000, + VkErrorIncompatibleShaderBinaryEXT = VkIncompatibleShaderBinaryEXT, + VkPipelineBinaryMissingKHR = 1000483000, + VkErrorNotEnoughSpaceKHR = -1000483000, +} + +[AllowDuplicates] enum VkStructureType : int32 +{ + [NoShow] VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + [NoShow] VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + [NoShow] VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + [NoShow] VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + [NoShow] VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + [NoShow] VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + [NoShow] VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + [NoShow] VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + [NoShow] VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + [NoShow] VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + [NoShow] VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + [NoShow] VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + [NoShow] VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, // Reserved for internal use by the loader, layers, and ICDs + [NoShow] VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, // Reserved for internal use by the loader, layers, and ICDs + [NoShow] VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + [NoShow] VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + [NoShow] VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + [NoShow] VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + [NoShow] VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + [NoShow] VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + [NoShow] VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + [NoShow] VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, + [NoShow] VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, + [NoShow] VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + [NoShow] VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, + [NoShow] VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + [NoShow] VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + [NoShow] VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + [NoShow] VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES = 55, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES = 56, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO = 1000174000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES = 1000265000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_MAP_INFO = 1000271000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO = 1000271001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES = 1000470000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES = 1000470001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO = 1000470004, + [NoShow] VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 = 1000338002, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 = 1000338003, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO = 1000470006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES = 1000545000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES = 1000545001, + [NoShow] VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS = 1000545002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES = 1000270000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES = 1000270001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY = 1000270002, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY = 1000270003, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO = 1000270004, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO = 1000270005, + [NoShow] VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO = 1000270006, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO = 1000270007, + [NoShow] VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE = 1000270008, + [NoShow] VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY = 1000270009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES = 1000416000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO = 1000470005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, + [NoShow] VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO = 1000545003, + [NoShow] VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO = 1000545004, + [NoShow] VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO = 1000545005, + [NoShow] VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO = 1000545006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES = 1000466000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO = 1000068000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES = 1000068001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES = 1000068002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES = 1000259000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO = 1000259001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES = 1000259002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO = 1000190001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES = 1000190002, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_AREA_INFO = 1000470003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES = 1000232000, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO = 1000232001, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO = 1000232002, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + [NoShow] VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + [NoShow] VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + [NoShow] VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + [NoShow] VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + [NoShow] VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + [NoShow] VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, + [NoShow] VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + [NoShow] VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + [NoShow] VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + [NoShow] VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, + [NoShow] VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + [NoShow] VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + [NoShow] VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX = 1000029004, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, + [NoShow] VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + [NoShow] VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + [NoShow] VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + [NoShow] VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + [NoShow] VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + [NoShow] VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + [NoShow] VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + [NoShow] VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + [NoShow] VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + [NoShow] VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + [NoShow] VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG = 1000110000, + [NoShow] VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + [NoShow] VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + [NoShow] VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + [NoShow] VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + [NoShow] VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + [NoShow] VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + [NoShow] VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + [NoShow] VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX = 1000134001, + [NoShow] VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX = 1000134002, + [NoShow] VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX = 1000134003, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000, + [NoShow] VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + [NoShow] VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + [NoShow] VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + [NoShow] VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + [NoShow] VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + [NoShow] VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + [NoShow] VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + [NoShow] VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + [NoShow] VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + [NoShow] VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + [NoShow] VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + [NoShow] VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + [NoShow] VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + [NoShow] VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + [NoShow] VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + [NoShow] VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + [NoShow] VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + [NoShow] VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT = 1000208000, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT = 1000208001, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT = 1000208002, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT = 1000208003, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT = 1000208004, + [NoShow] VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT = 1000208005, + [NoShow] VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT = 1000208006, + [NoShow] VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT = 1000208007, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT = 1000208008, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT = 1000208009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + [NoShow] VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + [NoShow] VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + [NoShow] VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + [NoShow] VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + [NoShow] VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + [NoShow] VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + [NoShow] VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, // Not promoted to 1.3 + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, + [NoShow] VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, + [NoShow] VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, + [NoShow] VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + [NoShow] VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + [NoShow] VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, // Not promoted to 1.3 + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000, + [NoShow] VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001, + [NoShow] VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, + [NoShow] VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + [NoShow] VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, + [NoShow] VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, + [NoShow] VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002, + [NoShow] VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM = 1000309003, + [NoShow] VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM = 1000309004, + [NoShow] VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM = 1000309005, + [NoShow] VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + [NoShow] VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + [NoShow] VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + [NoShow] VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + [NoShow] VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + [NoShow] VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, + [NoShow] VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + [NoShow] VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + [NoShow] VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + [NoShow] VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + [NoShow] VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + [NoShow] VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + [NoShow] VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + [NoShow] VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + [NoShow] VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + [NoShow] VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + [NoShow] VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000, + [NoShow] VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + [NoShow] VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, // Not promoted to 1.3 + [NoShow] VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + [NoShow] VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, + [NoShow] VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, + [NoShow] VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, + [NoShow] VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + [NoShow] VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, + [NoShow] VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI = 1000404002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, + [NoShow] VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, + [NoShow] VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV = 1000429008, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV = 1000429009, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV = 1000429010, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, + [NoShow] VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS = 1000452000, + [NoShow] VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS = 1000452001, + [NoShow] VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS = 1000452002, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS = 1000452003, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS = 1000452004, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS = 1000452005, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + [NoShow] VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + [NoShow] VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM = 1000460000, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM = 1000460001, + [NoShow] VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM = 1000460002, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM = 1000460003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM = 1000460004, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM = 1000460005, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM = 1000460006, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM = 1000460007, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM = 1000460008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM = 1000460009, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM = 1000460010, + [NoShow] VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM = 1000460011, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_COPY_ARM = 1000460012, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM = 1000460013, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM = 1000460014, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM = 1000460015, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM = 1000460016, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM = 1000460017, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM = 1000460018, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM = 1000460019, + [NoShow] VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM = 1000460020, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460021, + [NoShow] VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460022, + [NoShow] VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM = 1000460023, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + [NoShow] VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + [NoShow] VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + [NoShow] VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + [NoShow] VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + [NoShow] VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + [NoShow] VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001, + [NoShow] VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, + [NoShow] VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000, + [NoShow] VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001, + [NoShow] VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX = 1000478000, + [NoShow] VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX = 1000478001, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR = 1000480000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR = 1000480001, + [NoShow] VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR = 1000480002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + [NoShow] VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + [NoShow] VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR = 1000483000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR = 1000483001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR = 1000483002, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR = 1000483003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR = 1000483004, + [NoShow] VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR = 1000483005, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR = 1000483006, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR = 1000483007, + [NoShow] VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR = 1000483008, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR = 1000483009, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + [NoShow] VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + [NoShow] VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR = 1000274000, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR = 1000274001, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR = 1000274002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR = 1000275000, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR = 1000275001, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR = 1000275002, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR = 1000275003, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR = 1000275004, + [NoShow] VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR = 1000275005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV = 1000491000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491001, + [NoShow] VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491002, + [NoShow] VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV = 1000491004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + [NoShow] VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT = 1000495000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT = 1000495001, + [NoShow] VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, + [NoShow] VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000, + [NoShow] VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001, + [NoShow] VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002, + [NoShow] VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003, + [NoShow] VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004, + [NoShow] VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005, + [NoShow] VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007, + [NoShow] VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, + [NoShow] VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM = 1000507000, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM = 1000507001, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM = 1000507002, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM = 1000507003, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM = 1000507004, + [NoShow] VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM = 1000507005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM = 1000507006, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM = 1000507007, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM = 1000507008, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM = 1000507009, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM = 1000507010, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM = 1000507011, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM = 1000507012, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM = 1000507013, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM = 1000507014, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM = 1000507016, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM = 1000507017, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + [NoShow] VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR = 1000511000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR = 1000513000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000513001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR = 1000513002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR = 1000513003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR = 1000513004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR = 1000513005, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR = 1000513006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR = 1000513007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR = 1000513008, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR = 1000513009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR = 1000513010, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR = 1000514000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR = 1000514001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR = 1000514002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR = 1000514003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001, + [NoShow] VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000, + [NoShow] VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR = 1000527000, + [NoShow] VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT = 1000527001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, + [NoShow] VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, + [NoShow] VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, + [NoShow] VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, + [NoShow] VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, + [NoShow] VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, + [NoShow] VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, + [NoShow] VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, + [NoShow] VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM = 1000547000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM = 1000547001, + [NoShow] VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, + [NoShow] VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, + [NoShow] VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002, + [NoShow] VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT = 1000427000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT = 1000427001, + [NoShow] VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT = 1000550002, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000, + [NoShow] VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR = 1000552003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR = 1000552004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000553005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR = 1000553009, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553003, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553004, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553006, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV = 1000556000, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV = 1000556001, + [NoShow] VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV = 1000556002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV = 1000556003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR = 1000562001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR = 1000562002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR = 1000562003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT = 1000567000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000569001, + [NoShow] VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV = 1000569002, + [NoShow] VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV = 1000569003, + [NoShow] VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV = 1000569004, + [NoShow] VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV = 1000569005, + [NoShow] VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV = 1000569006, + [NoShow] VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000569007, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV = 1000570000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000570001, + [NoShow] VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570002, + [NoShow] VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV = 1000570003, + [NoShow] VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV = 1000570004, + [NoShow] VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV = 1000570005, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007, + [NoShow] VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008, + [NoShow] VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011, + [NoShow] VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, + [NoShow] VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, + [NoShow] VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT = 1000581000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT = 1000581001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR = 1000584001, + [NoShow] VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR = 1000584002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002, + [NoShow] VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003, + [NoShow] VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS = 1000685000, + [NoShow] VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS = 1000453001, + [NoShow] VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS = 1000453002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS = 1000453003, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000, + [NoShow] VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000, + [NoShow] VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, + [NoShow] VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, + [NoShow] VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM = 1000605000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM = 1000605001, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM = 1000605002, + [NoShow] VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM = 1000605003, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM = 1000605004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001, + [NoShow] VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, + [NoShow] VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, + [NoShow] VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, + [NoShow] VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, + [NoShow] VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT = 1000628002, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM = 1000629000, + [NoShow] VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM = 1000629001, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, + [NoShow] VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, + [NoShow] VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, + [NoShow] VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000, + // pretty names + ApplicationInfo = 0, + InstanceCreateInfo = 1, + DeviceQueueCreateInfo = 2, + DeviceCreateInfo = 3, + SubmitInfo = 4, + MemoryAllocateInfo = 5, + MappedMemoryRange = 6, + BindSparseInfo = 7, + FenceCreateInfo = 8, + SemaphoreCreateInfo = 9, + EventCreateInfo = 10, + QueryPoolCreateInfo = 11, + BufferCreateInfo = 12, + BufferViewCreateInfo = 13, + ImageCreateInfo = 14, + ImageViewCreateInfo = 15, + ShaderModuleCreateInfo = 16, + PipelineCacheCreateInfo = 17, + PipelineShaderStageCreateInfo = 18, + PipelineVertexInputStateCreateInfo = 19, + PipelineInputAssemblyStateCreateInfo = 20, + PipelineTessellationStateCreateInfo = 21, + PipelineViewportStateCreateInfo = 22, + PipelineRasterizationStateCreateInfo = 23, + PipelineMultisampleStateCreateInfo = 24, + PipelineDepthStencilStateCreateInfo = 25, + PipelineColorBlendStateCreateInfo = 26, + PipelineDynamicStateCreateInfo = 27, + GraphicsPipelineCreateInfo = 28, + ComputePipelineCreateInfo = 29, + PipelineLayoutCreateInfo = 30, + SamplerCreateInfo = 31, + DescriptorSetLayoutCreateInfo = 32, + DescriptorPoolCreateInfo = 33, + DescriptorSetAllocateInfo = 34, + WriteDescriptorSet = 35, + CopyDescriptorSet = 36, + FramebufferCreateInfo = 37, + RenderPassCreateInfo = 38, + CommandPoolCreateInfo = 39, + CommandBufferAllocateInfo = 40, + CommandBufferInheritanceInfo = 41, + CommandBufferBeginInfo = 42, + RenderPassBeginInfo = 43, + BufferMemoryBarrier = 44, + ImageMemoryBarrier = 45, + MemoryBarrier = 46, + LoaderInstanceCreateInfo = 47, // Reserved for internal use by the loader, layers, and ICDs + LoaderDeviceCreateInfo = 48, // Reserved for internal use by the loader, layers, and ICDs + BindBufferMemoryInfo = 1000157000, + BindImageMemoryInfo = 1000157001, + MemoryDedicatedRequirements = 1000127000, + MemoryDedicatedAllocateInfo = 1000127001, + MemoryAllocateFlagsInfo = 1000060000, + DeviceGroupCommandBufferBeginInfo = 1000060004, + DeviceGroupSubmitInfo = 1000060005, + DeviceGroupBindSparseInfo = 1000060006, + BindBufferMemoryDeviceGroupInfo = 1000060013, + BindImageMemoryDeviceGroupInfo = 1000060014, + PhysicalDeviceGroupProperties = 1000070000, + DeviceGroupDeviceCreateInfo = 1000070001, + BufferMemoryRequirementsInfo2 = 1000146000, + ImageMemoryRequirementsInfo2 = 1000146001, + ImageSparseMemoryRequirementsInfo2 = 1000146002, + MemoryRequirements2 = 1000146003, + SparseImageMemoryRequirements2 = 1000146004, + PhysicalDeviceFeatures2 = 1000059000, + PhysicalDeviceProperties2 = 1000059001, + FormatProperties2 = 1000059002, + ImageFormatProperties2 = 1000059003, + PhysicalDeviceImageFormatInfo2 = 1000059004, + QueueFamilyProperties2 = 1000059005, + PhysicalDeviceMemoryProperties2 = 1000059006, + SparseImageFormatProperties2 = 1000059007, + PhysicalDeviceSparseImageFormatInfo2 = 1000059008, + ImageViewUsageCreateInfo = 1000117002, + ProtectedSubmitInfo = 1000145000, + PhysicalDeviceProtectedMemoryFeatures = 1000145001, + PhysicalDeviceProtectedMemoryProperties = 1000145002, + DeviceQueueInfo2 = 1000145003, + PhysicalDeviceExternalImageFormatInfo = 1000071000, + ExternalImageFormatProperties = 1000071001, + PhysicalDeviceExternalBufferInfo = 1000071002, + ExternalBufferProperties = 1000071003, + PhysicalDeviceIdProperties = 1000071004, + ExternalMemoryBufferCreateInfo = 1000072000, + ExternalMemoryImageCreateInfo = 1000072001, + ExportMemoryAllocateInfo = 1000072002, + PhysicalDeviceExternalFenceInfo = 1000112000, + ExternalFenceProperties = 1000112001, + ExportFenceCreateInfo = 1000113000, + ExportSemaphoreCreateInfo = 1000077000, + PhysicalDeviceExternalSemaphoreInfo = 1000076000, + ExternalSemaphoreProperties = 1000076001, + PhysicalDeviceSubgroupProperties = 1000094000, + PhysicalDevice16bitStorageFeatures = 1000083000, + PhysicalDeviceVariablePointersFeatures = 1000120000, + PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures, + DescriptorUpdateTemplateCreateInfo = 1000085000, + PhysicalDeviceMaintenance3_Properties = 1000168000, + DescriptorSetLayoutSupport = 1000168001, + SamplerYcbcrConversionCreateInfo = 1000156000, + SamplerYcbcrConversionInfo = 1000156001, + BindImagePlaneMemoryInfo = 1000156002, + ImagePlaneMemoryRequirementsInfo = 1000156003, + PhysicalDeviceSamplerYcbcrConversionFeatures = 1000156004, + SamplerYcbcrConversionImageFormatProperties = 1000156005, + DeviceGroupRenderPassBeginInfo = 1000060003, + PhysicalDevicePointClippingProperties = 1000117000, + RenderPassInputAttachmentAspectCreateInfo = 1000117001, + PipelineTessellationDomainOriginStateCreateInfo = 1000117003, + RenderPassMultiviewCreateInfo = 1000053000, + PhysicalDeviceMultiviewFeatures = 1000053001, + PhysicalDeviceMultiviewProperties = 1000053002, + PhysicalDeviceShaderDrawParametersFeatures = 1000063000, + PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures, + PhysicalDeviceVulkan1_1_Features = 49, + PhysicalDeviceVulkan1_1_Properties = 50, + PhysicalDeviceVulkan1_2_Features = 51, + PhysicalDeviceVulkan1_2_Properties = 52, + ImageFormatListCreateInfo = 1000147000, + PhysicalDeviceDriverProperties = 1000196000, + PhysicalDeviceVulkanMemoryModelFeatures = 1000211000, + PhysicalDeviceHostQueryResetFeatures = 1000261000, + PhysicalDeviceTimelineSemaphoreFeatures = 1000207000, + PhysicalDeviceTimelineSemaphoreProperties = 1000207001, + SemaphoreTypeCreateInfo = 1000207002, + TimelineSemaphoreSubmitInfo = 1000207003, + SemaphoreWaitInfo = 1000207004, + SemaphoreSignalInfo = 1000207005, + PhysicalDeviceBufferDeviceAddressFeatures = 1000257000, + BufferDeviceAddressInfo = 1000244001, + BufferOpaqueCaptureAddressCreateInfo = 1000257002, + MemoryOpaqueCaptureAddressAllocateInfo = 1000257003, + DeviceMemoryOpaqueCaptureAddressInfo = 1000257004, + PhysicalDevice8bitStorageFeatures = 1000177000, + PhysicalDeviceShaderAtomicInt64_Features = 1000180000, + PhysicalDeviceShaderFloat16_Int8_Features = 1000082000, + PhysicalDeviceFloatControlsProperties = 1000197000, + DescriptorSetLayoutBindingFlagsCreateInfo = 1000161000, + PhysicalDeviceDescriptorIndexingFeatures = 1000161001, + PhysicalDeviceDescriptorIndexingProperties = 1000161002, + DescriptorSetVariableDescriptorCountAllocateInfo = 1000161003, + DescriptorSetVariableDescriptorCountLayoutSupport = 1000161004, + PhysicalDeviceScalarBlockLayoutFeatures = 1000221000, + PhysicalDeviceSamplerFilterMinmaxProperties = 1000130000, + SamplerReductionModeCreateInfo = 1000130001, + PhysicalDeviceUniformBufferStandardLayoutFeatures = 1000253000, + PhysicalDeviceShaderSubgroupExtendedTypesFeatures = 1000175000, + AttachmentDescription2 = 1000109000, + AttachmentReference2 = 1000109001, + SubpassDescription2 = 1000109002, + SubpassDependency2 = 1000109003, + RenderPassCreateInfo2 = 1000109004, + SubpassBeginInfo = 1000109005, + SubpassEndInfo = 1000109006, + PhysicalDeviceDepthStencilResolveProperties = 1000199000, + SubpassDescriptionDepthStencilResolve = 1000199001, + ImageStencilUsageCreateInfo = 1000246000, + PhysicalDeviceImagelessFramebufferFeatures = 1000108000, + FramebufferAttachmentsCreateInfo = 1000108001, + FramebufferAttachmentImageInfo = 1000108002, + RenderPassAttachmentBeginInfo = 1000108003, + PhysicalDeviceSeparateDepthStencilLayoutsFeatures = 1000241000, + AttachmentReferenceStencilLayout = 1000241001, + AttachmentDescriptionStencilLayout = 1000241002, + PhysicalDeviceVulkan1_3_Features = 53, + PhysicalDeviceVulkan1_3_Properties = 54, + PhysicalDeviceToolProperties = 1000245000, + PhysicalDevicePrivateDataFeatures = 1000295000, + DevicePrivateDataCreateInfo = 1000295001, + PrivateDataSlotCreateInfo = 1000295002, + MemoryBarrier2 = 1000314000, + BufferMemoryBarrier2 = 1000314001, + ImageMemoryBarrier2 = 1000314002, + DependencyInfo = 1000314003, + SubmitInfo2 = 1000314004, + SemaphoreSubmitInfo = 1000314005, + CommandBufferSubmitInfo = 1000314006, + PhysicalDeviceSynchronization2_Features = 1000314007, + CopyBufferInfo2 = 1000337000, + CopyImageInfo2 = 1000337001, + CopyBufferToImageInfo2 = 1000337002, + CopyImageToBufferInfo2 = 1000337003, + BufferCopy2 = 1000337006, + ImageCopy2 = 1000337007, + BufferImageCopy2 = 1000337009, + PhysicalDeviceTextureCompressionAstcHdrFeatures = 1000066000, + FormatProperties3 = 1000360000, + PhysicalDeviceMaintenance4_Features = 1000413000, + PhysicalDeviceMaintenance4_Properties = 1000413001, + DeviceBufferMemoryRequirements = 1000413002, + DeviceImageMemoryRequirements = 1000413003, + PipelineCreationFeedbackCreateInfo = 1000192000, + PhysicalDeviceShaderTerminateInvocationFeatures = 1000215000, + PhysicalDeviceShaderDemoteToHelperInvocationFeatures = 1000276000, + PhysicalDevicePipelineCreationCacheControlFeatures = 1000297000, + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures = 1000325000, + PhysicalDeviceImageRobustnessFeatures = 1000335000, + PhysicalDeviceSubgroupSizeControlProperties = 1000225000, + PipelineShaderStageRequiredSubgroupSizeCreateInfo = 1000225001, + PhysicalDeviceSubgroupSizeControlFeatures = 1000225002, + PhysicalDeviceInlineUniformBlockFeatures = 1000138000, + PhysicalDeviceInlineUniformBlockProperties = 1000138001, + WriteDescriptorSetInlineUniformBlock = 1000138002, + DescriptorPoolInlineUniformBlockCreateInfo = 1000138003, + PhysicalDeviceShaderIntegerDotProductFeatures = 1000280000, + PhysicalDeviceShaderIntegerDotProductProperties = 1000280001, + PhysicalDeviceTexelBufferAlignmentProperties = 1000281001, + BlitImageInfo2 = 1000337004, + ResolveImageInfo2 = 1000337005, + ImageBlit2 = 1000337008, + ImageResolve2 = 1000337010, + RenderingInfo = 1000044000, + RenderingAttachmentInfo = 1000044001, + PipelineRenderingCreateInfo = 1000044002, + PhysicalDeviceDynamicRenderingFeatures = 1000044003, + CommandBufferInheritanceRenderingInfo = 1000044004, + PhysicalDeviceVulkan1_4_Features = 55, + PhysicalDeviceVulkan1_4_Properties = 56, + DeviceQueueGlobalPriorityCreateInfo = 1000174000, + PhysicalDeviceGlobalPriorityQueryFeatures = 1000388000, + QueueFamilyGlobalPriorityProperties = 1000388001, + PhysicalDeviceIndexTypeUint8_Features = 1000265000, + MemoryMapInfo = 1000271000, + MemoryUnmapInfo = 1000271001, + PhysicalDeviceMaintenance5_Features = 1000470000, + PhysicalDeviceMaintenance5_Properties = 1000470001, + DeviceImageSubresourceInfo = 1000470004, + SubresourceLayout2 = 1000338002, + ImageSubresource2 = 1000338003, + BufferUsageFlags2_CreateInfo = 1000470006, + PhysicalDeviceMaintenance6_Features = 1000545000, + PhysicalDeviceMaintenance6_Properties = 1000545001, + BindMemoryStatus = 1000545002, + PhysicalDeviceHostImageCopyFeatures = 1000270000, + PhysicalDeviceHostImageCopyProperties = 1000270001, + MemoryToImageCopy = 1000270002, + ImageToMemoryCopy = 1000270003, + CopyImageToMemoryInfo = 1000270004, + CopyMemoryToImageInfo = 1000270005, + HostImageLayoutTransitionInfo = 1000270006, + CopyImageToImageInfo = 1000270007, + SubresourceHostMemcpySize = 1000270008, + HostImageCopyDevicePerformanceQuery = 1000270009, + PhysicalDeviceShaderSubgroupRotateFeatures = 1000416000, + PhysicalDeviceShaderFloatControls2_Features = 1000528000, + PhysicalDeviceShaderExpectAssumeFeatures = 1000544000, + PipelineCreateFlags2_CreateInfo = 1000470005, + PhysicalDevicePushDescriptorProperties = 1000080000, + BindDescriptorSetsInfo = 1000545003, + PushConstantsInfo = 1000545004, + PushDescriptorSetInfo = 1000545005, + PushDescriptorSetWithTemplateInfo = 1000545006, + PhysicalDevicePipelineProtectedAccessFeatures = 1000466000, + PipelineRobustnessCreateInfo = 1000068000, + PhysicalDevicePipelineRobustnessFeatures = 1000068001, + PhysicalDevicePipelineRobustnessProperties = 1000068002, + PhysicalDeviceLineRasterizationFeatures = 1000259000, + PipelineRasterizationLineStateCreateInfo = 1000259001, + PhysicalDeviceLineRasterizationProperties = 1000259002, + PhysicalDeviceVertexAttributeDivisorProperties = 1000525000, + PipelineVertexInputDivisorStateCreateInfo = 1000190001, + PhysicalDeviceVertexAttributeDivisorFeatures = 1000190002, + RenderingAreaInfo = 1000470003, + PhysicalDeviceDynamicRenderingLocalReadFeatures = 1000232000, + RenderingAttachmentLocationInfo = 1000232001, + RenderingInputAttachmentIndexInfo = 1000232002, + SwapchainCreateInfoKHR = 1000001000, + PresentInfoKHR = 1000001001, + DeviceGroupPresentCapabilitiesKHR = 1000060007, + ImageSwapchainCreateInfoKHR = 1000060008, + BindImageMemorySwapchainInfoKHR = 1000060009, + AcquireNextImageInfoKHR = 1000060010, + DeviceGroupPresentInfoKHR = 1000060011, + DeviceGroupSwapchainCreateInfoKHR = 1000060012, + DisplayModeCreateInfoKHR = 1000002000, + DisplaySurfaceCreateInfoKHR = 1000002001, + DisplayPresentInfoKHR = 1000003000, + XlibSurfaceCreateInfoKHR = 1000004000, + XcbSurfaceCreateInfoKHR = 1000005000, + WaylandSurfaceCreateInfoKHR = 1000006000, + AndroidSurfaceCreateInfoKHR = 1000008000, + Win32_SurfaceCreateInfoKHR = 1000009000, + DebugReportCallbackCreateInfoEXT = 1000011000, + DebugReportCreateInfoEXT = DebugReportCallbackCreateInfoEXT, + PipelineRasterizationStateRasterizationOrderAMD = 1000018000, + DebugMarkerObjectNameInfoEXT = 1000022000, + DebugMarkerObjectTagInfoEXT = 1000022001, + DebugMarkerMarkerInfoEXT = 1000022002, + VideoProfileInfoKHR = 1000023000, + VideoCapabilitiesKHR = 1000023001, + VideoPictureResourceInfoKHR = 1000023002, + VideoSessionMemoryRequirementsKHR = 1000023003, + BindVideoSessionMemoryInfoKHR = 1000023004, + VideoSessionCreateInfoKHR = 1000023005, + VideoSessionParametersCreateInfoKHR = 1000023006, + VideoSessionParametersUpdateInfoKHR = 1000023007, + VideoBeginCodingInfoKHR = 1000023008, + VideoEndCodingInfoKHR = 1000023009, + VideoCodingControlInfoKHR = 1000023010, + VideoReferenceSlotInfoKHR = 1000023011, + QueueFamilyVideoPropertiesKHR = 1000023012, + VideoProfileListInfoKHR = 1000023013, + PhysicalDeviceVideoFormatInfoKHR = 1000023014, + VideoFormatPropertiesKHR = 1000023015, + QueueFamilyQueryResultStatusPropertiesKHR = 1000023016, + VideoDecodeInfoKHR = 1000024000, + VideoDecodeCapabilitiesKHR = 1000024001, + VideoDecodeUsageInfoKHR = 1000024002, + DedicatedAllocationImageCreateInfoNV = 1000026000, + DedicatedAllocationBufferCreateInfoNV = 1000026001, + DedicatedAllocationMemoryAllocateInfoNV = 1000026002, + PhysicalDeviceTransformFeedbackFeaturesEXT = 1000028000, + PhysicalDeviceTransformFeedbackPropertiesEXT = 1000028001, + PipelineRasterizationStateStreamCreateInfoEXT = 1000028002, + CuModuleCreateInfoNVX = 1000029000, + CuFunctionCreateInfoNVX = 1000029001, + CuLaunchInfoNVX = 1000029002, + CuModuleTexturingModeCreateInfoNVX = 1000029004, + ImageViewHandleInfoNVX = 1000030000, + ImageViewAddressPropertiesNVX = 1000030001, + VideoEncodeH264_CapabilitiesKHR = 1000038000, + VideoEncodeH264_SessionParametersCreateInfoKHR = 1000038001, + VideoEncodeH264_SessionParametersAddInfoKHR = 1000038002, + VideoEncodeH264_PictureInfoKHR = 1000038003, + VideoEncodeH264_DpbSlotInfoKHR = 1000038004, + VideoEncodeH264_NaluSliceInfoKHR = 1000038005, + VideoEncodeH264_GopRemainingFrameInfoKHR = 1000038006, + VideoEncodeH264_ProfileInfoKHR = 1000038007, + VideoEncodeH264_RateControlInfoKHR = 1000038008, + VideoEncodeH264_RateControlLayerInfoKHR = 1000038009, + VideoEncodeH264_SessionCreateInfoKHR = 1000038010, + VideoEncodeH264_QualityLevelPropertiesKHR = 1000038011, + VideoEncodeH264_SessionParametersGetInfoKHR = 1000038012, + VideoEncodeH264_SessionParametersFeedbackInfoKHR = 1000038013, + VideoEncodeH265_CapabilitiesKHR = 1000039000, + VideoEncodeH265_SessionParametersCreateInfoKHR = 1000039001, + VideoEncodeH265_SessionParametersAddInfoKHR = 1000039002, + VideoEncodeH265_PictureInfoKHR = 1000039003, + VideoEncodeH265_DpbSlotInfoKHR = 1000039004, + VideoEncodeH265_NaluSliceSegmentInfoKHR = 1000039005, + VideoEncodeH265_GopRemainingFrameInfoKHR = 1000039006, + VideoEncodeH265_ProfileInfoKHR = 1000039007, + VideoEncodeH265_RateControlInfoKHR = 1000039009, + VideoEncodeH265_RateControlLayerInfoKHR = 1000039010, + VideoEncodeH265_SessionCreateInfoKHR = 1000039011, + VideoEncodeH265_QualityLevelPropertiesKHR = 1000039012, + VideoEncodeH265_SessionParametersGetInfoKHR = 1000039013, + VideoEncodeH265_SessionParametersFeedbackInfoKHR = 1000039014, + VideoDecodeH264_CapabilitiesKHR = 1000040000, + VideoDecodeH264_PictureInfoKHR = 1000040001, + VideoDecodeH264_ProfileInfoKHR = 1000040003, + VideoDecodeH264_SessionParametersCreateInfoKHR = 1000040004, + VideoDecodeH264_SessionParametersAddInfoKHR = 1000040005, + VideoDecodeH264_DpbSlotInfoKHR = 1000040006, + TextureLodGatherFormatPropertiesAMD = 1000041000, + RenderingInfoKHR = RenderingInfo, + RenderingAttachmentInfoKHR = RenderingAttachmentInfo, + PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo, + PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures, + CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo, + StreamDescriptorSurfaceCreateInfoGGP = 1000049000, + PhysicalDeviceCornerSampledImageFeaturesNV = 1000050000, + RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo, + PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures, + PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties, + ExternalMemoryImageCreateInfoNV = 1000056000, + ExportMemoryAllocateInfoNV = 1000056001, + ImportMemoryWin32_HandleInfoNV = 1000057000, + ExportMemoryWin32_HandleInfoNV = 1000057001, + Win32_KeyedMutexAcquireReleaseInfoNV = 1000058000, + PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2, + PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2, + FormatProperties2KHR = FormatProperties2, + ImageFormatProperties2KHR = ImageFormatProperties2, + PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2, + QueueFamilyProperties2KHR = QueueFamilyProperties2, + PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2, + SparseImageFormatProperties2KHR = SparseImageFormatProperties2, + PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2, + MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo, + DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo, + DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo, + DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo, + DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo, + BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo, + BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo, + ValidationFlagsEXT = 1000061000, + ViSurfaceCreateInfoNN = 1000062000, + PhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = PhysicalDeviceTextureCompressionAstcHdrFeatures, + ImageViewAstcDecodeModeEXT = 1000067000, + PhysicalDeviceAstcDecodeFeaturesEXT = 1000067001, + PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo, + PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures, + PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties, + PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties, + DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo, + PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo, + ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties, + PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo, + ExternalBufferPropertiesKHR = ExternalBufferProperties, + PhysicalDeviceIdPropertiesKHR = PhysicalDeviceIdProperties, + ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo, + ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo, + ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo, + ImportMemoryWin32_HandleInfoKHR = 1000073000, + ExportMemoryWin32_HandleInfoKHR = 1000073001, + MemoryWin32_HandlePropertiesKHR = 1000073002, + MemoryGetWin32_HandleInfoKHR = 1000073003, + ImportMemoryFdInfoKHR = 1000074000, + MemoryFdPropertiesKHR = 1000074001, + MemoryGetFdInfoKHR = 1000074002, + Win32_KeyedMutexAcquireReleaseInfoKHR = 1000075000, + PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo, + ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties, + ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo, + ImportSemaphoreWin32_HandleInfoKHR = 1000078000, + ExportSemaphoreWin32_HandleInfoKHR = 1000078001, + D3d12_FenceSubmitInfoKHR = 1000078002, + SemaphoreGetWin32_HandleInfoKHR = 1000078003, + ImportSemaphoreFdInfoKHR = 1000079000, + SemaphoreGetFdInfoKHR = 1000079001, + PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties, + CommandBufferInheritanceConditionalRenderingInfoEXT = 1000081000, + PhysicalDeviceConditionalRenderingFeaturesEXT = 1000081001, + ConditionalRenderingBeginInfoEXT = 1000081002, + PhysicalDeviceShaderFloat16_Int8_FeaturesKHR = PhysicalDeviceShaderFloat16_Int8_Features, + PhysicalDeviceFloat16_Int8_FeaturesKHR = PhysicalDeviceShaderFloat16_Int8_Features, + PhysicalDevice16bitStorageFeaturesKHR = PhysicalDevice16bitStorageFeatures, + PresentRegionsKHR = 1000084000, + DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo, + PipelineViewportWScalingStateCreateInfoNV = 1000087000, + SurfaceCapabilities2EXT = 1000090000, + DisplayPowerInfoEXT = 1000091000, + DeviceEventInfoEXT = 1000091001, + DisplayEventInfoEXT = 1000091002, + SwapchainCounterCreateInfoEXT = 1000091003, + PresentTimesInfoGOOGLE = 1000092000, + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = 1000097000, + MultiviewPerViewAttributesInfoNVX = 1000044009, + PipelineViewportSwizzleStateCreateInfoNV = 1000098000, + PhysicalDeviceDiscardRectanglePropertiesEXT = 1000099000, + PipelineDiscardRectangleStateCreateInfoEXT = 1000099001, + PhysicalDeviceConservativeRasterizationPropertiesEXT = 1000101000, + PipelineRasterizationConservativeStateCreateInfoEXT = 1000101001, + PhysicalDeviceDepthClipEnableFeaturesEXT = 1000102000, + PipelineRasterizationDepthClipStateCreateInfoEXT = 1000102001, + HdrMetadataEXT = 1000105000, + PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures, + FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo, + FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo, + RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo, + AttachmentDescription2KHR = AttachmentDescription2, + AttachmentReference2KHR = AttachmentReference2, + SubpassDescription2KHR = SubpassDescription2, + SubpassDependency2KHR = SubpassDependency2, + RenderPassCreateInfo2KHR = RenderPassCreateInfo2, + SubpassBeginInfoKHR = SubpassBeginInfo, + SubpassEndInfoKHR = SubpassEndInfo, + PhysicalDeviceRelaxedLineRasterizationFeaturesIMG = 1000110000, + SharedPresentSurfaceCapabilitiesKHR = 1000111000, + PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo, + ExternalFencePropertiesKHR = ExternalFenceProperties, + ExportFenceCreateInfoKHR = ExportFenceCreateInfo, + ImportFenceWin32_HandleInfoKHR = 1000114000, + ExportFenceWin32_HandleInfoKHR = 1000114001, + FenceGetWin32_HandleInfoKHR = 1000114002, + ImportFenceFdInfoKHR = 1000115000, + FenceGetFdInfoKHR = 1000115001, + PhysicalDevicePerformanceQueryFeaturesKHR = 1000116000, + PhysicalDevicePerformanceQueryPropertiesKHR = 1000116001, + QueryPoolPerformanceCreateInfoKHR = 1000116002, + PerformanceQuerySubmitInfoKHR = 1000116003, + AcquireProfilingLockInfoKHR = 1000116004, + PerformanceCounterKHR = 1000116005, + PerformanceCounterDescriptionKHR = 1000116006, + PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties, + RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo, + ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo, + PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo, + PhysicalDeviceSurfaceInfo2KHR = 1000119000, + SurfaceCapabilities2KHR = 1000119001, + SurfaceFormat2KHR = 1000119002, + PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures, + PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeaturesKHR, + DisplayProperties2KHR = 1000121000, + DisplayPlaneProperties2KHR = 1000121001, + DisplayModeProperties2KHR = 1000121002, + DisplayPlaneInfo2KHR = 1000121003, + DisplayPlaneCapabilities2KHR = 1000121004, + IosSurfaceCreateInfoMVK = 1000122000, + MacosSurfaceCreateInfoMVK = 1000123000, + MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements, + MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo, + DebugUtilsObjectNameInfoEXT = 1000128000, + DebugUtilsObjectTagInfoEXT = 1000128001, + DebugUtilsLabelEXT = 1000128002, + DebugUtilsMessengerCallbackDataEXT = 1000128003, + DebugUtilsMessengerCreateInfoEXT = 1000128004, + AndroidHardwareBufferUsageANDROID = 1000129000, + AndroidHardwareBufferPropertiesANDROID = 1000129001, + AndroidHardwareBufferFormatPropertiesANDROID = 1000129002, + ImportAndroidHardwareBufferInfoANDROID = 1000129003, + MemoryGetAndroidHardwareBufferInfoANDROID = 1000129004, + ExternalFormatANDROID = 1000129005, + AndroidHardwareBufferFormatProperties2ANDROID = 1000129006, + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties, + SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo, + PhysicalDeviceShaderEnqueueFeaturesAMDX = 1000134000, + PhysicalDeviceShaderEnqueuePropertiesAMDX = 1000134001, + ExecutionGraphPipelineScratchSizeAMDX = 1000134002, + ExecutionGraphPipelineCreateInfoAMDX = 1000134003, + PipelineShaderStageNodeCreateInfoAMDX = 1000134004, + AttachmentSampleCountInfoAMD = 1000044008, + PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures, + PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties, + WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock, + DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo, + PhysicalDeviceShaderBfloat16_FeaturesKHR = 1000141000, + SampleLocationsInfoEXT = 1000143000, + RenderPassSampleLocationsBeginInfoEXT = 1000143001, + PipelineSampleLocationsStateCreateInfoEXT = 1000143002, + PhysicalDeviceSampleLocationsPropertiesEXT = 1000143003, + MultisamplePropertiesEXT = 1000143004, + BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2, + ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2, + ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2, + MemoryRequirements2KHR = MemoryRequirements2, + SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2, + ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo, + PhysicalDeviceBlendOperationAdvancedFeaturesEXT = 1000148000, + PhysicalDeviceBlendOperationAdvancedPropertiesEXT = 1000148001, + PipelineColorBlendAdvancedStateCreateInfoEXT = 1000148002, + PipelineCoverageToColorStateCreateInfoNV = 1000149000, + WriteDescriptorSetAccelerationStructureKHR = 1000150007, + AccelerationStructureBuildGeometryInfoKHR = 1000150000, + AccelerationStructureDeviceAddressInfoKHR = 1000150002, + AccelerationStructureGeometryAabbsDataKHR = 1000150003, + AccelerationStructureGeometryInstancesDataKHR = 1000150004, + AccelerationStructureGeometryTrianglesDataKHR = 1000150005, + AccelerationStructureGeometryKHR = 1000150006, + AccelerationStructureVersionInfoKHR = 1000150009, + CopyAccelerationStructureInfoKHR = 1000150010, + CopyAccelerationStructureToMemoryInfoKHR = 1000150011, + CopyMemoryToAccelerationStructureInfoKHR = 1000150012, + PhysicalDeviceAccelerationStructureFeaturesKHR = 1000150013, + PhysicalDeviceAccelerationStructurePropertiesKHR = 1000150014, + AccelerationStructureCreateInfoKHR = 1000150017, + AccelerationStructureBuildSizesInfoKHR = 1000150020, + PhysicalDeviceRayTracingPipelineFeaturesKHR = 1000347000, + PhysicalDeviceRayTracingPipelinePropertiesKHR = 1000347001, + RayTracingPipelineCreateInfoKHR = 1000150015, + RayTracingShaderGroupCreateInfoKHR = 1000150016, + RayTracingPipelineInterfaceCreateInfoKHR = 1000150018, + PhysicalDeviceRayQueryFeaturesKHR = 1000348013, + PipelineCoverageModulationStateCreateInfoNV = 1000152000, + AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD, + PhysicalDeviceShaderSmBuiltinsFeaturesNV = 1000154000, + PhysicalDeviceShaderSmBuiltinsPropertiesNV = 1000154001, + SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo, + SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo, + BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo, + ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo, + PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures, + SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties, + BindBufferMemoryInfoKHR = BindBufferMemoryInfo, + BindImageMemoryInfoKHR = BindImageMemoryInfo, + DrmFormatModifierPropertiesListEXT = 1000158000, + PhysicalDeviceImageDrmFormatModifierInfoEXT = 1000158002, + ImageDrmFormatModifierListCreateInfoEXT = 1000158003, + ImageDrmFormatModifierExplicitCreateInfoEXT = 1000158004, + ImageDrmFormatModifierPropertiesEXT = 1000158005, + DrmFormatModifierPropertiesList2EXT = 1000158006, + ValidationCacheCreateInfoEXT = 1000160000, + ShaderModuleValidationCacheCreateInfoEXT = 1000160001, + DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo, + PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures, + PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties, + DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo, + DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport, + PhysicalDevicePortabilitySubsetFeaturesKHR = 1000163000, + PhysicalDevicePortabilitySubsetPropertiesKHR = 1000163001, + PipelineViewportShadingRateImageStateCreateInfoNV = 1000164000, + PhysicalDeviceShadingRateImageFeaturesNV = 1000164001, + PhysicalDeviceShadingRateImagePropertiesNV = 1000164002, + PipelineViewportCoarseSampleOrderStateCreateInfoNV = 1000164005, + RayTracingPipelineCreateInfoNV = 1000165000, + AccelerationStructureCreateInfoNV = 1000165001, + GeometryNV = 1000165003, + GeometryTrianglesNV = 1000165004, + GeometryAabbNV = 1000165005, + BindAccelerationStructureMemoryInfoNV = 1000165006, + WriteDescriptorSetAccelerationStructureNV = 1000165007, + AccelerationStructureMemoryRequirementsInfoNV = 1000165008, + PhysicalDeviceRayTracingPropertiesNV = 1000165009, + RayTracingShaderGroupCreateInfoNV = 1000165011, + AccelerationStructureInfoNV = 1000165012, + PhysicalDeviceRepresentativeFragmentTestFeaturesNV = 1000166000, + PipelineRepresentativeFragmentTestStateCreateInfoNV = 1000166001, + PhysicalDeviceMaintenance3_PropertiesKHR = PhysicalDeviceMaintenance3_Properties, + DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport, + PhysicalDeviceImageViewImageFormatInfoEXT = 1000170000, + FilterCubicImageViewImageFormatPropertiesEXT = 1000170001, + DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo, + PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures, + PhysicalDevice8bitStorageFeaturesKHR = PhysicalDevice8bitStorageFeatures, + ImportMemoryHostPointerInfoEXT = 1000178000, + MemoryHostPointerPropertiesEXT = 1000178001, + PhysicalDeviceExternalMemoryHostPropertiesEXT = 1000178002, + PhysicalDeviceShaderAtomicInt64_FeaturesKHR = PhysicalDeviceShaderAtomicInt64_Features, + PhysicalDeviceShaderClockFeaturesKHR = 1000181000, + PipelineCompilerControlCreateInfoAMD = 1000183000, + CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR, + PhysicalDeviceShaderCorePropertiesAMD = 1000185000, + VideoDecodeH265_CapabilitiesKHR = 1000187000, + VideoDecodeH265_SessionParametersCreateInfoKHR = 1000187001, + VideoDecodeH265_SessionParametersAddInfoKHR = 1000187002, + VideoDecodeH265_ProfileInfoKHR = 1000187003, + VideoDecodeH265_PictureInfoKHR = 1000187004, + VideoDecodeH265_DpbSlotInfoKHR = 1000187005, + DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo, + PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures, + QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties, + DeviceMemoryOverallocationCreateInfoAMD = 1000189000, + PhysicalDeviceVertexAttributeDivisorPropertiesEXT = 1000190000, + PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo, + PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures, + PresentFrameTokenGGP = 1000191000, + PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo, + PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties, + PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties, + PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties, + SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve, + PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR, + PhysicalDeviceMeshShaderFeaturesNV = 1000202000, + PhysicalDeviceMeshShaderPropertiesNV = 1000202001, + PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, + PhysicalDeviceShaderImageFootprintFeaturesNV = 1000204000, + PipelineViewportExclusiveScissorStateCreateInfoNV = 1000205000, + PhysicalDeviceExclusiveScissorFeaturesNV = 1000205002, + CheckpointDataNV = 1000206000, + QueueFamilyCheckpointPropertiesNV = 1000206001, + QueueFamilyCheckpointProperties2NV = 1000314008, + CheckpointData2NV = 1000314009, + PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures, + PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties, + SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo, + TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo, + SemaphoreWaitInfoKHR = SemaphoreWaitInfo, + SemaphoreSignalInfoKHR = SemaphoreSignalInfo, + PhysicalDevicePresentTimingFeaturesEXT = 1000208000, + SwapchainTimingPropertiesEXT = 1000208001, + SwapchainTimeDomainPropertiesEXT = 1000208002, + PresentTimingsInfoEXT = 1000208003, + PresentTimingInfoEXT = 1000208004, + PastPresentationTimingInfoEXT = 1000208005, + PastPresentationTimingPropertiesEXT = 1000208006, + PastPresentationTimingEXT = 1000208007, + PresentTimingSurfaceCapabilitiesEXT = 1000208008, + SwapchainCalibratedTimestampInfoEXT = 1000208009, + PhysicalDeviceShaderIntegerFunctions2_FeaturesINTEL = 1000209000, + QueryPoolPerformanceQueryCreateInfoINTEL = 1000210000, + QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL, + InitializePerformanceApiInfoINTEL = 1000210001, + PerformanceMarkerInfoINTEL = 1000210002, + PerformanceStreamMarkerInfoINTEL = 1000210003, + PerformanceOverrideInfoINTEL = 1000210004, + PerformanceConfigurationAcquireInfoINTEL = 1000210005, + PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures, + PhysicalDevicePciBusInfoPropertiesEXT = 1000212000, + DisplayNativeHdrSurfaceCapabilitiesAMD = 1000213000, + SwapchainDisplayNativeHdrCreateInfoAMD = 1000213001, + ImagepipeSurfaceCreateInfoFUCHSIA = 1000214000, + PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures, + MetalSurfaceCreateInfoEXT = 1000217000, + PhysicalDeviceFragmentDensityMapFeaturesEXT = 1000218000, + PhysicalDeviceFragmentDensityMapPropertiesEXT = 1000218001, + RenderPassFragmentDensityMapCreateInfoEXT = 1000218002, + RenderingFragmentDensityMapAttachmentInfoEXT = 1000044007, + PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures, + PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties, + PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo, + PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures, + FragmentShadingRateAttachmentInfoKHR = 1000226000, + PipelineFragmentShadingRateStateCreateInfoKHR = 1000226001, + PhysicalDeviceFragmentShadingRatePropertiesKHR = 1000226002, + PhysicalDeviceFragmentShadingRateFeaturesKHR = 1000226003, + PhysicalDeviceFragmentShadingRateKHR = 1000226004, + RenderingFragmentShadingRateAttachmentInfoKHR = 1000044006, + PhysicalDeviceShaderCoreProperties2AMD = 1000227000, + PhysicalDeviceCoherentMemoryFeaturesAMD = 1000229000, + PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures, + RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo, + RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo, + PhysicalDeviceShaderImageAtomicInt64_FeaturesEXT = 1000234000, + PhysicalDeviceShaderQuadControlFeaturesKHR = 1000235000, + PhysicalDeviceMemoryBudgetPropertiesEXT = 1000237000, + PhysicalDeviceMemoryPriorityFeaturesEXT = 1000238000, + MemoryPriorityAllocateInfoEXT = 1000238001, + SurfaceProtectedCapabilitiesKHR = 1000239000, + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = 1000240000, + PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures, + AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout, + AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout, + PhysicalDeviceBufferDeviceAddressFeaturesEXT = 1000244000, + PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT, + BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo, + BufferDeviceAddressCreateInfoEXT = 1000244002, + PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties, + ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo, + ValidationFeaturesEXT = 1000247000, + PhysicalDevicePresentWaitFeaturesKHR = 1000248000, + PhysicalDeviceCooperativeMatrixFeaturesNV = 1000249000, + CooperativeMatrixPropertiesNV = 1000249001, + PhysicalDeviceCooperativeMatrixPropertiesNV = 1000249002, + PhysicalDeviceCoverageReductionModeFeaturesNV = 1000250000, + PipelineCoverageReductionStateCreateInfoNV = 1000250001, + FramebufferMixedSamplesCombinationNV = 1000250002, + PhysicalDeviceFragmentShaderInterlockFeaturesEXT = 1000251000, + PhysicalDeviceYcbcrImageArraysFeaturesEXT = 1000252000, + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures, + PhysicalDeviceProvokingVertexFeaturesEXT = 1000254000, + PipelineRasterizationProvokingVertexStateCreateInfoEXT = 1000254001, + PhysicalDeviceProvokingVertexPropertiesEXT = 1000254002, + SurfaceFullScreenExclusiveInfoEXT = 1000255000, + SurfaceCapabilitiesFullScreenExclusiveEXT = 1000255002, + SurfaceFullScreenExclusiveWin32_InfoEXT = 1000255001, + HeadlessSurfaceCreateInfoEXT = 1000256000, + PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures, + BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo, + BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo, + MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo, + DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo, + PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures, + PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo, + PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties, + PhysicalDeviceShaderAtomicFloatFeaturesEXT = 1000260000, + PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures, + PhysicalDeviceIndexTypeUint8_FeaturesEXT = PhysicalDeviceIndexTypeUint8_Features, + PhysicalDeviceExtendedDynamicStateFeaturesEXT = 1000267000, // Not promoted to 1.3 + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR = 1000269000, + PipelineInfoKHR = 1000269001, + PipelineExecutablePropertiesKHR = 1000269002, + PipelineExecutableInfoKHR = 1000269003, + PipelineExecutableStatisticKHR = 1000269004, + PipelineExecutableInternalRepresentationKHR = 1000269005, + PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures, + PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties, + MemoryToImageCopyEXT = MemoryToImageCopy, + ImageToMemoryCopyEXT = ImageToMemoryCopy, + CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo, + CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo, + HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo, + CopyImageToImageInfoEXT = CopyImageToImageInfo, + SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize, + HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery, + MemoryMapInfoKHR = MemoryMapInfo, + MemoryUnmapInfoKHR = MemoryUnmapInfo, + PhysicalDeviceMapMemoryPlacedFeaturesEXT = 1000272000, + PhysicalDeviceMapMemoryPlacedPropertiesEXT = 1000272001, + MemoryMapPlacedInfoEXT = 1000272002, + PhysicalDeviceShaderAtomicFloat2_FeaturesEXT = 1000273000, + SurfacePresentModeEXT = SurfacePresentModeKHR, + SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR, + SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR, + PhysicalDeviceSwapchainMaintenance1_FeaturesEXT = PhysicalDeviceSwapchainMaintenance1_FeaturesKHR, + SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR, + SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR, + SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR, + SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR, + ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR, + PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures, + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV = 1000277000, + GraphicsShaderGroupCreateInfoNV = 1000277001, + GraphicsPipelineShaderGroupsCreateInfoNV = 1000277002, + IndirectCommandsLayoutTokenNV = 1000277003, + IndirectCommandsLayoutCreateInfoNV = 1000277004, + GeneratedCommandsInfoNV = 1000277005, + GeneratedCommandsMemoryRequirementsInfoNV = 1000277006, + PhysicalDeviceDeviceGeneratedCommandsFeaturesNV = 1000277007, + PhysicalDeviceInheritedViewportScissorFeaturesNV = 1000278000, + CommandBufferInheritanceViewportScissorInfoNV = 1000278001, + PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures, + PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties, + PhysicalDeviceTexelBufferAlignmentFeaturesEXT = 1000281000, // Not promoted to 1.3 + PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties, + CommandBufferInheritanceRenderPassTransformInfoQCOM = 1000282000, + RenderPassTransformBeginInfoQCOM = 1000282001, + PhysicalDeviceDepthBiasControlFeaturesEXT = 1000283000, + DepthBiasInfoEXT = 1000283001, + DepthBiasRepresentationInfoEXT = 1000283002, + PhysicalDeviceDeviceMemoryReportFeaturesEXT = 1000284000, + DeviceDeviceMemoryReportCreateInfoEXT = 1000284001, + DeviceMemoryReportCallbackDataEXT = 1000284002, + PhysicalDeviceRobustness2_FeaturesEXT = PhysicalDeviceRobustness2_FeaturesKHR, + PhysicalDeviceRobustness2_PropertiesEXT = PhysicalDeviceRobustness2_PropertiesKHR, + SamplerCustomBorderColorCreateInfoEXT = 1000287000, + PhysicalDeviceCustomBorderColorPropertiesEXT = 1000287001, + PhysicalDeviceCustomBorderColorFeaturesEXT = 1000287002, + PipelineLibraryCreateInfoKHR = 1000290000, + PhysicalDevicePresentBarrierFeaturesNV = 1000292000, + SurfaceCapabilitiesPresentBarrierNV = 1000292001, + SwapchainPresentBarrierCreateInfoNV = 1000292002, + PresentIdKHR = 1000294000, + PhysicalDevicePresentIdFeaturesKHR = 1000294001, + PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures, + DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo, + PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo, + PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures, + VideoEncodeInfoKHR = 1000299000, + VideoEncodeRateControlInfoKHR = 1000299001, + VideoEncodeRateControlLayerInfoKHR = 1000299002, + VideoEncodeCapabilitiesKHR = 1000299003, + VideoEncodeUsageInfoKHR = 1000299004, + QueryPoolVideoEncodeFeedbackCreateInfoKHR = 1000299005, + PhysicalDeviceVideoEncodeQualityLevelInfoKHR = 1000299006, + VideoEncodeQualityLevelPropertiesKHR = 1000299007, + VideoEncodeQualityLevelInfoKHR = 1000299008, + VideoEncodeSessionParametersGetInfoKHR = 1000299009, + VideoEncodeSessionParametersFeedbackInfoKHR = 1000299010, + PhysicalDeviceDiagnosticsConfigFeaturesNV = 1000300000, + DeviceDiagnosticsConfigCreateInfoNV = 1000300001, + CudaModuleCreateInfoNV = 1000307000, + CudaFunctionCreateInfoNV = 1000307001, + CudaLaunchInfoNV = 1000307002, + PhysicalDeviceCudaKernelLaunchFeaturesNV = 1000307003, + PhysicalDeviceCudaKernelLaunchPropertiesNV = 1000307004, + PhysicalDeviceTileShadingFeaturesQCOM = 1000309000, + PhysicalDeviceTileShadingPropertiesQCOM = 1000309001, + RenderPassTileShadingCreateInfoQCOM = 1000309002, + PerTileBeginInfoQCOM = 1000309003, + PerTileEndInfoQCOM = 1000309004, + DispatchTileInfoQCOM = 1000309005, + QueryLowLatencySupportNV = 1000310000, + ExportMetalObjectCreateInfoEXT = 1000311000, + ExportMetalObjectsInfoEXT = 1000311001, + ExportMetalDeviceInfoEXT = 1000311002, + ExportMetalCommandQueueInfoEXT = 1000311003, + ExportMetalBufferInfoEXT = 1000311004, + ImportMetalBufferInfoEXT = 1000311005, + ExportMetalTextureInfoEXT = 1000311006, + ImportMetalTextureInfoEXT = 1000311007, + ExportMetalIoSurfaceInfoEXT = 1000311008, + ImportMetalIoSurfaceInfoEXT = 1000311009, + ExportMetalSharedEventInfoEXT = 1000311010, + ImportMetalSharedEventInfoEXT = 1000311011, + MemoryBarrier2KHR = MemoryBarrier2, + BufferMemoryBarrier2KHR = BufferMemoryBarrier2, + ImageMemoryBarrier2KHR = ImageMemoryBarrier2, + DependencyInfoKHR = DependencyInfo, + SubmitInfo2KHR = SubmitInfo2, + SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo, + CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo, + PhysicalDeviceSynchronization2_FeaturesKHR = PhysicalDeviceSynchronization2_Features, + PhysicalDeviceDescriptorBufferPropertiesEXT = 1000316000, + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT = 1000316001, + PhysicalDeviceDescriptorBufferFeaturesEXT = 1000316002, + DescriptorAddressInfoEXT = 1000316003, + DescriptorGetInfoEXT = 1000316004, + BufferCaptureDescriptorDataInfoEXT = 1000316005, + ImageCaptureDescriptorDataInfoEXT = 1000316006, + ImageViewCaptureDescriptorDataInfoEXT = 1000316007, + SamplerCaptureDescriptorDataInfoEXT = 1000316008, + OpaqueCaptureDescriptorDataCreateInfoEXT = 1000316010, + DescriptorBufferBindingInfoEXT = 1000316011, + DescriptorBufferBindingPushDescriptorBufferHandleEXT = 1000316012, + AccelerationStructureCaptureDescriptorDataInfoEXT = 1000316009, + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT = 1000320000, + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT = 1000320001, + GraphicsPipelineLibraryCreateInfoEXT = 1000320002, + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD = 1000321000, + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR = 1000203000, + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR = 1000322000, + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR = 1000323000, + PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV = 1000326000, + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV = 1000326001, + PipelineFragmentShadingRateEnumStateCreateInfoNV = 1000326002, + AccelerationStructureGeometryMotionTrianglesDataNV = 1000327000, + PhysicalDeviceRayTracingMotionBlurFeaturesNV = 1000327001, + AccelerationStructureMotionInfoNV = 1000327002, + PhysicalDeviceMeshShaderFeaturesEXT = 1000328000, + PhysicalDeviceMeshShaderPropertiesEXT = 1000328001, + PhysicalDeviceYcbcr2_Plane444_FormatsFeaturesEXT = 1000330000, + PhysicalDeviceFragmentDensityMap2_FeaturesEXT = 1000332000, + PhysicalDeviceFragmentDensityMap2_PropertiesEXT = 1000332001, + CopyCommandTransformInfoQCOM = 1000333000, + PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures, + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR = 1000336000, + CopyBufferInfo2KHR = CopyBufferInfo2, + CopyImageInfo2KHR = CopyImageInfo2, + CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2, + CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2, + BlitImageInfo2KHR = BlitImageInfo2, + ResolveImageInfo2KHR = ResolveImageInfo2, + BufferCopy2KHR = BufferCopy2, + ImageCopy2KHR = ImageCopy2, + ImageBlit2KHR = ImageBlit2, + BufferImageCopy2KHR = BufferImageCopy2, + ImageResolve2KHR = ImageResolve2, + PhysicalDeviceImageCompressionControlFeaturesEXT = 1000338000, + ImageCompressionControlEXT = 1000338001, + SubresourceLayout2EXT = SubresourceLayout2, + ImageSubresource2EXT = ImageSubresource2, + ImageCompressionPropertiesEXT = 1000338004, + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT = 1000339000, + PhysicalDevice4444_FormatsFeaturesEXT = 1000340000, + PhysicalDeviceFaultFeaturesEXT = 1000341000, + DeviceFaultCountsEXT = 1000341001, + DeviceFaultInfoEXT = 1000341002, + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, + PhysicalDeviceRgba10x6_FormatsFeaturesEXT = 1000344000, + DirectfbSurfaceCreateInfoEXT = 1000346000, + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT, + MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT, + PhysicalDeviceVertexInputDynamicStateFeaturesEXT = 1000352000, + VertexInputBindingDescription2EXT = 1000352001, + VertexInputAttributeDescription2EXT = 1000352002, + PhysicalDeviceDrmPropertiesEXT = 1000353000, + PhysicalDeviceAddressBindingReportFeaturesEXT = 1000354000, + DeviceAddressBindingCallbackDataEXT = 1000354001, + PhysicalDeviceDepthClipControlFeaturesEXT = 1000355000, + PipelineViewportDepthClipControlCreateInfoEXT = 1000355001, + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT = 1000356000, + FormatProperties3KHR = FormatProperties3, + PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, + ImportMemoryZirconHandleInfoFUCHSIA = 1000364000, + MemoryZirconHandlePropertiesFUCHSIA = 1000364001, + MemoryGetZirconHandleInfoFUCHSIA = 1000364002, + ImportSemaphoreZirconHandleInfoFUCHSIA = 1000365000, + SemaphoreGetZirconHandleInfoFUCHSIA = 1000365001, + BufferCollectionCreateInfoFUCHSIA = 1000366000, + ImportMemoryBufferCollectionFUCHSIA = 1000366001, + BufferCollectionImageCreateInfoFUCHSIA = 1000366002, + BufferCollectionPropertiesFUCHSIA = 1000366003, + BufferConstraintsInfoFUCHSIA = 1000366004, + BufferCollectionBufferCreateInfoFUCHSIA = 1000366005, + ImageConstraintsInfoFUCHSIA = 1000366006, + ImageFormatConstraintsInfoFUCHSIA = 1000366007, + SysmemColorSpaceFUCHSIA = 1000366008, + BufferCollectionConstraintsInfoFUCHSIA = 1000366009, + SubpassShadingPipelineCreateInfoHUAWEI = 1000369000, + PhysicalDeviceSubpassShadingFeaturesHUAWEI = 1000369001, + PhysicalDeviceSubpassShadingPropertiesHUAWEI = 1000369002, + PhysicalDeviceInvocationMaskFeaturesHUAWEI = 1000370000, + MemoryGetRemoteAddressInfoNV = 1000371000, + PhysicalDeviceExternalMemoryRdmaFeaturesNV = 1000371001, + PipelinePropertiesIdentifierEXT = 1000372000, + PhysicalDevicePipelinePropertiesFeaturesEXT = 1000372001, + PipelineInfoEXT = PipelineInfoKHR, + PhysicalDeviceFrameBoundaryFeaturesEXT = 1000375000, + FrameBoundaryEXT = 1000375001, + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = 1000376000, + SubpassResolvePerformanceQueryEXT = 1000376001, + MultisampledRenderToSingleSampledInfoEXT = 1000376002, + PhysicalDeviceExtendedDynamicState2_FeaturesEXT = 1000377000, // Not promoted to 1.3 + ScreenSurfaceCreateInfoQNX = 1000378000, + PhysicalDeviceColorWriteEnableFeaturesEXT = 1000381000, + PipelineColorWriteCreateInfoEXT = 1000381001, + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = 1000382000, + PhysicalDeviceRayTracingMaintenance1_FeaturesKHR = 1000386000, + PhysicalDeviceShaderUntypedPointersFeaturesKHR = 1000387000, + PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures, + QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties, + PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE = 1000390000, + VideoEncodeRgbConversionCapabilitiesVALVE = 1000390001, + VideoEncodeProfileRgbConversionInfoVALVE = 1000390002, + VideoEncodeSessionRgbConversionCreateInfoVALVE = 1000390003, + PhysicalDeviceImageViewMinLodFeaturesEXT = 1000391000, + ImageViewMinLodCreateInfoEXT = 1000391001, + PhysicalDeviceMultiDrawFeaturesEXT = 1000392000, + PhysicalDeviceMultiDrawPropertiesEXT = 1000392001, + PhysicalDeviceImage2dViewOf3dFeaturesEXT = 1000393000, + PhysicalDeviceShaderTileImageFeaturesEXT = 1000395000, + PhysicalDeviceShaderTileImagePropertiesEXT = 1000395001, + MicromapBuildInfoEXT = 1000396000, + MicromapVersionInfoEXT = 1000396001, + CopyMicromapInfoEXT = 1000396002, + CopyMicromapToMemoryInfoEXT = 1000396003, + CopyMemoryToMicromapInfoEXT = 1000396004, + PhysicalDeviceOpacityMicromapFeaturesEXT = 1000396005, + PhysicalDeviceOpacityMicromapPropertiesEXT = 1000396006, + MicromapCreateInfoEXT = 1000396007, + MicromapBuildSizesInfoEXT = 1000396008, + AccelerationStructureTrianglesOpacityMicromapEXT = 1000396009, + PhysicalDeviceDisplacementMicromapFeaturesNV = 1000397000, + PhysicalDeviceDisplacementMicromapPropertiesNV = 1000397001, + AccelerationStructureTrianglesDisplacementMicromapNV = 1000397002, + PhysicalDeviceClusterCullingShaderFeaturesHUAWEI = 1000404000, + PhysicalDeviceClusterCullingShaderPropertiesHUAWEI = 1000404001, + PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI = 1000404002, + PhysicalDeviceBorderColorSwizzleFeaturesEXT = 1000411000, + SamplerBorderColorComponentMappingCreateInfoEXT = 1000411001, + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT = 1000412000, + PhysicalDeviceMaintenance4_FeaturesKHR = PhysicalDeviceMaintenance4_Features, + PhysicalDeviceMaintenance4_PropertiesKHR = PhysicalDeviceMaintenance4_Properties, + DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements, + DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements, + PhysicalDeviceShaderCorePropertiesARM = 1000415000, + PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures, + DeviceQueueShaderCoreControlCreateInfoARM = 1000417000, + PhysicalDeviceSchedulingControlsFeaturesARM = 1000417001, + PhysicalDeviceSchedulingControlsPropertiesARM = 1000417002, + PhysicalDeviceImageSlicedViewOf3dFeaturesEXT = 1000418000, + ImageViewSlicedCreateInfoEXT = 1000418001, + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = 1000420000, + DescriptorSetBindingReferenceVALVE = 1000420001, + DescriptorSetLayoutHostMappingInfoVALVE = 1000420002, + PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR, + PhysicalDeviceNonSeamlessCubeMapFeaturesEXT = 1000422000, + PhysicalDeviceRenderPassStripedFeaturesARM = 1000424000, + PhysicalDeviceRenderPassStripedPropertiesARM = 1000424001, + RenderPassStripeBeginInfoARM = 1000424002, + RenderPassStripeInfoARM = 1000424003, + RenderPassStripeSubmitInfoARM = 1000424004, + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, + SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT, + PhysicalDeviceCopyMemoryIndirectFeaturesNV = 1000426000, + PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR, + PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT, + PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT, + PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV = 1000428000, + ComputePipelineIndirectBufferInfoNV = 1000428001, + PipelineIndirectDeviceAddressInfoNV = 1000428002, + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV = 1000429008, + AccelerationStructureGeometryLinearSweptSpheresDataNV = 1000429009, + AccelerationStructureGeometrySpheresDataNV = 1000429010, + PhysicalDeviceLinearColorAttachmentFeaturesNV = 1000430000, + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR = 1000434000, + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT = 1000437000, + PhysicalDeviceImageProcessingFeaturesQCOM = 1000440000, + PhysicalDeviceImageProcessingPropertiesQCOM = 1000440001, + ImageViewSampleWeightCreateInfoQCOM = 1000440002, + PhysicalDeviceNestedCommandBufferFeaturesEXT = 1000451000, + PhysicalDeviceNestedCommandBufferPropertiesEXT = 1000451001, + NativeBufferUsageOHOS = 1000452000, + NativeBufferPropertiesOHOS = 1000452001, + NativeBufferFormatPropertiesOHOS = 1000452002, + ImportNativeBufferInfoOHOS = 1000452003, + MemoryGetNativeBufferInfoOHOS = 1000452004, + ExternalFormatOHOS = 1000452005, + ExternalMemoryAcquireUnmodifiedEXT = 1000453000, + PhysicalDeviceExtendedDynamicState3_FeaturesEXT = 1000455000, + PhysicalDeviceExtendedDynamicState3_PropertiesEXT = 1000455001, + PhysicalDeviceSubpassMergeFeedbackFeaturesEXT = 1000458000, + RenderPassCreationControlEXT = 1000458001, + RenderPassCreationFeedbackCreateInfoEXT = 1000458002, + RenderPassSubpassFeedbackCreateInfoEXT = 1000458003, + DirectDriverLoadingInfoLUNARG = 1000459000, + DirectDriverLoadingListLUNARG = 1000459001, + TensorCreateInfoARM = 1000460000, + TensorViewCreateInfoARM = 1000460001, + BindTensorMemoryInfoARM = 1000460002, + WriteDescriptorSetTensorARM = 1000460003, + PhysicalDeviceTensorPropertiesARM = 1000460004, + TensorFormatPropertiesARM = 1000460005, + TensorDescriptionARM = 1000460006, + TensorMemoryRequirementsInfoARM = 1000460007, + TensorMemoryBarrierARM = 1000460008, + PhysicalDeviceTensorFeaturesARM = 1000460009, + DeviceTensorMemoryRequirementsARM = 1000460010, + CopyTensorInfoARM = 1000460011, + TensorCopyARM = 1000460012, + TensorDependencyInfoARM = 1000460013, + MemoryDedicatedAllocateInfoTensorARM = 1000460014, + PhysicalDeviceExternalTensorInfoARM = 1000460015, + ExternalTensorPropertiesARM = 1000460016, + ExternalMemoryTensorCreateInfoARM = 1000460017, + PhysicalDeviceDescriptorBufferTensorFeaturesARM = 1000460018, + PhysicalDeviceDescriptorBufferTensorPropertiesARM = 1000460019, + DescriptorGetTensorInfoARM = 1000460020, + TensorCaptureDescriptorDataInfoARM = 1000460021, + TensorViewCaptureDescriptorDataInfoARM = 1000460022, + FrameBoundaryTensorsARM = 1000460023, + PhysicalDeviceShaderModuleIdentifierFeaturesEXT = 1000462000, + PhysicalDeviceShaderModuleIdentifierPropertiesEXT = 1000462001, + PipelineShaderStageModuleIdentifierCreateInfoEXT = 1000462002, + ShaderModuleIdentifierEXT = 1000462003, + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT = 1000342000, + PhysicalDeviceOpticalFlowFeaturesNV = 1000464000, + PhysicalDeviceOpticalFlowPropertiesNV = 1000464001, + OpticalFlowImageFormatInfoNV = 1000464002, + OpticalFlowImageFormatPropertiesNV = 1000464003, + OpticalFlowSessionCreateInfoNV = 1000464004, + OpticalFlowExecuteInfoNV = 1000464005, + OpticalFlowSessionCreatePrivateDataInfoNV = 1000464010, + PhysicalDeviceLegacyDitheringFeaturesEXT = 1000465000, + PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures, + PhysicalDeviceExternalFormatResolveFeaturesANDROID = 1000468000, + PhysicalDeviceExternalFormatResolvePropertiesANDROID = 1000468001, + AndroidHardwareBufferFormatResolvePropertiesANDROID = 1000468002, + PhysicalDeviceMaintenance5_FeaturesKHR = PhysicalDeviceMaintenance5_Features, + PhysicalDeviceMaintenance5_PropertiesKHR = PhysicalDeviceMaintenance5_Properties, + RenderingAreaInfoKHR = RenderingAreaInfo, + DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo, + SubresourceLayout2KHR = SubresourceLayout2, + ImageSubresource2KHR = ImageSubresource2, + PipelineCreateFlags2_CreateInfoKHR = PipelineCreateFlags2_CreateInfo, + BufferUsageFlags2_CreateInfoKHR = BufferUsageFlags2_CreateInfo, + PhysicalDeviceAntiLagFeaturesAMD = 1000476000, + AntiLagDataAMD = 1000476001, + AntiLagPresentationInfoAMD = 1000476002, + PhysicalDeviceDenseGeometryFormatFeaturesAMDX = 1000478000, + AccelerationStructureDenseGeometryFormatTrianglesDataAMDX = 1000478001, + SurfaceCapabilitiesPresentId2KHR = 1000479000, + PresentId2KHR = 1000479001, + PhysicalDevicePresentId2_FeaturesKHR = 1000479002, + SurfaceCapabilitiesPresentWait2KHR = 1000480000, + PhysicalDevicePresentWait2_FeaturesKHR = 1000480001, + PresentWait2_InfoKHR = 1000480002, + PhysicalDeviceRayTracingPositionFetchFeaturesKHR = 1000481000, + PhysicalDeviceShaderObjectFeaturesEXT = 1000482000, + PhysicalDeviceShaderObjectPropertiesEXT = 1000482001, + ShaderCreateInfoEXT = 1000482002, + ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo, + PhysicalDevicePipelineBinaryFeaturesKHR = 1000483000, + PipelineBinaryCreateInfoKHR = 1000483001, + PipelineBinaryInfoKHR = 1000483002, + PipelineBinaryKeyKHR = 1000483003, + PhysicalDevicePipelineBinaryPropertiesKHR = 1000483004, + ReleaseCapturedPipelineDataInfoKHR = 1000483005, + PipelineBinaryDataInfoKHR = 1000483006, + PipelineCreateInfoKHR = 1000483007, + DevicePipelineBinaryInternalCacheControlKHR = 1000483008, + PipelineBinaryHandlesInfoKHR = 1000483009, + PhysicalDeviceTilePropertiesFeaturesQCOM = 1000484000, + TilePropertiesQCOM = 1000484001, + PhysicalDeviceAmigoProfilingFeaturesSEC = 1000485000, + AmigoProfilingSubmitInfoSEC = 1000485001, + SurfacePresentModeKHR = 1000274000, + SurfacePresentScalingCapabilitiesKHR = 1000274001, + SurfacePresentModeCompatibilityKHR = 1000274002, + PhysicalDeviceSwapchainMaintenance1_FeaturesKHR = 1000275000, + SwapchainPresentFenceInfoKHR = 1000275001, + SwapchainPresentModesCreateInfoKHR = 1000275002, + SwapchainPresentModeInfoKHR = 1000275003, + SwapchainPresentScalingCreateInfoKHR = 1000275004, + ReleaseSwapchainImagesInfoKHR = 1000275005, + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM = 1000488000, + PhysicalDeviceRayTracingInvocationReorderFeaturesNV = 1000490000, + PhysicalDeviceRayTracingInvocationReorderPropertiesNV = 1000490001, + PhysicalDeviceCooperativeVectorFeaturesNV = 1000491000, + PhysicalDeviceCooperativeVectorPropertiesNV = 1000491001, + CooperativeVectorPropertiesNV = 1000491002, + ConvertCooperativeVectorMatrixInfoNV = 1000491004, + PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV = 1000492000, + PhysicalDeviceExtendedSparseAddressSpacePropertiesNV = 1000492001, + PhysicalDeviceMutableDescriptorTypeFeaturesEXT = 1000351000, + MutableDescriptorTypeCreateInfoEXT = 1000351002, + PhysicalDeviceLegacyVertexAttributesFeaturesEXT = 1000495000, + PhysicalDeviceLegacyVertexAttributesPropertiesEXT = 1000495001, + LayerSettingsCreateInfoEXT = 1000496000, + PhysicalDeviceShaderCoreBuiltinsFeaturesARM = 1000497000, + PhysicalDeviceShaderCoreBuiltinsPropertiesARM = 1000497001, + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = 1000498000, + PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = 1000499000, + LatencySleepModeInfoNV = 1000505000, + LatencySleepInfoNV = 1000505001, + SetLatencyMarkerInfoNV = 1000505002, + GetLatencyMarkerInfoNV = 1000505003, + LatencyTimingsFrameReportNV = 1000505004, + LatencySubmissionPresentIdNV = 1000505005, + OutOfBandQueueTypeInfoNV = 1000505006, + SwapchainLatencyCreateInfoNV = 1000505007, + LatencySurfaceCapabilitiesNV = 1000505008, + PhysicalDeviceCooperativeMatrixFeaturesKHR = 1000506000, + CooperativeMatrixPropertiesKHR = 1000506001, + PhysicalDeviceCooperativeMatrixPropertiesKHR = 1000506002, + DataGraphPipelineCreateInfoARM = 1000507000, + DataGraphPipelineSessionCreateInfoARM = 1000507001, + DataGraphPipelineResourceInfoARM = 1000507002, + DataGraphPipelineConstantARM = 1000507003, + DataGraphPipelineSessionMemoryRequirementsInfoARM = 1000507004, + BindDataGraphPipelineSessionMemoryInfoARM = 1000507005, + PhysicalDeviceDataGraphFeaturesARM = 1000507006, + DataGraphPipelineShaderModuleCreateInfoARM = 1000507007, + DataGraphPipelinePropertyQueryResultARM = 1000507008, + DataGraphPipelineInfoARM = 1000507009, + DataGraphPipelineCompilerControlCreateInfoARM = 1000507010, + DataGraphPipelineSessionBindPointRequirementsInfoARM = 1000507011, + DataGraphPipelineSessionBindPointRequirementARM = 1000507012, + DataGraphPipelineIdentifierCreateInfoARM = 1000507013, + DataGraphPipelineDispatchInfoARM = 1000507014, + DataGraphProcessingEngineCreateInfoARM = 1000507016, + QueueFamilyDataGraphProcessingEnginePropertiesARM = 1000507017, + QueueFamilyDataGraphPropertiesARM = 1000507018, + PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM = 1000507019, + DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM = 1000507015, + PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = 1000510000, + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = 1000510001, + PhysicalDeviceComputeShaderDerivativesFeaturesKHR = 1000201000, + PhysicalDeviceComputeShaderDerivativesPropertiesKHR = 1000511000, + VideoDecodeAv1_CapabilitiesKHR = 1000512000, + VideoDecodeAv1_PictureInfoKHR = 1000512001, + VideoDecodeAv1_ProfileInfoKHR = 1000512003, + VideoDecodeAv1_SessionParametersCreateInfoKHR = 1000512004, + VideoDecodeAv1_DpbSlotInfoKHR = 1000512005, + VideoEncodeAv1_CapabilitiesKHR = 1000513000, + VideoEncodeAv1_SessionParametersCreateInfoKHR = 1000513001, + VideoEncodeAv1_PictureInfoKHR = 1000513002, + VideoEncodeAv1_DpbSlotInfoKHR = 1000513003, + PhysicalDeviceVideoEncodeAv1_FeaturesKHR = 1000513004, + VideoEncodeAv1_ProfileInfoKHR = 1000513005, + VideoEncodeAv1_RateControlInfoKHR = 1000513006, + VideoEncodeAv1_RateControlLayerInfoKHR = 1000513007, + VideoEncodeAv1_QualityLevelPropertiesKHR = 1000513008, + VideoEncodeAv1_SessionCreateInfoKHR = 1000513009, + VideoEncodeAv1_GopRemainingFrameInfoKHR = 1000513010, + PhysicalDeviceVideoDecodeVp9_FeaturesKHR = 1000514000, + VideoDecodeVp9_CapabilitiesKHR = 1000514001, + VideoDecodeVp9_PictureInfoKHR = 1000514002, + VideoDecodeVp9_ProfileInfoKHR = 1000514003, + PhysicalDeviceVideoMaintenance1_FeaturesKHR = 1000515000, + VideoInlineQueryInfoKHR = 1000515001, + PhysicalDevicePerStageDescriptorSetFeaturesNV = 1000516000, + PhysicalDeviceImageProcessing2_FeaturesQCOM = 1000518000, + PhysicalDeviceImageProcessing2_PropertiesQCOM = 1000518001, + SamplerBlockMatchWindowCreateInfoQCOM = 1000518002, + SamplerCubicWeightsCreateInfoQCOM = 1000519000, + PhysicalDeviceCubicWeightsFeaturesQCOM = 1000519001, + BlitImageCubicWeightsInfoQCOM = 1000519002, + PhysicalDeviceYcbcrDegammaFeaturesQCOM = 1000520000, + SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = 1000520001, + PhysicalDeviceCubicClampFeaturesQCOM = 1000521000, + PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = 1000524000, + PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties, + PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo, + PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures, + PhysicalDeviceUnifiedImageLayoutsFeaturesKHR = 1000527000, + AttachmentFeedbackLoopInfoEXT = 1000527001, + PhysicalDeviceShaderFloatControls2_FeaturesKHR = PhysicalDeviceShaderFloatControls2_Features, + ScreenBufferPropertiesQNX = 1000529000, + ScreenBufferFormatPropertiesQNX = 1000529001, + ImportScreenBufferInfoQNX = 1000529002, + ExternalFormatQNX = 1000529003, + PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = 1000529004, + PhysicalDeviceLayeredDriverPropertiesMSFT = 1000530000, + PhysicalDeviceIndexTypeUint8_FeaturesKHR = PhysicalDeviceIndexTypeUint8_Features, + PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures, + PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo, + PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties, + CalibratedTimestampInfoKHR = 1000184000, + PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures, + PhysicalDeviceMaintenance6_FeaturesKHR = PhysicalDeviceMaintenance6_Features, + PhysicalDeviceMaintenance6_PropertiesKHR = PhysicalDeviceMaintenance6_Properties, + BindMemoryStatusKHR = BindMemoryStatus, + BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo, + PushConstantsInfoKHR = PushConstantsInfo, + PushDescriptorSetInfoKHR = PushDescriptorSetInfo, + PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo, + SetDescriptorBufferOffsetsInfoEXT = 1000545007, + BindDescriptorBufferEmbeddedSamplersInfoEXT = 1000545008, + PhysicalDeviceDescriptorPoolOverallocationFeaturesNV = 1000546000, + PhysicalDeviceTileMemoryHeapFeaturesQCOM = 1000547000, + PhysicalDeviceTileMemoryHeapPropertiesQCOM = 1000547001, + TileMemoryRequirementsQCOM = 1000547002, + TileMemoryBindInfoQCOM = 1000547003, + TileMemorySizeInfoQCOM = 1000547004, + PhysicalDeviceCopyMemoryIndirectFeaturesKHR = 1000549000, + PhysicalDeviceCopyMemoryIndirectPropertiesKHR = 1000426001, + CopyMemoryIndirectInfoKHR = 1000549002, + CopyMemoryToImageIndirectInfoKHR = 1000549003, + PhysicalDeviceMemoryDecompressionFeaturesEXT = 1000427000, + PhysicalDeviceMemoryDecompressionPropertiesEXT = 1000427001, + DecompressMemoryInfoEXT = 1000550002, + DisplaySurfaceStereoCreateInfoNV = 1000551000, + DisplayModeStereoPropertiesNV = 1000551001, + VideoEncodeIntraRefreshCapabilitiesKHR = 1000552000, + VideoEncodeSessionIntraRefreshCreateInfoKHR = 1000552001, + VideoEncodeIntraRefreshInfoKHR = 1000552002, + VideoReferenceIntraRefreshInfoKHR = 1000552003, + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR = 1000552004, + VideoEncodeQuantizationMapCapabilitiesKHR = 1000553000, + VideoFormatQuantizationMapPropertiesKHR = 1000553001, + VideoEncodeQuantizationMapInfoKHR = 1000553002, + VideoEncodeQuantizationMapSessionParametersCreateInfoKHR = 1000553005, + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR = 1000553009, + VideoEncodeH264_QuantizationMapCapabilitiesKHR = 1000553003, + VideoEncodeH265_QuantizationMapCapabilitiesKHR = 1000553004, + VideoFormatH265_QuantizationMapPropertiesKHR = 1000553006, + VideoEncodeAv1_QuantizationMapCapabilitiesKHR = 1000553007, + VideoFormatAv1_QuantizationMapPropertiesKHR = 1000553008, + PhysicalDeviceRawAccessChainsFeaturesNV = 1000555000, + ExternalComputeQueueDeviceCreateInfoNV = 1000556000, + ExternalComputeQueueCreateInfoNV = 1000556001, + ExternalComputeQueueDataParamsNV = 1000556002, + PhysicalDeviceExternalComputeQueuePropertiesNV = 1000556003, + PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = 1000558000, + PhysicalDeviceCommandBufferInheritanceFeaturesNV = 1000559000, + PhysicalDeviceMaintenance7_FeaturesKHR = 1000562000, + PhysicalDeviceMaintenance7_PropertiesKHR = 1000562001, + PhysicalDeviceLayeredApiPropertiesListKHR = 1000562002, + PhysicalDeviceLayeredApiPropertiesKHR = 1000562003, + PhysicalDeviceLayeredApiVulkanPropertiesKHR = 1000562004, + PhysicalDeviceShaderAtomicFloat16_VectorFeaturesNV = 1000563000, + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT = 1000564000, + PhysicalDeviceShaderFloat8_FeaturesEXT = 1000567000, + PhysicalDeviceRayTracingValidationFeaturesNV = 1000568000, + PhysicalDeviceClusterAccelerationStructureFeaturesNV = 1000569000, + PhysicalDeviceClusterAccelerationStructurePropertiesNV = 1000569001, + ClusterAccelerationStructureClustersBottomLevelInputNV = 1000569002, + ClusterAccelerationStructureTriangleClusterInputNV = 1000569003, + ClusterAccelerationStructureMoveObjectsInputNV = 1000569004, + ClusterAccelerationStructureInputInfoNV = 1000569005, + ClusterAccelerationStructureCommandsInfoNV = 1000569006, + RayTracingPipelineClusterAccelerationStructureCreateInfoNV = 1000569007, + PhysicalDevicePartitionedAccelerationStructureFeaturesNV = 1000570000, + PhysicalDevicePartitionedAccelerationStructurePropertiesNV = 1000570001, + WriteDescriptorSetPartitionedAccelerationStructureNV = 1000570002, + PartitionedAccelerationStructureInstancesInputNV = 1000570003, + BuildPartitionedAccelerationStructureInfoNV = 1000570004, + PartitionedAccelerationStructureFlagsNV = 1000570005, + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT = 1000572000, + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT = 1000572001, + GeneratedCommandsMemoryRequirementsInfoEXT = 1000572002, + IndirectExecutionSetCreateInfoEXT = 1000572003, + GeneratedCommandsInfoEXT = 1000572004, + IndirectCommandsLayoutCreateInfoEXT = 1000572006, + IndirectCommandsLayoutTokenEXT = 1000572007, + WriteIndirectExecutionSetPipelineEXT = 1000572008, + WriteIndirectExecutionSetShaderEXT = 1000572009, + IndirectExecutionSetPipelineInfoEXT = 1000572010, + IndirectExecutionSetShaderInfoEXT = 1000572011, + IndirectExecutionSetShaderLayoutInfoEXT = 1000572012, + GeneratedCommandsPipelineInfoEXT = 1000572013, + GeneratedCommandsShaderInfoEXT = 1000572014, + PhysicalDeviceMaintenance8_FeaturesKHR = 1000574000, + MemoryBarrierAccessFlags3KHR = 1000574002, + PhysicalDeviceImageAlignmentControlFeaturesMESA = 1000575000, + PhysicalDeviceImageAlignmentControlPropertiesMESA = 1000575001, + ImageAlignmentControlCreateInfoMESA = 1000575002, + PhysicalDeviceShaderFmaFeaturesKHR = 1000579000, + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT = 1000581000, + PhysicalDeviceRayTracingInvocationReorderPropertiesEXT = 1000581001, + PhysicalDeviceDepthClampControlFeaturesEXT = 1000582000, + PipelineViewportDepthClampControlCreateInfoEXT = 1000582001, + PhysicalDeviceMaintenance9_FeaturesKHR = 1000584000, + PhysicalDeviceMaintenance9_PropertiesKHR = 1000584001, + QueueFamilyOwnershipTransferPropertiesKHR = 1000584002, + PhysicalDeviceVideoMaintenance2_FeaturesKHR = 1000586000, + VideoDecodeH264_InlineSessionParametersInfoKHR = 1000586001, + VideoDecodeH265_InlineSessionParametersInfoKHR = 1000586002, + VideoDecodeAv1_InlineSessionParametersInfoKHR = 1000586003, + SurfaceCreateInfoOHOS = 1000685000, + NativeBufferOHOS = 1000453001, + SwapchainImageCreateInfoOHOS = 1000453002, + PhysicalDevicePresentationPropertiesOHOS = 1000453003, + PhysicalDeviceHdrVividFeaturesHUAWEI = 1000590000, + HdrVividDynamicMetadataHUAWEI = 1000590001, + PhysicalDeviceCooperativeMatrix2_FeaturesNV = 1000593000, + CooperativeMatrixFlexibleDimensionsPropertiesNV = 1000593001, + PhysicalDeviceCooperativeMatrix2_PropertiesNV = 1000593002, + PhysicalDevicePipelineOpacityMicromapFeaturesARM = 1000596000, + ImportMemoryMetalHandleInfoEXT = 1000602000, + MemoryMetalHandlePropertiesEXT = 1000602001, + MemoryGetMetalHandleInfoEXT = 1000602002, + PhysicalDeviceDepthClampZeroOneFeaturesKHR = 1000421000, + PhysicalDevicePerformanceCountersByRegionFeaturesARM = 1000605000, + PhysicalDevicePerformanceCountersByRegionPropertiesARM = 1000605001, + PerformanceCounterARM = 1000605002, + PerformanceCounterDescriptionARM = 1000605003, + RenderPassPerformanceCountersByRegionBeginInfoARM = 1000605004, + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT = 1000608000, + PhysicalDeviceFormatPackFeaturesARM = 1000609000, + PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE = 1000611000, + PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE = 1000611001, + PipelineFragmentDensityMapLayeredCreateInfoVALVE = 1000611002, + PhysicalDeviceRobustness2_FeaturesKHR = 1000286000, + PhysicalDeviceRobustness2_PropertiesKHR = 1000286001, + SetPresentConfigNV = 1000613000, + PhysicalDevicePresentMeteringFeaturesNV = 1000613001, + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT = 1000425000, + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT = 1000425001, + RenderPassFragmentDensityMapOffsetEndInfoEXT = 1000425002, + RenderingEndInfoEXT = RenderingEndInfoKHR, + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT = 1000620000, + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR = 1000361000, + PhysicalDeviceShader64_BitIndexingFeaturesEXT = 1000627000, + PhysicalDeviceCustomResolveFeaturesEXT = 1000628000, + BeginCustomResolveInfoEXT = 1000628001, + CustomResolveCreateInfoEXT = 1000628002, + PhysicalDeviceDataGraphModelFeaturesQCOM = 1000629000, + DataGraphPipelineBuiltinModelCreateInfoQCOM = 1000629001, + PhysicalDeviceMaintenance10_FeaturesKHR = 1000630000, + PhysicalDeviceMaintenance10_PropertiesKHR = 1000630001, + RenderingAttachmentFlagsInfoKHR = 1000630002, + RenderingEndInfoKHR = 1000619003, + ResolveImageModeInfoKHR = 1000630004, + PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = 1000637000, + PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT = 1000642000, +} + +// API constants +static { public const uint32 VK_FALSE = 0; } +static { public const float VK_LOD_CLAMP_NONE = 1000.0F; } +static { public const uint32 VK_QUEUE_FAMILY_IGNORED = (~0U); } +static { public const uint32 VK_REMAINING_ARRAY_LAYERS = (~0U); } +static { public const uint32 VK_REMAINING_MIP_LEVELS = (~0U); } +static { public const uint32 VK_TRUE = 1; } +static { public const uint64 VK_WHOLE_SIZE = (~0UL); } +static { public const uint32 VK_MAX_MEMORY_TYPES = 32; } +static { public const uint32 VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; } +static { public const uint32 VK_UUID_SIZE = 16; } +static { public const uint32 VK_MAX_EXTENSION_NAME_SIZE = 256; } +static { public const uint32 VK_MAX_DESCRIPTION_SIZE = 256; } +// The maximum number of unique memory heaps, each of which supporting 1 or more memory types +static { public const uint32 VK_MAX_MEMORY_HEAPS = 16; } + +// These types are part of the API, though not directly used in API commands or data structures +[CRepr] struct VkBaseInStructure : this() +{ + public VkStructureType sType = default; + public VkBaseInStructure* pNext = null; + + public this(VkStructureType sType, VkBaseInStructure* pNext = null) : this() + { + this.sType = sType; + this.pNext = pNext; + } +} + +[CRepr] struct VkBaseOutStructure : this() +{ + public VkStructureType sType = default; + public VkBaseOutStructure* pNext = null; + + public this(VkStructureType sType, VkBaseOutStructure* pNext = null) : this() + { + this.sType = sType; + this.pNext = pNext; + } +} + +[CRepr] struct VkBufferMemoryBarrier : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccessFlags srcAccessMask = default; // Memory accesses from the source of the dependency to synchronize + public VkAccessFlags dstAccessMask = default; // Memory accesses from the destination of the dependency to synchronize + public uint32 srcQueueFamilyIndex = 0; // Queue family to transition ownership from + public uint32 dstQueueFamilyIndex = 0; // Queue family to transition ownership to + public VkBuffer buffer = null; // Buffer to sync + public VkDeviceSize offset = default; // Offset within the buffer to sync + public VkDeviceSize size = default; // Amount of bytes to sync + + public this(void* pNext, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, uint32 srcQueueFamilyIndex, uint32 dstQueueFamilyIndex, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.srcAccessMask = srcAccessMask; + this.dstAccessMask = dstAccessMask; + this.srcQueueFamilyIndex = srcQueueFamilyIndex; + this.dstQueueFamilyIndex = dstQueueFamilyIndex; + this.buffer = buffer; + this.offset = offset; + this.size = size; + } +} + +[CRepr] struct VkImageMemoryBarrier : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccessFlags srcAccessMask = default; // Memory accesses from the source of the dependency to synchronize + public VkAccessFlags dstAccessMask = default; // Memory accesses from the destination of the dependency to synchronize + public VkImageLayout oldLayout = default; // Current layout of the image + public VkImageLayout newLayout = default; // New layout to transition the image to + public uint32 srcQueueFamilyIndex = 0; // Queue family to transition ownership from + public uint32 dstQueueFamilyIndex = 0; // Queue family to transition ownership to + public VkImage image = null; // Image to sync + public VkImageSubresourceRange subresourceRange = default; // Subresource range to sync + + public this(void* pNext, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, uint32 srcQueueFamilyIndex, uint32 dstQueueFamilyIndex, VkImage image, VkImageSubresourceRange subresourceRange) : this() + { + this.pNext = pNext; + this.srcAccessMask = srcAccessMask; + this.dstAccessMask = dstAccessMask; + this.oldLayout = oldLayout; + this.newLayout = newLayout; + this.srcQueueFamilyIndex = srcQueueFamilyIndex; + this.dstQueueFamilyIndex = dstQueueFamilyIndex; + this.image = image; + this.subresourceRange = subresourceRange; + } +} + +[CRepr] struct VkMemoryBarrier : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_BARRIER; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccessFlags srcAccessMask = default; // Memory accesses from the source of the dependency to synchronize + public VkAccessFlags dstAccessMask = default; // Memory accesses from the destination of the dependency to synchronize + + public this(void* pNext = null, VkAccessFlags srcAccessMask = default, VkAccessFlags dstAccessMask = default) : this() + { + this.pNext = pNext; + this.srcAccessMask = srcAccessMask; + this.dstAccessMask = dstAccessMask; + } +} + +[AllowDuplicates] enum VkObjectType : int32 +{ + [NoShow] VK_OBJECT_TYPE_UNKNOWN = 0, + [NoShow] VK_OBJECT_TYPE_INSTANCE = 1, + [NoShow] VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + [NoShow] VK_OBJECT_TYPE_DEVICE = 3, + [NoShow] VK_OBJECT_TYPE_QUEUE = 4, + [NoShow] VK_OBJECT_TYPE_SEMAPHORE = 5, + [NoShow] VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + [NoShow] VK_OBJECT_TYPE_FENCE = 7, + [NoShow] VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + [NoShow] VK_OBJECT_TYPE_BUFFER = 9, + [NoShow] VK_OBJECT_TYPE_IMAGE = 10, + [NoShow] VK_OBJECT_TYPE_EVENT = 11, + [NoShow] VK_OBJECT_TYPE_QUERY_POOL = 12, + [NoShow] VK_OBJECT_TYPE_BUFFER_VIEW = 13, + [NoShow] VK_OBJECT_TYPE_IMAGE_VIEW = 14, + [NoShow] VK_OBJECT_TYPE_SHADER_MODULE = 15, + [NoShow] VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + [NoShow] VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + [NoShow] VK_OBJECT_TYPE_RENDER_PASS = 18, + [NoShow] VK_OBJECT_TYPE_PIPELINE = 19, + [NoShow] VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + [NoShow] VK_OBJECT_TYPE_SAMPLER = 21, + [NoShow] VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + [NoShow] VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + [NoShow] VK_OBJECT_TYPE_FRAMEBUFFER = 24, + [NoShow] VK_OBJECT_TYPE_COMMAND_POOL = 25, + [NoShow] VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + [NoShow] VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + [NoShow] VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + [NoShow] VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + [NoShow] VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + [NoShow] VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + [NoShow] VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + [NoShow] VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + [NoShow] VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, // VkVideoSessionKHR + [NoShow] VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, // VkVideoSessionParametersKHR + [NoShow] VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, + [NoShow] VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, + [NoShow] VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + [NoShow] VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + [NoShow] VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + [NoShow] VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + [NoShow] VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + [NoShow] VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + [NoShow] VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, + [NoShow] VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, + [NoShow] VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, + [NoShow] VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + [NoShow] VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, + [NoShow] VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, + [NoShow] VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, // VkBufferCollectionFUCHSIA + [NoShow] VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + [NoShow] VK_OBJECT_TYPE_TENSOR_ARM = 1000460000, + [NoShow] VK_OBJECT_TYPE_TENSOR_VIEW_ARM = 1000460001, + [NoShow] VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + [NoShow] VK_OBJECT_TYPE_SHADER_EXT = 1000482000, + [NoShow] VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + [NoShow] VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000, + [NoShow] VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, + [NoShow] VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, + [NoShow] VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, + // pretty names + Unknown = 0, + Instance = 1, + PhysicalDevice = 2, + Device = 3, + Queue = 4, + Semaphore = 5, + CommandBuffer = 6, + Fence = 7, + DeviceMemory = 8, + Buffer = 9, + Image = 10, + Event = 11, + QueryPool = 12, + BufferView = 13, + ImageView = 14, + ShaderModule = 15, + PipelineCache = 16, + PipelineLayout = 17, + RenderPass = 18, + Pipeline = 19, + DescriptorSetLayout = 20, + Sampler = 21, + DescriptorPool = 22, + DescriptorSet = 23, + Framebuffer = 24, + CommandPool = 25, + DescriptorUpdateTemplate = 1000085000, + SamplerYcbcrConversion = 1000156000, + PrivateDataSlot = 1000295000, + SurfaceKHR = 1000000000, + SwapchainKHR = 1000001000, + DisplayKHR = 1000002000, + DisplayModeKHR = 1000002001, + DebugReportCallbackEXT = 1000011000, + VideoSessionKHR = 1000023000, // VkVideoSessionKHR + VideoSessionParametersKHR = 1000023001, // VkVideoSessionParametersKHR + CuModuleNVX = 1000029000, + CuFunctionNVX = 1000029001, + DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate, + DebugUtilsMessengerEXT = 1000128000, + AccelerationStructureKHR = 1000150000, + SamplerYcbcrConversionKHR = SamplerYcbcrConversion, + ValidationCacheEXT = 1000160000, + AccelerationStructureNV = 1000165000, + PerformanceConfigurationINTEL = 1000210000, + DeferredOperationKHR = 1000268000, + IndirectCommandsLayoutNV = 1000277000, + PrivateDataSlotEXT = PrivateDataSlot, + CudaModuleNV = 1000307000, + CudaFunctionNV = 1000307001, + BufferCollectionFUCHSIA = 1000366000, // VkBufferCollectionFUCHSIA + MicromapEXT = 1000396000, + TensorARM = 1000460000, + TensorViewARM = 1000460001, + OpticalFlowSessionNV = 1000464000, + ShaderEXT = 1000482000, + PipelineBinaryKHR = 1000483000, + DataGraphPipelineSessionARM = 1000507000, + ExternalComputeQueueNV = 1000556000, + IndirectCommandsLayoutEXT = 1000572000, + IndirectExecutionSetEXT = 1000572001, +} + +[AllowDuplicates] enum VkVendorId : int32 +{ + [NoShow] VK_VENDOR_ID_KHRONOS = 0x10000, // Khronos vendor ID + [NoShow] VK_VENDOR_ID_VIV = 0x10001, // Vivante vendor ID + [NoShow] VK_VENDOR_ID_VSI = 0x10002, // VeriSilicon vendor ID + [NoShow] VK_VENDOR_ID_KAZAN = 0x10003, // Kazan Software Renderer + [NoShow] VK_VENDOR_ID_CODEPLAY = 0x10004, // Codeplay Software Ltd. vendor ID + [NoShow] VK_VENDOR_ID_MESA = 0x10005, // Mesa vendor ID + [NoShow] VK_VENDOR_ID_POCL = 0x10006, // PoCL vendor ID + [NoShow] VK_VENDOR_ID_MOBILEYE = 0x10007, // Mobileye vendor ID + // pretty names + Khronos = 0x10000, // Khronos vendor ID + VkVendorIdVIV = 0x10001, // Vivante vendor ID + VkVendorIdVSI = 0x10002, // VeriSilicon vendor ID + Kazan = 0x10003, // Kazan Software Renderer + Codeplay = 0x10004, // Codeplay Software Ltd. vendor ID + VkVendorIdMESA = 0x10005, // Mesa vendor ID + Pocl = 0x10006, // PoCL vendor ID + Mobileye = 0x10007, // Mobileye vendor ID +} + +// API version macros +//static { public const let VK_API_VERSION = VK_MAKE_API_VERSION(0, 1, 0, 0) ; }// Patch version should always be set to 0 +// Version of this file +static { public const let VK_HEADER_VERSION = 335; } +// Complete version of this file +static { public const let VK_HEADER_VERSION_COMPLETE = VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION); } +static { public static uint32 VK_MAKE_VERSION(uint32 major, uint32 minor, uint32 patch) => + ((((uint32)(major)) << 22U) | (((uint32)(minor)) << 12U) | ((uint32)(patch))); } +static { public static uint32 VK_VERSION_MAJOR(uint32 version) => ((uint32)(version) >> 22U); } +static { public static uint32 VK_VERSION_MINOR(uint32 version) => (((uint32)(version) >> 12U) & 0x3FFU); } +static { public static uint32 VK_VERSION_PATCH(uint32 version) => ((uint32)(version) & 0xFFFU); } +static { public static uint32 VK_MAKE_API_VERSION(uint32 variant, uint32 major, uint32 minor, uint32 patch) => + ((((uint32)(variant)) << 29U) | (((uint32)(major)) << 22U) | (((uint32)(minor)) << 12U) | ((uint32)(patch))); } +static { public static uint32 VK_API_VERSION_VARIANT(uint32 version) => ((uint32)(version) >> 29U); } +static { public static uint32 VK_API_VERSION_MAJOR(uint32 version) => (((uint32)(version) >> 22U) & 0x7FU); } +static { public static uint32 VK_API_VERSION_MINOR(uint32 version) => (((uint32)(version) >> 12U) & 0x3FFU); } +static { public static uint32 VK_API_VERSION_PATCH(uint32 version) => ((uint32)(version) & 0xFFFU); } +// Vulkan 1.0 version number +static { public const let VK_API_VERSION_1_0 = VK_MAKE_API_VERSION(0, 1, 0, 0); }// Patch version should always be set to 0 + +// Device initialization +[CallingConvention(VKAPI_PTR)] function void* PFN_vkAllocationFunction( + void* pUserData, + c_size size, + c_size alignment, + VkSystemAllocationScope allocationScope); + +[CallingConvention(VKAPI_PTR)] function void PFN_vkFreeFunction( + void* pUserData, + void* pMemory); + +[CallingConvention(VKAPI_PTR)] function void PFN_vkInternalAllocationNotification( + void* pUserData, + c_size size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +[CallingConvention(VKAPI_PTR)] function void PFN_vkInternalFreeNotification( + void* pUserData, + c_size size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +[CallingConvention(VKAPI_PTR)] function void* PFN_vkReallocationFunction( + void* pUserData, + void* pOriginal, + c_size size, + c_size alignment, + VkSystemAllocationScope allocationScope); + +[CallingConvention(VKAPI_PTR)] function void PFN_vkVoidFunction(void); + +[CRepr] struct VkAllocationCallbacks : this() +{ + public void* pUserData = null; + public PFN_vkAllocationFunction pfnAllocation = default; + public PFN_vkReallocationFunction pfnReallocation = default; + public PFN_vkFreeFunction pfnFree = default; + public PFN_vkInternalAllocationNotification pfnInternalAllocation = default; + public PFN_vkInternalFreeNotification pfnInternalFree = default; + + public this(void* pUserData, PFN_vkAllocationFunction pfnAllocation, PFN_vkReallocationFunction pfnReallocation, PFN_vkFreeFunction pfnFree, PFN_vkInternalAllocationNotification pfnInternalAllocation = default, PFN_vkInternalFreeNotification pfnInternalFree = default) : this() + { + this.pUserData = pUserData; + this.pfnAllocation = pfnAllocation; + this.pfnReallocation = pfnReallocation; + this.pfnFree = pfnFree; + this.pfnInternalAllocation = pfnInternalAllocation; + this.pfnInternalFree = pfnInternalFree; + } +} + +[CRepr] struct VkApplicationInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_APPLICATION_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public char8* pApplicationName = null; + public uint32 applicationVersion = 0; + public char8* pEngineName = null; + public uint32 engineVersion = 0; + public uint32 apiVersion = 0; + + public this(void* pNext, char8* pApplicationName, uint32 applicationVersion, char8* pEngineName, uint32 engineVersion, uint32 apiVersion) : this() + { + this.pNext = pNext; + this.pApplicationName = pApplicationName; + this.applicationVersion = applicationVersion; + this.pEngineName = pEngineName; + this.engineVersion = engineVersion; + this.apiVersion = apiVersion; + } +} + +[AllowDuplicates] enum VkFormat : int32 +{ + [NoShow] VK_FORMAT_UNDEFINED = 0, + [NoShow] VK_FORMAT_R4G4_UNORM_PACK8 = 1, + [NoShow] VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + [NoShow] VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + [NoShow] VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + [NoShow] VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + [NoShow] VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + [NoShow] VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + [NoShow] VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + [NoShow] VK_FORMAT_R8_UNORM = 9, + [NoShow] VK_FORMAT_R8_SNORM = 10, + [NoShow] VK_FORMAT_R8_USCALED = 11, + [NoShow] VK_FORMAT_R8_SSCALED = 12, + [NoShow] VK_FORMAT_R8_UINT = 13, + [NoShow] VK_FORMAT_R8_SINT = 14, + [NoShow] VK_FORMAT_R8_SRGB = 15, + [NoShow] VK_FORMAT_R8G8_UNORM = 16, + [NoShow] VK_FORMAT_R8G8_SNORM = 17, + [NoShow] VK_FORMAT_R8G8_USCALED = 18, + [NoShow] VK_FORMAT_R8G8_SSCALED = 19, + [NoShow] VK_FORMAT_R8G8_UINT = 20, + [NoShow] VK_FORMAT_R8G8_SINT = 21, + [NoShow] VK_FORMAT_R8G8_SRGB = 22, + [NoShow] VK_FORMAT_R8G8B8_UNORM = 23, + [NoShow] VK_FORMAT_R8G8B8_SNORM = 24, + [NoShow] VK_FORMAT_R8G8B8_USCALED = 25, + [NoShow] VK_FORMAT_R8G8B8_SSCALED = 26, + [NoShow] VK_FORMAT_R8G8B8_UINT = 27, + [NoShow] VK_FORMAT_R8G8B8_SINT = 28, + [NoShow] VK_FORMAT_R8G8B8_SRGB = 29, + [NoShow] VK_FORMAT_B8G8R8_UNORM = 30, + [NoShow] VK_FORMAT_B8G8R8_SNORM = 31, + [NoShow] VK_FORMAT_B8G8R8_USCALED = 32, + [NoShow] VK_FORMAT_B8G8R8_SSCALED = 33, + [NoShow] VK_FORMAT_B8G8R8_UINT = 34, + [NoShow] VK_FORMAT_B8G8R8_SINT = 35, + [NoShow] VK_FORMAT_B8G8R8_SRGB = 36, + [NoShow] VK_FORMAT_R8G8B8A8_UNORM = 37, + [NoShow] VK_FORMAT_R8G8B8A8_SNORM = 38, + [NoShow] VK_FORMAT_R8G8B8A8_USCALED = 39, + [NoShow] VK_FORMAT_R8G8B8A8_SSCALED = 40, + [NoShow] VK_FORMAT_R8G8B8A8_UINT = 41, + [NoShow] VK_FORMAT_R8G8B8A8_SINT = 42, + [NoShow] VK_FORMAT_R8G8B8A8_SRGB = 43, + [NoShow] VK_FORMAT_B8G8R8A8_UNORM = 44, + [NoShow] VK_FORMAT_B8G8R8A8_SNORM = 45, + [NoShow] VK_FORMAT_B8G8R8A8_USCALED = 46, + [NoShow] VK_FORMAT_B8G8R8A8_SSCALED = 47, + [NoShow] VK_FORMAT_B8G8R8A8_UINT = 48, + [NoShow] VK_FORMAT_B8G8R8A8_SINT = 49, + [NoShow] VK_FORMAT_B8G8R8A8_SRGB = 50, + [NoShow] VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + [NoShow] VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + [NoShow] VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + [NoShow] VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + [NoShow] VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + [NoShow] VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + [NoShow] VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + [NoShow] VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + [NoShow] VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + [NoShow] VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + [NoShow] VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + [NoShow] VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + [NoShow] VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + [NoShow] VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + [NoShow] VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + [NoShow] VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + [NoShow] VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + [NoShow] VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + [NoShow] VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + [NoShow] VK_FORMAT_R16_UNORM = 70, + [NoShow] VK_FORMAT_R16_SNORM = 71, + [NoShow] VK_FORMAT_R16_USCALED = 72, + [NoShow] VK_FORMAT_R16_SSCALED = 73, + [NoShow] VK_FORMAT_R16_UINT = 74, + [NoShow] VK_FORMAT_R16_SINT = 75, + [NoShow] VK_FORMAT_R16_SFLOAT = 76, + [NoShow] VK_FORMAT_R16G16_UNORM = 77, + [NoShow] VK_FORMAT_R16G16_SNORM = 78, + [NoShow] VK_FORMAT_R16G16_USCALED = 79, + [NoShow] VK_FORMAT_R16G16_SSCALED = 80, + [NoShow] VK_FORMAT_R16G16_UINT = 81, + [NoShow] VK_FORMAT_R16G16_SINT = 82, + [NoShow] VK_FORMAT_R16G16_SFLOAT = 83, + [NoShow] VK_FORMAT_R16G16B16_UNORM = 84, + [NoShow] VK_FORMAT_R16G16B16_SNORM = 85, + [NoShow] VK_FORMAT_R16G16B16_USCALED = 86, + [NoShow] VK_FORMAT_R16G16B16_SSCALED = 87, + [NoShow] VK_FORMAT_R16G16B16_UINT = 88, + [NoShow] VK_FORMAT_R16G16B16_SINT = 89, + [NoShow] VK_FORMAT_R16G16B16_SFLOAT = 90, + [NoShow] VK_FORMAT_R16G16B16A16_UNORM = 91, + [NoShow] VK_FORMAT_R16G16B16A16_SNORM = 92, + [NoShow] VK_FORMAT_R16G16B16A16_USCALED = 93, + [NoShow] VK_FORMAT_R16G16B16A16_SSCALED = 94, + [NoShow] VK_FORMAT_R16G16B16A16_UINT = 95, + [NoShow] VK_FORMAT_R16G16B16A16_SINT = 96, + [NoShow] VK_FORMAT_R16G16B16A16_SFLOAT = 97, + [NoShow] VK_FORMAT_R32_UINT = 98, + [NoShow] VK_FORMAT_R32_SINT = 99, + [NoShow] VK_FORMAT_R32_SFLOAT = 100, + [NoShow] VK_FORMAT_R32G32_UINT = 101, + [NoShow] VK_FORMAT_R32G32_SINT = 102, + [NoShow] VK_FORMAT_R32G32_SFLOAT = 103, + [NoShow] VK_FORMAT_R32G32B32_UINT = 104, + [NoShow] VK_FORMAT_R32G32B32_SINT = 105, + [NoShow] VK_FORMAT_R32G32B32_SFLOAT = 106, + [NoShow] VK_FORMAT_R32G32B32A32_UINT = 107, + [NoShow] VK_FORMAT_R32G32B32A32_SINT = 108, + [NoShow] VK_FORMAT_R32G32B32A32_SFLOAT = 109, + [NoShow] VK_FORMAT_R64_UINT = 110, + [NoShow] VK_FORMAT_R64_SINT = 111, + [NoShow] VK_FORMAT_R64_SFLOAT = 112, + [NoShow] VK_FORMAT_R64G64_UINT = 113, + [NoShow] VK_FORMAT_R64G64_SINT = 114, + [NoShow] VK_FORMAT_R64G64_SFLOAT = 115, + [NoShow] VK_FORMAT_R64G64B64_UINT = 116, + [NoShow] VK_FORMAT_R64G64B64_SINT = 117, + [NoShow] VK_FORMAT_R64G64B64_SFLOAT = 118, + [NoShow] VK_FORMAT_R64G64B64A64_UINT = 119, + [NoShow] VK_FORMAT_R64G64B64A64_SINT = 120, + [NoShow] VK_FORMAT_R64G64B64A64_SFLOAT = 121, + [NoShow] VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + [NoShow] VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + [NoShow] VK_FORMAT_D16_UNORM = 124, + [NoShow] VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + [NoShow] VK_FORMAT_D32_SFLOAT = 126, + [NoShow] VK_FORMAT_S8_UINT = 127, + [NoShow] VK_FORMAT_D16_UNORM_S8_UINT = 128, + [NoShow] VK_FORMAT_D24_UNORM_S8_UINT = 129, + [NoShow] VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + [NoShow] VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + [NoShow] VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + [NoShow] VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + [NoShow] VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + [NoShow] VK_FORMAT_BC2_UNORM_BLOCK = 135, + [NoShow] VK_FORMAT_BC2_SRGB_BLOCK = 136, + [NoShow] VK_FORMAT_BC3_UNORM_BLOCK = 137, + [NoShow] VK_FORMAT_BC3_SRGB_BLOCK = 138, + [NoShow] VK_FORMAT_BC4_UNORM_BLOCK = 139, + [NoShow] VK_FORMAT_BC4_SNORM_BLOCK = 140, + [NoShow] VK_FORMAT_BC5_UNORM_BLOCK = 141, + [NoShow] VK_FORMAT_BC5_SNORM_BLOCK = 142, + [NoShow] VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + [NoShow] VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + [NoShow] VK_FORMAT_BC7_UNORM_BLOCK = 145, + [NoShow] VK_FORMAT_BC7_SRGB_BLOCK = 146, + [NoShow] VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + [NoShow] VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + [NoShow] VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + [NoShow] VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + [NoShow] VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + [NoShow] VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + [NoShow] VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + [NoShow] VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + [NoShow] VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + [NoShow] VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + [NoShow] VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + [NoShow] VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + [NoShow] VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + [NoShow] VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + [NoShow] VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + [NoShow] VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + [NoShow] VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + [NoShow] VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + [NoShow] VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + [NoShow] VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + [NoShow] VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + [NoShow] VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + [NoShow] VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + [NoShow] VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + [NoShow] VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + [NoShow] VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + [NoShow] VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + [NoShow] VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + [NoShow] VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + [NoShow] VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + [NoShow] VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + [NoShow] VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + [NoShow] VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + [NoShow] VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + [NoShow] VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + [NoShow] VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + [NoShow] VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + [NoShow] VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + [NoShow] VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + [NoShow] VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + [NoShow] VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + [NoShow] VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + [NoShow] VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + [NoShow] VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + [NoShow] VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + [NoShow] VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + [NoShow] VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + [NoShow] VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + [NoShow] VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + [NoShow] VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + [NoShow] VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + [NoShow] VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + [NoShow] VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + [NoShow] VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + [NoShow] VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + [NoShow] VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + [NoShow] VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + [NoShow] VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + [NoShow] VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + [NoShow] VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + [NoShow] VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + [NoShow] VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + [NoShow] VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + [NoShow] VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + [NoShow] VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + [NoShow] VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + [NoShow] VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + [NoShow] VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, + [NoShow] VK_FORMAT_A1B5G5R5_UNORM_PACK16 = 1000470000, + [NoShow] VK_FORMAT_A8_UNORM = 1000470001, + [NoShow] VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + [NoShow] VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + [NoShow] VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + [NoShow] VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + [NoShow] VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + [NoShow] VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + [NoShow] VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + [NoShow] VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + [NoShow] VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + [NoShow] VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + [NoShow] VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + [NoShow] VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + [NoShow] VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + [NoShow] VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + [NoShow] VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + [NoShow] VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + [NoShow] VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + [NoShow] VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + [NoShow] VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + [NoShow] VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + [NoShow] VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + [NoShow] VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + [NoShow] VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + [NoShow] VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + [NoShow] VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + [NoShow] VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + [NoShow] VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + [NoShow] VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + [NoShow] VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + [NoShow] VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + [NoShow] VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + [NoShow] VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + [NoShow] VK_FORMAT_R8_BOOL_ARM = 1000460000, + [NoShow] VK_FORMAT_R16G16_SFIXED5_NV = 1000464000, + [NoShow] VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV, + [NoShow] VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16, + [NoShow] VK_FORMAT_A8_UNORM_KHR = VK_FORMAT_A8_UNORM, + [NoShow] VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000, + [NoShow] VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM = 1000609001, + [NoShow] VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002, + [NoShow] VK_FORMAT_R12X4_UINT_PACK16_ARM = 1000609003, + [NoShow] VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM = 1000609004, + [NoShow] VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005, + [NoShow] VK_FORMAT_R14X2_UINT_PACK16_ARM = 1000609006, + [NoShow] VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM = 1000609007, + [NoShow] VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008, + [NoShow] VK_FORMAT_R14X2_UNORM_PACK16_ARM = 1000609009, + [NoShow] VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM = 1000609010, + [NoShow] VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011, + [NoShow] VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012, + [NoShow] VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013, + // pretty names + UNDEFINED = 0, + R4G4_UNORM_PACK8 = 1, + R4G4B4A4_UNORM_PACK16 = 2, + B4G4R4A4_UNORM_PACK16 = 3, + R5G6B5_UNORM_PACK16 = 4, + B5G6R5_UNORM_PACK16 = 5, + R5G5B5A1_UNORM_PACK16 = 6, + B5G5R5A1_UNORM_PACK16 = 7, + A1R5G5B5_UNORM_PACK16 = 8, + R8_UNORM = 9, + R8_SNORM = 10, + R8_USCALED = 11, + R8_SSCALED = 12, + R8_UINT = 13, + R8_SINT = 14, + R8_SRGB = 15, + R8G8_UNORM = 16, + R8G8_SNORM = 17, + R8G8_USCALED = 18, + R8G8_SSCALED = 19, + R8G8_UINT = 20, + R8G8_SINT = 21, + R8G8_SRGB = 22, + R8G8B8_UNORM = 23, + R8G8B8_SNORM = 24, + R8G8B8_USCALED = 25, + R8G8B8_SSCALED = 26, + R8G8B8_UINT = 27, + R8G8B8_SINT = 28, + R8G8B8_SRGB = 29, + B8G8R8_UNORM = 30, + B8G8R8_SNORM = 31, + B8G8R8_USCALED = 32, + B8G8R8_SSCALED = 33, + B8G8R8_UINT = 34, + B8G8R8_SINT = 35, + B8G8R8_SRGB = 36, + R8G8B8A8_UNORM = 37, + R8G8B8A8_SNORM = 38, + R8G8B8A8_USCALED = 39, + R8G8B8A8_SSCALED = 40, + R8G8B8A8_UINT = 41, + R8G8B8A8_SINT = 42, + R8G8B8A8_SRGB = 43, + B8G8R8A8_UNORM = 44, + B8G8R8A8_SNORM = 45, + B8G8R8A8_USCALED = 46, + B8G8R8A8_SSCALED = 47, + B8G8R8A8_UINT = 48, + B8G8R8A8_SINT = 49, + B8G8R8A8_SRGB = 50, + A8B8G8R8_UNORM_PACK32 = 51, + A8B8G8R8_SNORM_PACK32 = 52, + A8B8G8R8_USCALED_PACK32 = 53, + A8B8G8R8_SSCALED_PACK32 = 54, + A8B8G8R8_UINT_PACK32 = 55, + A8B8G8R8_SINT_PACK32 = 56, + A8B8G8R8_SRGB_PACK32 = 57, + A2R10G10B10_UNORM_PACK32 = 58, + A2R10G10B10_SNORM_PACK32 = 59, + A2R10G10B10_USCALED_PACK32 = 60, + A2R10G10B10_SSCALED_PACK32 = 61, + A2R10G10B10_UINT_PACK32 = 62, + A2R10G10B10_SINT_PACK32 = 63, + A2B10G10R10_UNORM_PACK32 = 64, + A2B10G10R10_SNORM_PACK32 = 65, + A2B10G10R10_USCALED_PACK32 = 66, + A2B10G10R10_SSCALED_PACK32 = 67, + A2B10G10R10_UINT_PACK32 = 68, + A2B10G10R10_SINT_PACK32 = 69, + R16_UNORM = 70, + R16_SNORM = 71, + R16_USCALED = 72, + R16_SSCALED = 73, + R16_UINT = 74, + R16_SINT = 75, + R16_SFLOAT = 76, + R16G16_UNORM = 77, + R16G16_SNORM = 78, + R16G16_USCALED = 79, + R16G16_SSCALED = 80, + R16G16_UINT = 81, + R16G16_SINT = 82, + R16G16_SFLOAT = 83, + R16G16B16_UNORM = 84, + R16G16B16_SNORM = 85, + R16G16B16_USCALED = 86, + R16G16B16_SSCALED = 87, + R16G16B16_UINT = 88, + R16G16B16_SINT = 89, + R16G16B16_SFLOAT = 90, + R16G16B16A16_UNORM = 91, + R16G16B16A16_SNORM = 92, + R16G16B16A16_USCALED = 93, + R16G16B16A16_SSCALED = 94, + R16G16B16A16_UINT = 95, + R16G16B16A16_SINT = 96, + R16G16B16A16_SFLOAT = 97, + R32_UINT = 98, + R32_SINT = 99, + R32_SFLOAT = 100, + R32G32_UINT = 101, + R32G32_SINT = 102, + R32G32_SFLOAT = 103, + R32G32B32_UINT = 104, + R32G32B32_SINT = 105, + R32G32B32_SFLOAT = 106, + R32G32B32A32_UINT = 107, + R32G32B32A32_SINT = 108, + R32G32B32A32_SFLOAT = 109, + R64_UINT = 110, + R64_SINT = 111, + R64_SFLOAT = 112, + R64G64_UINT = 113, + R64G64_SINT = 114, + R64G64_SFLOAT = 115, + R64G64B64_UINT = 116, + R64G64B64_SINT = 117, + R64G64B64_SFLOAT = 118, + R64G64B64A64_UINT = 119, + R64G64B64A64_SINT = 120, + R64G64B64A64_SFLOAT = 121, + B10G11R11_UFLOAT_PACK32 = 122, + E5B9G9R9_UFLOAT_PACK32 = 123, + D16_UNORM = 124, + X8_D24_UNORM_PACK32 = 125, + D32_SFLOAT = 126, + S8_UINT = 127, + D16_UNORM_S8_UINT = 128, + D24_UNORM_S8_UINT = 129, + D32_SFLOAT_S8_UINT = 130, + BC1_RGB_UNORM_BLOCK = 131, + BC1_RGB_SRGB_BLOCK = 132, + BC1_RGBA_UNORM_BLOCK = 133, + BC1_RGBA_SRGB_BLOCK = 134, + BC2_UNORM_BLOCK = 135, + BC2_SRGB_BLOCK = 136, + BC3_UNORM_BLOCK = 137, + BC3_SRGB_BLOCK = 138, + BC4_UNORM_BLOCK = 139, + BC4_SNORM_BLOCK = 140, + BC5_UNORM_BLOCK = 141, + BC5_SNORM_BLOCK = 142, + BC6H_UFLOAT_BLOCK = 143, + BC6H_SFLOAT_BLOCK = 144, + BC7_UNORM_BLOCK = 145, + BC7_SRGB_BLOCK = 146, + ETC2_R8G8B8_UNORM_BLOCK = 147, + ETC2_R8G8B8_SRGB_BLOCK = 148, + ETC2_R8G8B8A1_UNORM_BLOCK = 149, + ETC2_R8G8B8A1_SRGB_BLOCK = 150, + ETC2_R8G8B8A8_UNORM_BLOCK = 151, + ETC2_R8G8B8A8_SRGB_BLOCK = 152, + EAC_R11_UNORM_BLOCK = 153, + EAC_R11_SNORM_BLOCK = 154, + EAC_R11G11_UNORM_BLOCK = 155, + EAC_R11G11_SNORM_BLOCK = 156, + ASTC_4x4_UNORM_BLOCK = 157, + ASTC_4x4_SRGB_BLOCK = 158, + ASTC_5x4_UNORM_BLOCK = 159, + ASTC_5x4_SRGB_BLOCK = 160, + ASTC_5x5_UNORM_BLOCK = 161, + ASTC_5x5_SRGB_BLOCK = 162, + ASTC_6x5_UNORM_BLOCK = 163, + ASTC_6x5_SRGB_BLOCK = 164, + ASTC_6x6_UNORM_BLOCK = 165, + ASTC_6x6_SRGB_BLOCK = 166, + ASTC_8x5_UNORM_BLOCK = 167, + ASTC_8x5_SRGB_BLOCK = 168, + ASTC_8x6_UNORM_BLOCK = 169, + ASTC_8x6_SRGB_BLOCK = 170, + ASTC_8x8_UNORM_BLOCK = 171, + ASTC_8x8_SRGB_BLOCK = 172, + ASTC_10x5_UNORM_BLOCK = 173, + ASTC_10x5_SRGB_BLOCK = 174, + ASTC_10x6_UNORM_BLOCK = 175, + ASTC_10x6_SRGB_BLOCK = 176, + ASTC_10x8_UNORM_BLOCK = 177, + ASTC_10x8_SRGB_BLOCK = 178, + ASTC_10x10_UNORM_BLOCK = 179, + ASTC_10x10_SRGB_BLOCK = 180, + ASTC_12x10_UNORM_BLOCK = 181, + ASTC_12x10_SRGB_BLOCK = 182, + ASTC_12x12_UNORM_BLOCK = 183, + ASTC_12x12_SRGB_BLOCK = 184, + G8B8G8R8_422_UNORM = 1000156000, + B8G8R8G8_422_UNORM = 1000156001, + G8_B8_R8_3PLANE_420_UNORM = 1000156002, + G8_B8R8_2PLANE_420_UNORM = 1000156003, + G8_B8_R8_3PLANE_422_UNORM = 1000156004, + G8_B8R8_2PLANE_422_UNORM = 1000156005, + G8_B8_R8_3PLANE_444_UNORM = 1000156006, + R10X6_UNORM_PACK16 = 1000156007, + R10X6G10X6_UNORM_2PACK16 = 1000156008, + R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + R12X4_UNORM_PACK16 = 1000156017, + R12X4G12X4_UNORM_2PACK16 = 1000156018, + R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + G16B16G16R16_422_UNORM = 1000156027, + B16G16R16G16_422_UNORM = 1000156028, + G16_B16_R16_3PLANE_420_UNORM = 1000156029, + G16_B16R16_2PLANE_420_UNORM = 1000156030, + G16_B16_R16_3PLANE_422_UNORM = 1000156031, + G16_B16R16_2PLANE_422_UNORM = 1000156032, + G16_B16_R16_3PLANE_444_UNORM = 1000156033, + G8_B8R8_2PLANE_444_UNORM = 1000330000, + G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + G16_B16R16_2PLANE_444_UNORM = 1000330003, + A4R4G4B4_UNORM_PACK16 = 1000340000, + A4B4G4R4_UNORM_PACK16 = 1000340001, + ASTC_4x4_SFLOAT_BLOCK = 1000066000, + ASTC_5x4_SFLOAT_BLOCK = 1000066001, + ASTC_5x5_SFLOAT_BLOCK = 1000066002, + ASTC_6x5_SFLOAT_BLOCK = 1000066003, + ASTC_6x6_SFLOAT_BLOCK = 1000066004, + ASTC_8x5_SFLOAT_BLOCK = 1000066005, + ASTC_8x6_SFLOAT_BLOCK = 1000066006, + ASTC_8x8_SFLOAT_BLOCK = 1000066007, + ASTC_10x5_SFLOAT_BLOCK = 1000066008, + ASTC_10x6_SFLOAT_BLOCK = 1000066009, + ASTC_10x8_SFLOAT_BLOCK = 1000066010, + ASTC_10x10_SFLOAT_BLOCK = 1000066011, + ASTC_12x10_SFLOAT_BLOCK = 1000066012, + ASTC_12x12_SFLOAT_BLOCK = 1000066013, + A1B5G5R5_UNORM_PACK16 = 1000470000, + A8_UNORM = 1000470001, + PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + ASTC_4x4_SFLOAT_BLOCK_EXT = ASTC_4x4_SFLOAT_BLOCK, + ASTC_5x4_SFLOAT_BLOCK_EXT = ASTC_5x4_SFLOAT_BLOCK, + ASTC_5x5_SFLOAT_BLOCK_EXT = ASTC_5x5_SFLOAT_BLOCK, + ASTC_6x5_SFLOAT_BLOCK_EXT = ASTC_6x5_SFLOAT_BLOCK, + ASTC_6x6_SFLOAT_BLOCK_EXT = ASTC_6x6_SFLOAT_BLOCK, + ASTC_8x5_SFLOAT_BLOCK_EXT = ASTC_8x5_SFLOAT_BLOCK, + ASTC_8x6_SFLOAT_BLOCK_EXT = ASTC_8x6_SFLOAT_BLOCK, + ASTC_8x8_SFLOAT_BLOCK_EXT = ASTC_8x8_SFLOAT_BLOCK, + ASTC_10x5_SFLOAT_BLOCK_EXT = ASTC_10x5_SFLOAT_BLOCK, + ASTC_10x6_SFLOAT_BLOCK_EXT = ASTC_10x6_SFLOAT_BLOCK, + ASTC_10x8_SFLOAT_BLOCK_EXT = ASTC_10x8_SFLOAT_BLOCK, + ASTC_10x10_SFLOAT_BLOCK_EXT = ASTC_10x10_SFLOAT_BLOCK, + ASTC_12x10_SFLOAT_BLOCK_EXT = ASTC_12x10_SFLOAT_BLOCK, + ASTC_12x12_SFLOAT_BLOCK_EXT = ASTC_12x12_SFLOAT_BLOCK, + G8B8G8R8_422_UNORM_KHR = G8B8G8R8_422_UNORM, + B8G8R8G8_422_UNORM_KHR = B8G8R8G8_422_UNORM, + G8_B8_R8_3PLANE_420_UNORM_KHR = G8_B8_R8_3PLANE_420_UNORM, + G8_B8R8_2PLANE_420_UNORM_KHR = G8_B8R8_2PLANE_420_UNORM, + G8_B8_R8_3PLANE_422_UNORM_KHR = G8_B8_R8_3PLANE_422_UNORM, + G8_B8R8_2PLANE_422_UNORM_KHR = G8_B8R8_2PLANE_422_UNORM, + G8_B8_R8_3PLANE_444_UNORM_KHR = G8_B8_R8_3PLANE_444_UNORM, + R10X6_UNORM_PACK16_KHR = R10X6_UNORM_PACK16, + R10X6G10X6_UNORM_2PACK16_KHR = R10X6G10X6_UNORM_2PACK16, + R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = R10X6G10X6B10X6A10X6_UNORM_4PACK16, + G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + R12X4_UNORM_PACK16_KHR = R12X4_UNORM_PACK16, + R12X4G12X4_UNORM_2PACK16_KHR = R12X4G12X4_UNORM_2PACK16, + R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = R12X4G12X4B12X4A12X4_UNORM_4PACK16, + G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + G16B16G16R16_422_UNORM_KHR = G16B16G16R16_422_UNORM, + B16G16R16G16_422_UNORM_KHR = B16G16R16G16_422_UNORM, + G16_B16_R16_3PLANE_420_UNORM_KHR = G16_B16_R16_3PLANE_420_UNORM, + G16_B16R16_2PLANE_420_UNORM_KHR = G16_B16R16_2PLANE_420_UNORM, + G16_B16_R16_3PLANE_422_UNORM_KHR = G16_B16_R16_3PLANE_422_UNORM, + G16_B16R16_2PLANE_422_UNORM_KHR = G16_B16R16_2PLANE_422_UNORM, + G16_B16_R16_3PLANE_444_UNORM_KHR = G16_B16_R16_3PLANE_444_UNORM, + G8_B8R8_2PLANE_444_UNORM_EXT = G8_B8R8_2PLANE_444_UNORM, + G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + G16_B16R16_2PLANE_444_UNORM_EXT = G16_B16R16_2PLANE_444_UNORM, + A4R4G4B4_UNORM_PACK16_EXT = A4R4G4B4_UNORM_PACK16, + A4B4G4R4_UNORM_PACK16_EXT = A4B4G4R4_UNORM_PACK16, + R8_BOOL_ARM = 1000460000, + R16G16_SFIXED5_NV = 1000464000, + R16G16_S10_5_NV = R16G16_SFIXED5_NV, + A1B5G5R5_UNORM_PACK16_KHR = A1B5G5R5_UNORM_PACK16, + A8_UNORM_KHR = A8_UNORM, + R10X6_UINT_PACK16_ARM = 1000609000, + R10X6G10X6_UINT_2PACK16_ARM = 1000609001, + R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002, + R12X4_UINT_PACK16_ARM = 1000609003, + R12X4G12X4_UINT_2PACK16_ARM = 1000609004, + R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005, + R14X2_UINT_PACK16_ARM = 1000609006, + R14X2G14X2_UINT_2PACK16_ARM = 1000609007, + R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008, + R14X2_UNORM_PACK16_ARM = 1000609009, + R14X2G14X2_UNORM_2PACK16_ARM = 1000609010, + R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011, + G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012, + G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013, +} + +[AllowDuplicates] enum VkFormatFeatureFlagBits : int32 +{ + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1 << 0, // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + [NoShow] VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 1 << 1, // Format can be used for storage images (STORAGE_IMAGE descriptor type) + [NoShow] VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 1 << 2, // Format supports atomic operations in case it is used for storage images + [NoShow] VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 1 << 3, // Format can be used for uniform texel buffers (TBOs) + [NoShow] VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 1 << 4, // Format can be used for storage texel buffers (IBOs) + [NoShow] VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 1 << 5, // Format supports atomic operations in case it is used for storage texel buffers + [NoShow] VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 1 << 6, // Format can be used for vertex buffers (VBOs) + [NoShow] VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 1 << 7, // Format can be used for color attachment images + [NoShow] VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 1 << 8, // Format supports blending in case it is used for color attachment images + [NoShow] VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 1 << 9, // Format can be used for depth/stencil attachment images + [NoShow] VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1 << 10, // Format can be used as the source image of blits with vkCmdBlitImage + [NoShow] VK_FORMAT_FEATURE_BLIT_DST_BIT = 1 << 11, // Format can be used as the destination image of blits with vkCmdBlitImage + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 1 << 12, // Format can be filtered with VK_FILTER_LINEAR when being sampled + [NoShow] VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 1 << 14, // Format can be used as the source image of image transfer commands + [NoShow] VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 1 << 15, // Format can be used as the destination image of image transfer commands + [NoShow] VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 1 << 17, // Format can have midpoint rather than cosited chroma samples + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 1 << 18, // Format can be used with linear filtering whilst color conversion is enabled + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 1 << 19, // Format can have different chroma, min and mag filters + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1 << 20, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 1 << 21, + [NoShow] VK_FORMAT_FEATURE_DISJOINT_BIT = 1 << 22, // Format supports disjoint planes + [NoShow] VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 1 << 23, // Format can have cosited rather than midpoint chroma samples + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 1 << 16, // Format can be used with min/max reduction filtering + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, // Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled + [NoShow] VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 1 << 25, + [NoShow] VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 1 << 26, + [NoShow] VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + [NoShow] VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + [NoShow] VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 1 << 29, + [NoShow] VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + [NoShow] VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + [NoShow] VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + [NoShow] VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 1 << 13, + [NoShow] VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 1 << 24, + [NoShow] VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 30, + [NoShow] VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 1 << 27, + [NoShow] VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 1 << 28, + // pretty names + SampledImage = 1 << 0, // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + StorageImage = 1 << 1, // Format can be used for storage images (STORAGE_IMAGE descriptor type) + StorageImageAtomic = 1 << 2, // Format supports atomic operations in case it is used for storage images + UniformTexelBuffer = 1 << 3, // Format can be used for uniform texel buffers (TBOs) + StorageTexelBuffer = 1 << 4, // Format can be used for storage texel buffers (IBOs) + StorageTexelBufferAtomic = 1 << 5, // Format supports atomic operations in case it is used for storage texel buffers + VertexBuffer = 1 << 6, // Format can be used for vertex buffers (VBOs) + ColorAttachment = 1 << 7, // Format can be used for color attachment images + ColorAttachmentBlend = 1 << 8, // Format supports blending in case it is used for color attachment images + DepthStencilAttachment = 1 << 9, // Format can be used for depth/stencil attachment images + BlitSrc = 1 << 10, // Format can be used as the source image of blits with vkCmdBlitImage + BlitDst = 1 << 11, // Format can be used as the destination image of blits with vkCmdBlitImage + SampledImageFilterLinear = 1 << 12, // Format can be filtered with VK_FILTER_LINEAR when being sampled + TransferSrc = 1 << 14, // Format can be used as the source image of image transfer commands + TransferDst = 1 << 15, // Format can be used as the destination image of image transfer commands + MidpointChromaSamples = 1 << 17, // Format can have midpoint rather than cosited chroma samples + SampledImageYcbcrConversionLinearFilter = 1 << 18, // Format can be used with linear filtering whilst color conversion is enabled + SampledImageYcbcrConversionSeparateReconstructionFilter = 1 << 19, // Format can have different chroma, min and mag filters + SampledImageYcbcrConversionChromaReconstructionExplicit = 1 << 20, + SampledImageYcbcrConversionChromaReconstructionExplicitForceable = 1 << 21, + Disjoint = 1 << 22, // Format supports disjoint planes + CositedChromaSamples = 1 << 23, // Format can have cosited rather than midpoint chroma samples + SampledImageFilterMinmax = 1 << 16, // Format can be used with min/max reduction filtering + SampledImageFilterCubicIMG = SampledImageFilterCubicEXT, // Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled + VideoDecodeOutputKHR = 1 << 25, + VideoDecodeDpbKHR = 1 << 26, + TransferSrcKHR = TransferSrc, + TransferDstKHR = TransferDst, + SampledImageFilterMinmaxEXT = SampledImageFilterMinmax, + AccelerationStructureVertexBufferKHR = 1 << 29, + MidpointChromaSamplesKHR = MidpointChromaSamples, + SampledImageYcbcrConversionLinearFilterKHR = SampledImageYcbcrConversionLinearFilter, + SampledImageYcbcrConversionSeparateReconstructionFilterKHR = SampledImageYcbcrConversionSeparateReconstructionFilter, + SampledImageYcbcrConversionChromaReconstructionExplicitKHR = SampledImageYcbcrConversionChromaReconstructionExplicit, + SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = SampledImageYcbcrConversionChromaReconstructionExplicitForceable, + DisjointKHR = Disjoint, + CositedChromaSamplesKHR = CositedChromaSamples, + SampledImageFilterCubicEXT = 1 << 13, + FragmentDensityMapEXT = 1 << 24, + FragmentShadingRateAttachmentKHR = 1 << 30, + VideoEncodeInputKHR = 1 << 27, + VideoEncodeDpbKHR = 1 << 28, +} + +typealias VkFormatFeatureFlags = VkFormatFeatureFlagBits; + +[CRepr] struct VkFormatProperties : this() +{ + public VkFormatFeatureFlags linearTilingFeatures = default; // Format features in case of linear tiling + public VkFormatFeatureFlags optimalTilingFeatures = default; // Format features in case of optimal tiling + public VkFormatFeatureFlags bufferFeatures = default; // Format features supported by buffers +} + +[AllowDuplicates] enum VkImageCreateFlagBits : int32 +{ + [NoShow] VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1 << 0, // Image should support sparse backing + [NoShow] VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 1 << 1, // Image should support sparse backing with partial residency + [NoShow] VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 1 << 2, // Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images + [NoShow] VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 1 << 3, // Allows image views to have different format than the base image + [NoShow] VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 1 << 4, // Allows creating image views with cube type from the created image + [NoShow] VK_IMAGE_CREATE_ALIAS_BIT = 1 << 10, + [NoShow] VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 1 << 6, // Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image + [NoShow] VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 1 << 5, // The 3D image can be viewed as a 2D or 2D array image + [NoShow] VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 1 << 7, + [NoShow] VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 1 << 8, + [NoShow] VK_IMAGE_CREATE_PROTECTED_BIT = 1 << 11, // Image requires protected memory + [NoShow] VK_IMAGE_CREATE_DISJOINT_BIT = 1 << 9, + [NoShow] VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 1 << 13, + [NoShow] VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + [NoShow] VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + [NoShow] VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + [NoShow] VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + [NoShow] VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 1 << 12, + [NoShow] VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + [NoShow] VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + [NoShow] VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 1 << 14, + [NoShow] VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 1 << 16, + [NoShow] VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 1 << 18, + [NoShow] VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 1 << 17, // Image is created with a layout where individual slices are capable of being used as 2D images + [NoShow] VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, + [NoShow] VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 1 << 20, + [NoShow] VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 1 << 15, + // pretty names + SparseBinding = 1 << 0, // Image should support sparse backing + SparseResidency = 1 << 1, // Image should support sparse backing with partial residency + SparseAliased = 1 << 2, // Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images + MutableFormat = 1 << 3, // Allows image views to have different format than the base image + CubeCompatible = 1 << 4, // Allows creating image views with cube type from the created image + Alias = 1 << 10, + SplitInstanceBindRegions = 1 << 6, // Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image + _2dArrayCompatible = 1 << 5, // The 3D image can be viewed as a 2D or 2D array image + BlockTexelViewCompatible = 1 << 7, + ExtendedUsage = 1 << 8, + Protected = 1 << 11, // Image requires protected memory + Disjoint = 1 << 9, + CornerSampledNV = 1 << 13, + SplitInstanceBindRegionsKHR = SplitInstanceBindRegions, + _2dArrayCompatibleKHR = _2dArrayCompatible, + BlockTexelViewCompatibleKHR = BlockTexelViewCompatible, + ExtendedUsageKHR = ExtendedUsage, + SampleLocationsCompatibleDepthEXT = 1 << 12, + DisjointKHR = Disjoint, + AliasKHR = Alias, + SubsampledEXT = 1 << 14, + DescriptorBufferCaptureReplayEXT = 1 << 16, + MultisampledRenderToSingleSampledEXT = 1 << 18, + _2dViewCompatibleEXT = 1 << 17, // Image is created with a layout where individual slices are capable of being used as 2D images + FragmentDensityMapOffsetQCOM = FragmentDensityMapOffsetEXT, + VideoProfileIndependentKHR = 1 << 20, + FragmentDensityMapOffsetEXT = 1 << 15, +} + +typealias VkImageCreateFlags = VkImageCreateFlagBits; + +[CRepr] struct VkImageFormatProperties : this() +{ + public VkExtent3D maxExtent = default; // max image dimensions for this resource type + public uint32 maxMipLevels = 0; // max number of mipmap levels for this resource type + public uint32 maxArrayLayers = 0; // max array size for this resource type + public VkSampleCountFlags sampleCounts = default; // supported sample counts for this resource type + public VkDeviceSize maxResourceSize = default; // max size (in bytes) of this resource type +} + +[AllowDuplicates] enum VkImageTiling : int32 +{ + [NoShow] VK_IMAGE_TILING_OPTIMAL = 0, + [NoShow] VK_IMAGE_TILING_LINEAR = 1, + [NoShow] VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + // pretty names + Optimal = 0, + Linear = 1, + DrmFormatModifierEXT = 1000158000, +} + +[AllowDuplicates] enum VkImageType : int32 +{ + [NoShow] VK_IMAGE_TYPE_1D = 0, + [NoShow] VK_IMAGE_TYPE_2D = 1, + [NoShow] VK_IMAGE_TYPE_3D = 2, + // pretty names + _1d = 0, + _2d = 1, + _3d = 2, +} + +[AllowDuplicates] enum VkImageUsageFlagBits : int32 +{ + [NoShow] VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1 << 0, // Can be used as a source of transfer operations + [NoShow] VK_IMAGE_USAGE_TRANSFER_DST_BIT = 1 << 1, // Can be used as a destination of transfer operations + [NoShow] VK_IMAGE_USAGE_SAMPLED_BIT = 1 << 2, // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + [NoShow] VK_IMAGE_USAGE_STORAGE_BIT = 1 << 3, // Can be used as storage image (STORAGE_IMAGE descriptor type) + [NoShow] VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 1 << 4, // Can be used as framebuffer color attachment + [NoShow] VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 1 << 5, // Can be used as framebuffer depth/stencil attachment + [NoShow] VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 1 << 6, // Image data not needed outside of rendering + [NoShow] VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 1 << 7, // Can be used as framebuffer input attachment + [NoShow] VK_IMAGE_USAGE_HOST_TRANSFER_BIT = 1 << 22, + [NoShow] VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 1 << 10, + [NoShow] VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 1 << 11, + [NoShow] VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 1 << 12, + [NoShow] VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + [NoShow] VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 1 << 9, + [NoShow] VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 8, + [NoShow] VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, // Can be used with host image copies + [NoShow] VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 1 << 13, + [NoShow] VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 1 << 14, + [NoShow] VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 1 << 15, + [NoShow] VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1 << 19, + [NoShow] VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 1 << 18, + [NoShow] VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 1 << 20, + [NoShow] VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 1 << 21, + [NoShow] VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM = 1 << 23, + [NoShow] VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 1 << 27, + [NoShow] VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 1 << 25, + [NoShow] VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 1 << 26, + // pretty names + TransferSrc = 1 << 0, // Can be used as a source of transfer operations + TransferDst = 1 << 1, // Can be used as a destination of transfer operations + Sampled = 1 << 2, // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) + Storage = 1 << 3, // Can be used as storage image (STORAGE_IMAGE descriptor type) + ColorAttachment = 1 << 4, // Can be used as framebuffer color attachment + DepthStencilAttachment = 1 << 5, // Can be used as framebuffer depth/stencil attachment + TransientAttachment = 1 << 6, // Image data not needed outside of rendering + InputAttachment = 1 << 7, // Can be used as framebuffer input attachment + HostTransfer = 1 << 22, + VideoDecodeDstKHR = 1 << 10, + VideoDecodeSrcKHR = 1 << 11, + VideoDecodeDpbKHR = 1 << 12, + ShadingRateImageNV = FragmentShadingRateAttachmentKHR, + FragmentDensityMapEXT = 1 << 9, + FragmentShadingRateAttachmentKHR = 1 << 8, + HostTransferEXT = HostTransfer, // Can be used with host image copies + VideoEncodeDstKHR = 1 << 13, + VideoEncodeSrcKHR = 1 << 14, + VideoEncodeDpbKHR = 1 << 15, + AttachmentFeedbackLoopEXT = 1 << 19, + InvocationMaskHUAWEI = 1 << 18, + SampleWeightQCOM = 1 << 20, + SampleBlockMatchQCOM = 1 << 21, + TensorAliasingARM = 1 << 23, + TileMemoryQCOM = 1 << 27, + VideoEncodeQuantizationDeltaMapKHR = 1 << 25, + VideoEncodeEmphasisMapKHR = 1 << 26, +} + +typealias VkImageUsageFlags = VkImageUsageFlagBits; +struct VkInstance : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_INSTANCE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkInstanceCreateFlags = VkInstanceCreateFlagBits; + +[AllowDuplicates] enum VkInstanceCreateFlagBits : int32 +{ + [NoShow] VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 1 << 0, + // pretty names + EnumeratePortabilityKHR = 1 << 0, +} + +[CRepr] struct VkInstanceCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkInstanceCreateFlags flags = default; + public VkApplicationInfo* pApplicationInfo = null; + public uint32 enabledLayerCount = 0; + public char8** ppEnabledLayerNames = null; // Ordered list of layer names to be enabled + public uint32 enabledExtensionCount = 0; + public char8** ppEnabledExtensionNames = null; // Extension names to be enabled + + public this(void* pNext, VkInstanceCreateFlags flags, VkApplicationInfo* pApplicationInfo, uint32 enabledLayerCount, char8** ppEnabledLayerNames, uint32 enabledExtensionCount, char8** ppEnabledExtensionNames) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pApplicationInfo = pApplicationInfo; + this.enabledLayerCount = enabledLayerCount; + this.ppEnabledLayerNames = ppEnabledLayerNames; + this.enabledExtensionCount = enabledExtensionCount; + this.ppEnabledExtensionNames = ppEnabledExtensionNames; + } +} + +[AllowDuplicates] enum VkInternalAllocationType : int32 +{ + [NoShow] VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + // pretty names + Executable = 0, +} + +[CRepr] struct VkMemoryHeap : this() +{ + public VkDeviceSize size = default; // Available memory in the heap + public VkMemoryHeapFlags flags = default; // Flags for the heap +} + +[AllowDuplicates] enum VkMemoryHeapFlagBits : int32 +{ + [NoShow] VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1 << 0, // If set, heap represents device memory + [NoShow] VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 1 << 1, // If set, heap allocations allocate multiple instances by default + [NoShow] VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + [NoShow] VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 1 << 3, + // pretty names + DeviceLocal = 1 << 0, // If set, heap represents device memory + MultiInstance = 1 << 1, // If set, heap allocations allocate multiple instances by default + MultiInstanceKHR = MultiInstance, + TileMemoryQCOM = 1 << 3, +} + +typealias VkMemoryHeapFlags = VkMemoryHeapFlagBits; + +[AllowDuplicates] enum VkMemoryPropertyFlagBits : int32 +{ + [NoShow] VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1 << 0, // If otherwise stated, then allocate memory on device + [NoShow] VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 1 << 1, // Memory is mappable by host + [NoShow] VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 1 << 2, // Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache + [NoShow] VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 1 << 3, // Memory will be cached by the host + [NoShow] VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 1 << 4, // Memory may be allocated by the driver when it is required + [NoShow] VK_MEMORY_PROPERTY_PROTECTED_BIT = 1 << 5, // Memory is protected + [NoShow] VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 1 << 6, + [NoShow] VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 1 << 7, + [NoShow] VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 1 << 8, + // pretty names + DeviceLocal = 1 << 0, // If otherwise stated, then allocate memory on device + HostVisible = 1 << 1, // Memory is mappable by host + HostCoherent = 1 << 2, // Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache + HostCached = 1 << 3, // Memory will be cached by the host + LazilyAllocated = 1 << 4, // Memory may be allocated by the driver when it is required + Protected = 1 << 5, // Memory is protected + DeviceCoherentAMD = 1 << 6, + DeviceUncachedAMD = 1 << 7, + RdmaCapableNV = 1 << 8, +} + +typealias VkMemoryPropertyFlags = VkMemoryPropertyFlagBits; + +[CRepr] struct VkMemoryType : this() +{ + public VkMemoryPropertyFlags propertyFlags = default; // Memory properties of this memory type + public uint32 heapIndex = 0; // Index of the memory heap allocations of this memory type are taken from +} + +struct VkPhysicalDevice : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PHYSICAL_DEVICE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkPhysicalDeviceFeatures : this() +{ + public VkBool32 robustBufferAccess = false; // out of bounds buffer accesses are well defined + public VkBool32 fullDrawIndexUint32 = false; // full 32-bit range of indices for indexed draw calls + public VkBool32 imageCubeArray = false; // image views which are arrays of cube maps + public VkBool32 independentBlend = false; // blending operations are controlled per-attachment + public VkBool32 geometryShader = false; // geometry stage + public VkBool32 tessellationShader = false; // tessellation control and evaluation stage + public VkBool32 sampleRateShading = false; // per-sample shading and interpolation + public VkBool32 dualSrcBlend = false; // blend operations which take two sources + public VkBool32 logicOp = false; // logic operations + public VkBool32 multiDrawIndirect = false; // multi draw indirect + public VkBool32 drawIndirectFirstInstance = false; // indirect drawing can use non-zero firstInstance + public VkBool32 depthClamp = false; // depth clamping + public VkBool32 depthBiasClamp = false; // depth bias clamping + public VkBool32 fillModeNonSolid = false; // point and wireframe fill modes + public VkBool32 depthBounds = false; // depth bounds test + public VkBool32 wideLines = false; // lines with width greater than 1 + public VkBool32 largePoints = false; // points with size greater than 1 + public VkBool32 alphaToOne = false; // the fragment alpha component can be forced to maximum representable alpha value + public VkBool32 multiViewport = false; // viewport arrays + public VkBool32 samplerAnisotropy = false; // anisotropic sampler filtering + public VkBool32 textureCompressionETC2 = false; // ETC texture compression formats + public VkBool32 textureCompressionASTC_LDR = false; // ASTC LDR texture compression formats + public VkBool32 textureCompressionBC = false; // BC1-7 texture compressed formats + public VkBool32 occlusionQueryPrecise = false; // precise occlusion queries returning actual sample counts + public VkBool32 pipelineStatisticsQuery = false; // pipeline statistics query + public VkBool32 vertexPipelineStoresAndAtomics = false; // stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages + public VkBool32 fragmentStoresAndAtomics = false; // stores and atomic ops on storage buffers and images are supported in the fragment stage + public VkBool32 shaderTessellationAndGeometryPointSize = false; // tessellation and geometry stages can export point size + public VkBool32 shaderImageGatherExtended = false; // image gather with runtime values and independent offsets + public VkBool32 shaderStorageImageExtendedFormats = false; // the extended set of formats can be used for storage images + public VkBool32 shaderStorageImageMultisample = false; // multisample images can be used for storage images + public VkBool32 shaderStorageImageReadWithoutFormat = false; // read from storage image does not require format qualifier + public VkBool32 shaderStorageImageWriteWithoutFormat = false; // write to storage image does not require format qualifier + public VkBool32 shaderUniformBufferArrayDynamicIndexing = false; // arrays of uniform buffers can be accessed with dynamically uniform indices + public VkBool32 shaderSampledImageArrayDynamicIndexing = false; // arrays of sampled images can be accessed with dynamically uniform indices + public VkBool32 shaderStorageBufferArrayDynamicIndexing = false; // arrays of storage buffers can be accessed with dynamically uniform indices + public VkBool32 shaderStorageImageArrayDynamicIndexing = false; // arrays of storage images can be accessed with dynamically uniform indices + public VkBool32 shaderClipDistance = false; // clip distance in shaders + public VkBool32 shaderCullDistance = false; // cull distance in shaders + public VkBool32 shaderFloat64 = false; // 64-bit floats (doubles) in shaders + public VkBool32 shaderInt64 = false; // 64-bit integers in shaders + public VkBool32 shaderInt16 = false; // 16-bit integers in shaders + public VkBool32 shaderResourceResidency = false; // shader can use texture operations that return resource residency information (requires sparseNonResident support) + public VkBool32 shaderResourceMinLod = false; // shader can use texture operations that specify minimum resource LOD + public VkBool32 sparseBinding = false; // Sparse resources support: Resource memory can be managed at opaque page level rather than object level + public VkBool32 sparseResidencyBuffer = false; // Sparse resources support: GPU can access partially resident buffers + public VkBool32 sparseResidencyImage2D = false; // Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images + public VkBool32 sparseResidencyImage3D = false; // Sparse resources support: GPU can access partially resident 3D images + public VkBool32 sparseResidency2Samples = false; // Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples + public VkBool32 sparseResidency4Samples = false; // Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples + public VkBool32 sparseResidency8Samples = false; // Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples + public VkBool32 sparseResidency16Samples = false; // Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples + public VkBool32 sparseResidencyAliased = false; // Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) + public VkBool32 variableMultisampleRate = false; // multisample rate must be the same for all pipelines in a subpass + public VkBool32 inheritedQueries = false; // Queries may be inherited from primary to secondary command buffers + + public this(VkBool32 robustBufferAccess, VkBool32 fullDrawIndexUint32, VkBool32 imageCubeArray, VkBool32 independentBlend, VkBool32 geometryShader, VkBool32 tessellationShader, VkBool32 sampleRateShading, VkBool32 dualSrcBlend, VkBool32 logicOp, VkBool32 multiDrawIndirect, VkBool32 drawIndirectFirstInstance, VkBool32 depthClamp, VkBool32 depthBiasClamp, VkBool32 fillModeNonSolid, VkBool32 depthBounds, VkBool32 wideLines, VkBool32 largePoints, VkBool32 alphaToOne, VkBool32 multiViewport, VkBool32 samplerAnisotropy, VkBool32 textureCompressionETC2, VkBool32 textureCompressionASTC_LDR, VkBool32 textureCompressionBC, VkBool32 occlusionQueryPrecise, VkBool32 pipelineStatisticsQuery, VkBool32 vertexPipelineStoresAndAtomics, VkBool32 fragmentStoresAndAtomics, VkBool32 shaderTessellationAndGeometryPointSize, VkBool32 shaderImageGatherExtended, VkBool32 shaderStorageImageExtendedFormats, VkBool32 shaderStorageImageMultisample, VkBool32 shaderStorageImageReadWithoutFormat, VkBool32 shaderStorageImageWriteWithoutFormat, VkBool32 shaderUniformBufferArrayDynamicIndexing, VkBool32 shaderSampledImageArrayDynamicIndexing, VkBool32 shaderStorageBufferArrayDynamicIndexing, VkBool32 shaderStorageImageArrayDynamicIndexing, VkBool32 shaderClipDistance, VkBool32 shaderCullDistance, VkBool32 shaderFloat64, VkBool32 shaderInt64, VkBool32 shaderInt16, VkBool32 shaderResourceResidency, VkBool32 shaderResourceMinLod, VkBool32 sparseBinding, VkBool32 sparseResidencyBuffer, VkBool32 sparseResidencyImage2D, VkBool32 sparseResidencyImage3D, VkBool32 sparseResidency2Samples, VkBool32 sparseResidency4Samples, VkBool32 sparseResidency8Samples, VkBool32 sparseResidency16Samples, VkBool32 sparseResidencyAliased, VkBool32 variableMultisampleRate, VkBool32 inheritedQueries) : this() + { + this.robustBufferAccess = robustBufferAccess; + this.fullDrawIndexUint32 = fullDrawIndexUint32; + this.imageCubeArray = imageCubeArray; + this.independentBlend = independentBlend; + this.geometryShader = geometryShader; + this.tessellationShader = tessellationShader; + this.sampleRateShading = sampleRateShading; + this.dualSrcBlend = dualSrcBlend; + this.logicOp = logicOp; + this.multiDrawIndirect = multiDrawIndirect; + this.drawIndirectFirstInstance = drawIndirectFirstInstance; + this.depthClamp = depthClamp; + this.depthBiasClamp = depthBiasClamp; + this.fillModeNonSolid = fillModeNonSolid; + this.depthBounds = depthBounds; + this.wideLines = wideLines; + this.largePoints = largePoints; + this.alphaToOne = alphaToOne; + this.multiViewport = multiViewport; + this.samplerAnisotropy = samplerAnisotropy; + this.textureCompressionETC2 = textureCompressionETC2; + this.textureCompressionASTC_LDR = textureCompressionASTC_LDR; + this.textureCompressionBC = textureCompressionBC; + this.occlusionQueryPrecise = occlusionQueryPrecise; + this.pipelineStatisticsQuery = pipelineStatisticsQuery; + this.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics; + this.fragmentStoresAndAtomics = fragmentStoresAndAtomics; + this.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize; + this.shaderImageGatherExtended = shaderImageGatherExtended; + this.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats; + this.shaderStorageImageMultisample = shaderStorageImageMultisample; + this.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat; + this.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat; + this.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing; + this.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing; + this.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing; + this.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing; + this.shaderClipDistance = shaderClipDistance; + this.shaderCullDistance = shaderCullDistance; + this.shaderFloat64 = shaderFloat64; + this.shaderInt64 = shaderInt64; + this.shaderInt16 = shaderInt16; + this.shaderResourceResidency = shaderResourceResidency; + this.shaderResourceMinLod = shaderResourceMinLod; + this.sparseBinding = sparseBinding; + this.sparseResidencyBuffer = sparseResidencyBuffer; + this.sparseResidencyImage2D = sparseResidencyImage2D; + this.sparseResidencyImage3D = sparseResidencyImage3D; + this.sparseResidency2Samples = sparseResidency2Samples; + this.sparseResidency4Samples = sparseResidency4Samples; + this.sparseResidency8Samples = sparseResidency8Samples; + this.sparseResidency16Samples = sparseResidency16Samples; + this.sparseResidencyAliased = sparseResidencyAliased; + this.variableMultisampleRate = variableMultisampleRate; + this.inheritedQueries = inheritedQueries; + } +} + +[CRepr] struct VkPhysicalDeviceLimits : this() +{ + + public uint32 maxImageDimension1D = 0; // max 1D image dimension + public uint32 maxImageDimension2D = 0; // max 2D image dimension + public uint32 maxImageDimension3D = 0; // max 3D image dimension + public uint32 maxImageDimensionCube = 0; // max cube map image dimension + public uint32 maxImageArrayLayers = 0; // max layers for image arrays + public uint32 maxTexelBufferElements = 0; // max texel buffer size (fstexels) + public uint32 maxUniformBufferRange = 0; // max uniform buffer range (bytes) + public uint32 maxStorageBufferRange = 0; // max storage buffer range (bytes) + public uint32 maxPushConstantsSize = 0; // max size of the push constants pool (bytes) + + public uint32 maxMemoryAllocationCount = 0; // max number of device memory allocations supported + public uint32 maxSamplerAllocationCount = 0; // max number of samplers that can be allocated on a device + public VkDeviceSize bufferImageGranularity = default; // Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage + public VkDeviceSize sparseAddressSpaceSize = default; // Total address space available for sparse allocations (bytes) + + public uint32 maxBoundDescriptorSets = 0; // max number of descriptors sets that can be bound to a pipeline + public uint32 maxPerStageDescriptorSamplers = 0; // max number of samplers allowed per-stage in a descriptor set + public uint32 maxPerStageDescriptorUniformBuffers = 0; // max number of uniform buffers allowed per-stage in a descriptor set + public uint32 maxPerStageDescriptorStorageBuffers = 0; // max number of storage buffers allowed per-stage in a descriptor set + public uint32 maxPerStageDescriptorSampledImages = 0; // max number of sampled images allowed per-stage in a descriptor set + public uint32 maxPerStageDescriptorStorageImages = 0; // max number of storage images allowed per-stage in a descriptor set + public uint32 maxPerStageDescriptorInputAttachments = 0; // max number of input attachments allowed per-stage in a descriptor set + public uint32 maxPerStageResources = 0; // max number of resources allowed by a single stage + public uint32 maxDescriptorSetSamplers = 0; // max number of samplers allowed in all stages in a descriptor set + public uint32 maxDescriptorSetUniformBuffers = 0; // max number of uniform buffers allowed in all stages in a descriptor set + public uint32 maxDescriptorSetUniformBuffersDynamic = 0; // max number of dynamic uniform buffers allowed in all stages in a descriptor set + public uint32 maxDescriptorSetStorageBuffers = 0; // max number of storage buffers allowed in all stages in a descriptor set + public uint32 maxDescriptorSetStorageBuffersDynamic = 0; // max number of dynamic storage buffers allowed in all stages in a descriptor set + public uint32 maxDescriptorSetSampledImages = 0; // max number of sampled images allowed in all stages in a descriptor set + public uint32 maxDescriptorSetStorageImages = 0; // max number of storage images allowed in all stages in a descriptor set + public uint32 maxDescriptorSetInputAttachments = 0; // max number of input attachments allowed in all stages in a descriptor set + + public uint32 maxVertexInputAttributes = 0; // max number of vertex input attribute slots + public uint32 maxVertexInputBindings = 0; // max number of vertex input binding slots + public uint32 maxVertexInputAttributeOffset = 0; // max vertex input attribute offset added to vertex buffer offset + public uint32 maxVertexInputBindingStride = 0; // max vertex input binding stride + public uint32 maxVertexOutputComponents = 0; // max number of output components written by vertex shader + + public uint32 maxTessellationGenerationLevel = 0; // max level supported by tessellation primitive generator + public uint32 maxTessellationPatchSize = 0; // max patch size (vertices) + public uint32 maxTessellationControlPerVertexInputComponents = 0; // max number of input components per-vertex in TCS + public uint32 maxTessellationControlPerVertexOutputComponents = 0; // max number of output components per-vertex in TCS + public uint32 maxTessellationControlPerPatchOutputComponents = 0; // max number of output components per-patch in TCS + public uint32 maxTessellationControlTotalOutputComponents = 0; // max total number of per-vertex and per-patch output components in TCS + + public uint32 maxTessellationEvaluationInputComponents = 0; // max number of input components per vertex in TES + public uint32 maxTessellationEvaluationOutputComponents = 0; // max number of output components per vertex in TES + + public uint32 maxGeometryShaderInvocations = 0; // max invocation count supported in geometry shader + public uint32 maxGeometryInputComponents = 0; // max number of input components read in geometry stage + public uint32 maxGeometryOutputComponents = 0; // max number of output components written in geometry stage + public uint32 maxGeometryOutputVertices = 0; // max number of vertices that can be emitted in geometry stage + public uint32 maxGeometryTotalOutputComponents = 0; // max total number of components (all vertices) written in geometry stage + + public uint32 maxFragmentInputComponents = 0; // max number of input components read in fragment stage + public uint32 maxFragmentOutputAttachments = 0; // max number of output attachments written in fragment stage + public uint32 maxFragmentDualSrcAttachments = 0; // max number of output attachments written when using dual source blending + public uint32 maxFragmentCombinedOutputResources = 0; // max total number of storage buffers, storage images and output buffers + + public uint32 maxComputeSharedMemorySize = 0; // max total storage size of work group local storage (bytes) + public uint32[3] maxComputeWorkGroupCount = .(); // max num of compute work groups that may be dispatched by a single command (x,y,z) + public uint32 maxComputeWorkGroupInvocations = 0; // max total compute invocations in a single local work group + public uint32[3] maxComputeWorkGroupSize = .(); // max local size of a compute work group (x,y,z) + public uint32 subPixelPrecisionBits = 0; // number bits of subpixel precision in screen x and y + public uint32 subTexelPrecisionBits = 0; // number bits of precision for selecting texel weights + public uint32 mipmapPrecisionBits = 0; // number bits of precision for selecting mipmap weights + public uint32 maxDrawIndexedIndexValue = 0; // max index value for indexed draw calls (for 32-bit indices) + public uint32 maxDrawIndirectCount = 0; // max draw count for indirect drawing calls + public float maxSamplerLodBias = 0; // max absolute sampler LOD bias + public float maxSamplerAnisotropy = 0; // max degree of sampler anisotropy + public uint32 maxViewports = 0; // max number of active viewports + public uint32[2] maxViewportDimensions = .(); // max viewport dimensions (x,y) + public float[2] viewportBoundsRange = .(); // viewport bounds range (min,max) + public uint32 viewportSubPixelBits = 0; // number bits of subpixel precision for viewport + public c_size minMemoryMapAlignment = 0; // min required alignment of pointers returned by MapMemory (bytes) + public VkDeviceSize minTexelBufferOffsetAlignment = default; // min required alignment for texel buffer offsets (bytes) + public VkDeviceSize minUniformBufferOffsetAlignment = default; // min required alignment for uniform buffer sizes and offsets (bytes) + public VkDeviceSize minStorageBufferOffsetAlignment = default; // min required alignment for storage buffer offsets (bytes) + public int32 minTexelOffset = 0; // min texel offset for OpTextureSampleOffset + public uint32 maxTexelOffset = 0; // max texel offset for OpTextureSampleOffset + public int32 minTexelGatherOffset = 0; // min texel offset for OpTextureGatherOffset + public uint32 maxTexelGatherOffset = 0; // max texel offset for OpTextureGatherOffset + public float minInterpolationOffset = 0; // furthest negative offset for interpolateAtOffset + public float maxInterpolationOffset = 0; // furthest positive offset for interpolateAtOffset + public uint32 subPixelInterpolationOffsetBits = 0; // number of subpixel bits for interpolateAtOffset + public uint32 maxFramebufferWidth = 0; // max width for a framebuffer + public uint32 maxFramebufferHeight = 0; // max height for a framebuffer + public uint32 maxFramebufferLayers = 0; // max layer count for a layered framebuffer + public VkSampleCountFlags framebufferColorSampleCounts = default; // supported color sample counts for a framebuffer + public VkSampleCountFlags framebufferDepthSampleCounts = default; // supported depth sample counts for a framebuffer + public VkSampleCountFlags framebufferStencilSampleCounts = default; // supported stencil sample counts for a framebuffer + public VkSampleCountFlags framebufferNoAttachmentsSampleCounts = default; // supported sample counts for a subpass which uses no attachments + public uint32 maxColorAttachments = 0; // max number of color attachments per subpass + public VkSampleCountFlags sampledImageColorSampleCounts = default; // supported color sample counts for a non-integer sampled image + public VkSampleCountFlags sampledImageIntegerSampleCounts = default; // supported sample counts for an integer image + public VkSampleCountFlags sampledImageDepthSampleCounts = default; // supported depth sample counts for a sampled image + public VkSampleCountFlags sampledImageStencilSampleCounts = default; // supported stencil sample counts for a sampled image + public VkSampleCountFlags storageImageSampleCounts = default; // supported sample counts for a storage image + public uint32 maxSampleMaskWords = 0; // max number of sample mask words + public VkBool32 timestampComputeAndGraphics = false; // timestamps on graphics and compute queues + public float timestampPeriod = 0; // number of nanoseconds it takes for timestamp query value to increment by 1 + public uint32 maxClipDistances = 0; // max number of clip distances + public uint32 maxCullDistances = 0; // max number of cull distances + public uint32 maxCombinedClipAndCullDistances = 0; // max combined number of user clipping + public uint32 discreteQueuePriorities = 0; // distinct queue priorities available + public float[2] pointSizeRange = .(); // range (min,max) of supported point sizes + public float[2] lineWidthRange = .(); // range (min,max) of supported line widths + public float pointSizeGranularity = 0; // granularity of supported point sizes + public float lineWidthGranularity = 0; // granularity of supported line widths + public VkBool32 strictLines = false; // line rasterization follows preferred rules + public VkBool32 standardSampleLocations = false; // supports standard sample locations for all supported sample counts + public VkDeviceSize optimalBufferCopyOffsetAlignment = default; // optimal offset of buffer copies + public VkDeviceSize optimalBufferCopyRowPitchAlignment = default; // optimal pitch of buffer copies + public VkDeviceSize nonCoherentAtomSize = default; // minimum size and alignment for non-coherent host-mapped device memory access +} + +[CRepr] struct VkPhysicalDeviceMemoryProperties : this() +{ + public uint32 memoryTypeCount = 0; + public VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes = .(); + public Span memoryTypesSpan + { + get mut { return .(&memoryTypes, (.)memoryTypeCount); } + set mut { value.CopyTo(memoryTypes); memoryTypeCount = (.)value.Length; } + } + public uint32 memoryHeapCount = 0; + public VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps = .(); + public Span memoryHeapsSpan + { + get mut { return .(&memoryHeaps, (.)memoryHeapCount); } + set mut { value.CopyTo(memoryHeaps); memoryHeapCount = (.)value.Length; } + } +} + +[CRepr] struct VkPhysicalDeviceProperties : this() +{ + public uint32 apiVersion = 0; + public uint32 driverVersion = 0; + public uint32 vendorID = 0; + public uint32 deviceID = 0; + public VkPhysicalDeviceType deviceType = default; + public char8[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName = .(); + public uint8[VK_UUID_SIZE] pipelineCacheUUID = .(); + public VkPhysicalDeviceLimits limits = default; + public VkPhysicalDeviceSparseProperties sparseProperties = default; +} + +[CRepr] struct VkPhysicalDeviceSparseProperties : this() +{ + public VkBool32 residencyStandard2DBlockShape = false; // Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) + public VkBool32 residencyStandard2DMultisampleBlockShape = false; // Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) + public VkBool32 residencyStandard3DBlockShape = false; // Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) + public VkBool32 residencyAlignedMipSize = false; // Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail + public VkBool32 residencyNonResidentStrict = false; // Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded +} + +[AllowDuplicates] enum VkPhysicalDeviceType : int32 +{ + [NoShow] VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + [NoShow] VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + [NoShow] VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + [NoShow] VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + [NoShow] VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + // pretty names + Other = 0, + IntegratedGpu = 1, + DiscreteGpu = 2, + VirtualGpu = 3, + Cpu = 4, +} + +[CRepr] struct VkQueueFamilyProperties : this() +{ + public VkQueueFlags queueFlags = default; // Queue flags + public uint32 queueCount = 0; + public uint32 timestampValidBits = 0; + public VkExtent3D minImageTransferGranularity = default; // Minimum alignment requirement for image transfers +} + +[AllowDuplicates] enum VkQueueFlagBits : int32 +{ + [NoShow] VK_QUEUE_GRAPHICS_BIT = 1 << 0, // Queue supports graphics operations + [NoShow] VK_QUEUE_COMPUTE_BIT = 1 << 1, // Queue supports compute operations + [NoShow] VK_QUEUE_TRANSFER_BIT = 1 << 2, // Queue supports transfer operations + [NoShow] VK_QUEUE_SPARSE_BINDING_BIT = 1 << 3, // Queue supports sparse resource memory management operations + [NoShow] VK_QUEUE_PROTECTED_BIT = 1 << 4, // Queues may support protected operations + [NoShow] VK_QUEUE_VIDEO_DECODE_BIT_KHR = 1 << 5, + [NoShow] VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 1 << 6, + [NoShow] VK_QUEUE_OPTICAL_FLOW_BIT_NV = 1 << 8, + [NoShow] VK_QUEUE_DATA_GRAPH_BIT_ARM = 1 << 10, + // pretty names + Graphics = 1 << 0, // Queue supports graphics operations + Compute = 1 << 1, // Queue supports compute operations + Transfer = 1 << 2, // Queue supports transfer operations + SparseBinding = 1 << 3, // Queue supports sparse resource memory management operations + Protected = 1 << 4, // Queues may support protected operations + VideoDecodeKHR = 1 << 5, + VideoEncodeKHR = 1 << 6, + OpticalFlowNV = 1 << 8, + DataGraphARM = 1 << 10, +} + +typealias VkQueueFlags = VkQueueFlagBits; + +[AllowDuplicates] enum VkSampleCountFlagBits : int32 +{ + [NoShow] VK_SAMPLE_COUNT_1_BIT = 1 << 0, // Sample count 1 supported + [NoShow] VK_SAMPLE_COUNT_2_BIT = 1 << 1, // Sample count 2 supported + [NoShow] VK_SAMPLE_COUNT_4_BIT = 1 << 2, // Sample count 4 supported + [NoShow] VK_SAMPLE_COUNT_8_BIT = 1 << 3, // Sample count 8 supported + [NoShow] VK_SAMPLE_COUNT_16_BIT = 1 << 4, // Sample count 16 supported + [NoShow] VK_SAMPLE_COUNT_32_BIT = 1 << 5, // Sample count 32 supported + [NoShow] VK_SAMPLE_COUNT_64_BIT = 1 << 6, // Sample count 64 supported + // pretty names + _1 = 1 << 0, // Sample count 1 supported + _2 = 1 << 1, // Sample count 2 supported + _4 = 1 << 2, // Sample count 4 supported + _8 = 1 << 3, // Sample count 8 supported + _16 = 1 << 4, // Sample count 16 supported + _32 = 1 << 5, // Sample count 32 supported + _64 = 1 << 6, // Sample count 64 supported +} + +typealias VkSampleCountFlags = VkSampleCountFlagBits; + +[AllowDuplicates] enum VkSystemAllocationScope : int32 +{ + [NoShow] VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + [NoShow] VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + [NoShow] VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + [NoShow] VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + [NoShow] VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + // pretty names + Command = 0, + Object = 1, + Cache = 2, + Device = 3, + Instance = 4, +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateInstance(VkInstanceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkInstance pInstance); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyInstance(VkInstance instance = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumeratePhysicalDevices(VkInstance instance, out uint32 pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceFeatures pFeatures); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, out VkFormatProperties pFormatProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, out VkImageFormatProperties pImageFormatProperties); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceProperties pProperties); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, out uint32 pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceMemoryProperties pMemoryProperties); +[CallingConvention(VKAPI_PTR)] function PFN_vkVoidFunction PFN_vkGetInstanceProcAddr(VkInstance instance, char8* pName); +[CallingConvention(VKAPI_PTR)] function PFN_vkVoidFunction PFN_vkGetDeviceProcAddr(VkDevice device, char8* pName); + +// Device commands +struct VkDevice : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DEVICE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkDeviceCreateFlags = VkFlags; + +[CRepr] struct VkDeviceCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceCreateFlags flags = default; + public uint32 queueCreateInfoCount = 0; + public VkDeviceQueueCreateInfo* pQueueCreateInfos = null; + public Span queueCreateInfos + { + get { return .(pQueueCreateInfos, (.)queueCreateInfoCount); } + set mut { pQueueCreateInfos = value.Ptr; queueCreateInfoCount = (.)value.Length; } + } + public uint32 enabledLayerCount = 0; + public char8** ppEnabledLayerNames = null; // Ordered list of layer names to be enabled + public uint32 enabledExtensionCount = 0; + public char8** ppEnabledExtensionNames = null; + public VkPhysicalDeviceFeatures* pEnabledFeatures = null; + + public this(void* pNext, VkDeviceCreateFlags flags, Span queueCreateInfos, uint32 enabledLayerCount, char8** ppEnabledLayerNames, uint32 enabledExtensionCount, char8** ppEnabledExtensionNames, 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.pEnabledFeatures = pEnabledFeatures; + } +} + +typealias VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlagBits; + +[CRepr] struct VkDeviceQueueCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceQueueCreateFlags flags = default; + public uint32 queueFamilyIndex = 0; + public uint32 queueCount = 0; + public float* pQueuePriorities = null; + public Span queuePriorities + { + get { return .(pQueuePriorities, (.)queueCount); } + set mut { pQueuePriorities = value.Ptr; queueCount = (.)value.Length; } + } + + public this(void* pNext, VkDeviceQueueCreateFlags flags, uint32 queueFamilyIndex, Span queuePriorities) : this() + { + this.pNext = pNext; + this.flags = flags; + this.queueFamilyIndex = queueFamilyIndex; + this.queuePriorities = queuePriorities; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDevice(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDevice pDevice); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDevice(VkDevice device = null, VkAllocationCallbacks* pAllocator = null); + +// Extension discovery commands +[CRepr] struct VkExtensionProperties : this() +{ + public char8[VK_MAX_EXTENSION_NAME_SIZE] extensionName = .(); // extension name + public uint32 specVersion = 0; // version of the extension specification implemented +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumerateInstanceExtensionProperties(char8* pLayerName, out uint32 pPropertyCount, VkExtensionProperties* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, char8* pLayerName, out uint32 pPropertyCount, VkExtensionProperties* pProperties = null); + +// Layer discovery commands +[CRepr] struct VkLayerProperties : this() +{ + public char8[VK_MAX_EXTENSION_NAME_SIZE] layerName = .(); // layer name + public uint32 specVersion = 0; // version of the layer specification implemented + public uint32 implementationVersion = 0; // build or release version of the layer's library + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); // Free-form description of the layer +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumerateInstanceLayerProperties(out uint32 pPropertyCount, VkLayerProperties* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkLayerProperties* pProperties = null); + +// Queue commands +[AllowDuplicates] enum VkPipelineStageFlagBits : int32 +{ + [NoShow] VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1 << 0, // Before subsequent commands are processed + [NoShow] VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 1 << 1, // Draw/DispatchIndirect command fetch + [NoShow] VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 1 << 2, // Vertex/index fetch + [NoShow] VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 1 << 3, // Vertex shading + [NoShow] VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 1 << 4, // Tessellation control shading + [NoShow] VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 1 << 5, // Tessellation evaluation shading + [NoShow] VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 1 << 6, // Geometry shading + [NoShow] VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 1 << 7, // Fragment shading + [NoShow] VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 1 << 8, // Early fragment (depth and stencil) tests + [NoShow] VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 1 << 9, // Late fragment (depth and stencil) tests + [NoShow] VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1 << 10, // Color attachment writes + [NoShow] VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 1 << 11, // Compute shading + [NoShow] VK_PIPELINE_STAGE_TRANSFER_BIT = 1 << 12, // Transfer/copy operations + [NoShow] VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 1 << 13, // After previous commands have completed + [NoShow] VK_PIPELINE_STAGE_HOST_BIT = 1 << 14, // Indicates host (CPU) is a source/sink of the dependency + [NoShow] VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 1 << 15, // All stages of the graphics pipeline + [NoShow] VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 1 << 16, // All stages supported on the queue + [NoShow] VK_PIPELINE_STAGE_NONE = 0, + [NoShow] VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 1 << 24, + [NoShow] VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 1 << 18, // A pipeline stage for conditional rendering predicate fetch + [NoShow] VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 1 << 25, + [NoShow] VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 1 << 21, + [NoShow] VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 1 << 23, + [NoShow] VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 22, + [NoShow] VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + [NoShow] VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 1 << 19, + [NoShow] VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 1 << 20, + [NoShow] VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = 1 << 17, + // pretty names + TopOfPipe = 1 << 0, // Before subsequent commands are processed + DrawIndirect = 1 << 1, // Draw/DispatchIndirect command fetch + VertexInput = 1 << 2, // Vertex/index fetch + VertexShader = 1 << 3, // Vertex shading + TessellationControlShader = 1 << 4, // Tessellation control shading + TessellationEvaluationShader = 1 << 5, // Tessellation evaluation shading + GeometryShader = 1 << 6, // Geometry shading + FragmentShader = 1 << 7, // Fragment shading + EarlyFragmentTests = 1 << 8, // Early fragment (depth and stencil) tests + LateFragmentTests = 1 << 9, // Late fragment (depth and stencil) tests + ColorAttachmentOutput = 1 << 10, // Color attachment writes + ComputeShader = 1 << 11, // Compute shading + Transfer = 1 << 12, // Transfer/copy operations + BottomOfPipe = 1 << 13, // After previous commands have completed + Host = 1 << 14, // Indicates host (CPU) is a source/sink of the dependency + AllGraphics = 1 << 15, // All stages of the graphics pipeline + AllCommands = 1 << 16, // All stages supported on the queue + None = 0, + TransformFeedbackEXT = 1 << 24, + ConditionalRenderingEXT = 1 << 18, // A pipeline stage for conditional rendering predicate fetch + AccelerationStructureBuildKHR = 1 << 25, + RayTracingShaderKHR = 1 << 21, + ShadingRateImageNV = FragmentShadingRateAttachmentKHR, + RayTracingShaderNV = RayTracingShaderKHR, + AccelerationStructureBuildNV = AccelerationStructureBuildKHR, + TaskShaderNV = TaskShaderEXT, + MeshShaderNV = MeshShaderEXT, + FragmentDensityProcessEXT = 1 << 23, + FragmentShadingRateAttachmentKHR = 1 << 22, + CommandPreprocessNV = CommandPreprocessEXT, + NoneKHR = None, + TaskShaderEXT = 1 << 19, + MeshShaderEXT = 1 << 20, + CommandPreprocessEXT = 1 << 17, +} + +typealias VkPipelineStageFlags = VkPipelineStageFlagBits; +struct VkQueue : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_QUEUE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreCount = 0; + public VkSemaphore* pWaitSemaphores = null; + public VkPipelineStageFlags* pWaitDstStageMask = null; + public uint32 commandBufferCount = 0; + public VkCommandBuffer* pCommandBuffers = null; + public Span commandBuffers + { + get { return .(pCommandBuffers, (.)commandBufferCount); } + set mut { pCommandBuffers = value.Ptr; commandBufferCount = (.)value.Length; } + } + public uint32 signalSemaphoreCount = 0; + public VkSemaphore* pSignalSemaphores = null; + public Span signalSemaphores + { + get { return .(pSignalSemaphores, (.)signalSemaphoreCount); } + set mut { pSignalSemaphores = value.Ptr; signalSemaphoreCount = (.)value.Length; } + } + + public this(void* pNext, uint32 waitSemaphoreCount, VkSemaphore* pWaitSemaphores, VkPipelineStageFlags* pWaitDstStageMask, Span commandBuffers = default, Span signalSemaphores = default) : this() + { + this.pNext = pNext; + this.waitSemaphoreCount = waitSemaphoreCount; + this.pWaitSemaphores = pWaitSemaphores; + this.pWaitDstStageMask = pWaitDstStageMask; + this.commandBuffers = commandBuffers; + this.signalSemaphores = signalSemaphores; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceQueue(VkDevice device, uint32 queueFamilyIndex, uint32 queueIndex, out VkQueue pQueue); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueSubmit(VkQueue queue, uint32 submitCount, VkSubmitInfo* pSubmits, VkFence fence = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueWaitIdle(VkQueue queue); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkDeviceWaitIdle(VkDevice device); + +// Memory commands +[CRepr] struct VkMappedMemoryRange : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; // Mapped memory object + public VkDeviceSize offset = default; // Offset within the memory object where the range starts + public VkDeviceSize size = default; // Size of the range within the memory object + + public this(void* pNext, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.memory = memory; + this.offset = offset; + this.size = size; + } +} + +[CRepr] struct VkMemoryAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize allocationSize = default; // Size of memory allocation + public uint32 memoryTypeIndex = 0; // Index of the of the memory type to allocate from + + public this(void* pNext, VkDeviceSize allocationSize, uint32 memoryTypeIndex) : this() + { + this.pNext = pNext; + this.allocationSize = allocationSize; + this.memoryTypeIndex = memoryTypeIndex; + } +} + +[AllowDuplicates] enum VkMemoryMapFlagBits : int32 +{ + [NoShow] VK_MEMORY_MAP_PLACED_BIT_EXT = 1 << 0, + // pretty names + PlacedEXT = 1 << 0, +} + +typealias VkMemoryMapFlags = VkMemoryMapFlagBits; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAllocateMemory(VkDevice device, VkMemoryAllocateInfo* pAllocateInfo, VkAllocationCallbacks* pAllocator, out VkDeviceMemory pMemory); +[CallingConvention(VKAPI_PTR)] function void PFN_vkFreeMemory(VkDevice device, VkDeviceMemory memory = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, out void* ppData); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUnmapMemory(VkDevice device, VkDeviceMemory memory); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkFlushMappedMemoryRanges(VkDevice device, uint32 memoryRangeCount, VkMappedMemoryRange* pMemoryRanges); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkInvalidateMappedMemoryRanges(VkDevice device, uint32 memoryRangeCount, VkMappedMemoryRange* pMemoryRanges); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, out VkDeviceSize pCommittedMemoryInBytes); + +// Memory management API commands +struct VkDeviceMemory : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DEVICE_MEMORY; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkMemoryRequirements : this() +{ + public VkDeviceSize size = default; // Specified in bytes + public VkDeviceSize alignment = default; // Specified in bytes + public uint32 memoryTypeBits = 0; // Bitmask of the allowed memory type indices into memoryTypes[] for this object +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, out VkMemoryRequirements pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageMemoryRequirements(VkDevice device, VkImage image, out VkMemoryRequirements pMemoryRequirements); + +// Sparse resource memory management API commands (optional) +[CRepr] struct VkBindSparseInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreCount = 0; + public VkSemaphore* pWaitSemaphores = null; + public Span waitSemaphores + { + get { return .(pWaitSemaphores, (.)waitSemaphoreCount); } + set mut { pWaitSemaphores = value.Ptr; waitSemaphoreCount = (.)value.Length; } + } + public uint32 bufferBindCount = 0; + public VkSparseBufferMemoryBindInfo* pBufferBinds = null; + public Span bufferBinds + { + get { return .(pBufferBinds, (.)bufferBindCount); } + set mut { pBufferBinds = value.Ptr; bufferBindCount = (.)value.Length; } + } + public uint32 imageOpaqueBindCount = 0; + public VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds = null; + public Span imageOpaqueBinds + { + get { return .(pImageOpaqueBinds, (.)imageOpaqueBindCount); } + set mut { pImageOpaqueBinds = value.Ptr; imageOpaqueBindCount = (.)value.Length; } + } + public uint32 imageBindCount = 0; + public VkSparseImageMemoryBindInfo* pImageBinds = null; + public Span imageBinds + { + get { return .(pImageBinds, (.)imageBindCount); } + set mut { pImageBinds = value.Ptr; imageBindCount = (.)value.Length; } + } + public uint32 signalSemaphoreCount = 0; + public VkSemaphore* pSignalSemaphores = null; + public Span signalSemaphores + { + get { return .(pSignalSemaphores, (.)signalSemaphoreCount); } + set mut { pSignalSemaphores = value.Ptr; signalSemaphoreCount = (.)value.Length; } + } + + public this(void* pNext = null, Span waitSemaphores = default, Span bufferBinds = default, Span imageOpaqueBinds = default, Span imageBinds = default, Span signalSemaphores = default) : this() + { + this.pNext = pNext; + this.waitSemaphores = waitSemaphores; + this.bufferBinds = bufferBinds; + this.imageOpaqueBinds = imageOpaqueBinds; + this.imageBinds = imageBinds; + this.signalSemaphores = signalSemaphores; + } +} + +[AllowDuplicates] enum VkImageAspectFlagBits : int32 +{ + [NoShow] VK_IMAGE_ASPECT_COLOR_BIT = 1 << 0, + [NoShow] VK_IMAGE_ASPECT_DEPTH_BIT = 1 << 1, + [NoShow] VK_IMAGE_ASPECT_STENCIL_BIT = 1 << 2, + [NoShow] VK_IMAGE_ASPECT_METADATA_BIT = 1 << 3, + [NoShow] VK_IMAGE_ASPECT_PLANE_0_BIT = 1 << 4, + [NoShow] VK_IMAGE_ASPECT_PLANE_1_BIT = 1 << 5, + [NoShow] VK_IMAGE_ASPECT_PLANE_2_BIT = 1 << 6, + [NoShow] VK_IMAGE_ASPECT_NONE = 0, + [NoShow] VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + [NoShow] VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + [NoShow] VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + [NoShow] VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 1 << 7, + [NoShow] VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 1 << 8, + [NoShow] VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 1 << 9, + [NoShow] VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 1 << 10, + [NoShow] VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, + // pretty names + Color = 1 << 0, + Depth = 1 << 1, + Stencil = 1 << 2, + Metadata = 1 << 3, + Plane0 = 1 << 4, + Plane1 = 1 << 5, + Plane2 = 1 << 6, + None = 0, + Plane0KHR = Plane0, + Plane1KHR = Plane1, + Plane2KHR = Plane2, + MemoryPlane0EXT = 1 << 7, + MemoryPlane1EXT = 1 << 8, + MemoryPlane2EXT = 1 << 9, + MemoryPlane3EXT = 1 << 10, + NoneKHR = None, +} + +typealias VkImageAspectFlags = VkImageAspectFlagBits; + +[CRepr] struct VkImageSubresource : this() +{ + public VkImageAspectFlags aspectMask = default; + public uint32 mipLevel = 0; + public uint32 arrayLayer = 0; + + public this(VkImageAspectFlags aspectMask, uint32 mipLevel, uint32 arrayLayer) : this() + { + this.aspectMask = aspectMask; + this.mipLevel = mipLevel; + this.arrayLayer = arrayLayer; + } +} + +[CRepr] struct VkSparseBufferMemoryBindInfo : this() +{ + public VkBuffer buffer = null; + public uint32 bindCount = 0; + public VkSparseMemoryBind* pBinds = null; + public Span binds + { + get { return .(pBinds, (.)bindCount); } + set mut { pBinds = value.Ptr; bindCount = (.)value.Length; } + } + + public this(VkBuffer buffer, Span binds) : this() + { + this.buffer = buffer; + this.binds = binds; + } +} + +[AllowDuplicates] enum VkSparseImageFormatFlagBits : int32 +{ + [NoShow] VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1 << 0, // Image uses a single mip tail region for all array layers + [NoShow] VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 1 << 1, // Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels. + [NoShow] VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 1 << 2, // Image uses a non-standard sparse image block dimensions + // pretty names + SingleMiptail = 1 << 0, // Image uses a single mip tail region for all array layers + AlignedMipSize = 1 << 1, // Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels. + NonstandardBlockSize = 1 << 2, // Image uses a non-standard sparse image block dimensions +} + +typealias VkSparseImageFormatFlags = VkSparseImageFormatFlagBits; + +[CRepr] struct VkSparseImageFormatProperties : this() +{ + public VkImageAspectFlags aspectMask = default; + public VkExtent3D imageGranularity = default; + public VkSparseImageFormatFlags flags = default; +} + +[CRepr] struct VkSparseImageMemoryBind : this() +{ + public VkImageSubresource subresource = default; + public VkOffset3D offset = default; + public VkExtent3D extent = default; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; // Specified in bytes + public VkSparseMemoryBindFlags flags = default; + + public this(VkImageSubresource subresource, VkOffset3D offset, VkExtent3D extent, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkSparseMemoryBindFlags flags = default) : this() + { + this.subresource = subresource; + this.offset = offset; + this.extent = extent; + this.memory = memory; + this.memoryOffset = memoryOffset; + this.flags = flags; + } +} + +[CRepr] struct VkSparseImageMemoryBindInfo : this() +{ + public VkImage image = null; + public uint32 bindCount = 0; + public VkSparseImageMemoryBind* pBinds = null; + public Span binds + { + get { return .(pBinds, (.)bindCount); } + set mut { pBinds = value.Ptr; bindCount = (.)value.Length; } + } + + public this(VkImage image, Span binds) : this() + { + this.image = image; + this.binds = binds; + } +} + +[CRepr] struct VkSparseImageMemoryRequirements : this() +{ + public VkSparseImageFormatProperties formatProperties = default; + public uint32 imageMipTailFirstLod = 0; + public VkDeviceSize imageMipTailSize = default; // Specified in bytes, must be a multiple of sparse block size in bytes / alignment + public VkDeviceSize imageMipTailOffset = default; // Specified in bytes, must be a multiple of sparse block size in bytes / alignment + public VkDeviceSize imageMipTailStride = default; // Specified in bytes, must be a multiple of sparse block size in bytes / alignment +} + +[CRepr] struct VkSparseImageOpaqueMemoryBindInfo : this() +{ + public VkImage image = null; + public uint32 bindCount = 0; + public VkSparseMemoryBind* pBinds = null; + public Span binds + { + get { return .(pBinds, (.)bindCount); } + set mut { pBinds = value.Ptr; bindCount = (.)value.Length; } + } + + public this(VkImage image, Span binds) : this() + { + this.image = image; + this.binds = binds; + } +} + +[CRepr] struct VkSparseMemoryBind : this() +{ + public VkDeviceSize resourceOffset = default; // Specified in bytes + public VkDeviceSize size = default; // Specified in bytes + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; // Specified in bytes + public VkSparseMemoryBindFlags flags = default; + + public this(VkDeviceSize resourceOffset, VkDeviceSize size, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkSparseMemoryBindFlags flags = default) : this() + { + this.resourceOffset = resourceOffset; + this.size = size; + this.memory = memory; + this.memoryOffset = memoryOffset; + this.flags = flags; + } +} + +[AllowDuplicates] enum VkSparseMemoryBindFlagBits : int32 +{ + [NoShow] VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1 << 0, // Operation binds resource metadata to memory + // pretty names + Metadata = 1 << 0, // Operation binds resource metadata to memory +} + +typealias VkSparseMemoryBindFlags = VkSparseMemoryBindFlagBits; + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out uint32 pPropertyCount, VkSparseImageFormatProperties* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueBindSparse(VkQueue queue, uint32 bindInfoCount, VkBindSparseInfo* pBindInfo, VkFence fence = null); + +// Fence commands +struct VkFence : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_FENCE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkFenceCreateFlagBits : int32 +{ + [NoShow] VK_FENCE_CREATE_SIGNALED_BIT = 1 << 0, + // pretty names + Signaled = 1 << 0, +} + +typealias VkFenceCreateFlags = VkFenceCreateFlagBits; + +[CRepr] struct VkFenceCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFenceCreateFlags flags = default; // Fence creation flags + + public this(void* pNext = null, VkFenceCreateFlags flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateFence(VkDevice device, VkFenceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyFence(VkDevice device, VkFence fence = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkResetFences(VkDevice device, uint32 fenceCount, VkFence* pFences); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetFenceStatus(VkDevice device, VkFence fence); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWaitForFences(VkDevice device, uint32 fenceCount, VkFence* pFences, VkBool32 waitAll, uint64 timeout); + +// Queue semaphore commands +struct VkSemaphore : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SEMAPHORE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkSemaphoreCreateFlags = VkFlags; + +[CRepr] struct VkSemaphoreCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphoreCreateFlags flags = default; // Semaphore creation flags + + public this(void* pNext = null, VkSemaphoreCreateFlags flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSemaphore(VkDevice device, VkSemaphoreCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSemaphore pSemaphore); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore = null, VkAllocationCallbacks* pAllocator = null); + +// Query commands +struct VkQueryPool : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_QUERY_POOL; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkQueryPoolCreateFlagBits : int32 +{ + [NoShow] VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 1 << 0, + // pretty names + ResetKHR = 1 << 0, +} + +typealias VkQueryPoolCreateFlags = VkQueryPoolCreateFlagBits; + +[CRepr] struct VkQueryPoolCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueryPoolCreateFlags flags = default; + public VkQueryType queryType = default; + public uint32 queryCount = 0; + public VkQueryPipelineStatisticFlags pipelineStatistics = default; // Optional + + public this(void* pNext, VkQueryPoolCreateFlags flags, VkQueryType queryType, uint32 queryCount, VkQueryPipelineStatisticFlags pipelineStatistics = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.queryType = queryType; + this.queryCount = queryCount; + this.pipelineStatistics = pipelineStatistics; + } +} + +[AllowDuplicates] enum VkQueryResultFlagBits : int32 +{ + [NoShow] VK_QUERY_RESULT_64_BIT = 1 << 0, // Results of the queries are written to the destination buffer as 64-bit values + [NoShow] VK_QUERY_RESULT_WAIT_BIT = 1 << 1, // Results of the queries are waited on before proceeding with the result copy + [NoShow] VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 1 << 2, // Besides the results of the query, the availability of the results is also written + [NoShow] VK_QUERY_RESULT_PARTIAL_BIT = 1 << 3, // Copy the partial results of the query even if the final results are not available + [NoShow] VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 1 << 4, + // pretty names + _64 = 1 << 0, // Results of the queries are written to the destination buffer as 64-bit values + Wait = 1 << 1, // Results of the queries are waited on before proceeding with the result copy + WithAvailability = 1 << 2, // Besides the results of the query, the availability of the results is also written + Partial = 1 << 3, // Copy the partial results of the query even if the final results are not available + WithStatusKHR = 1 << 4, +} + +typealias VkQueryResultFlags = VkQueryResultFlagBits; + +[AllowDuplicates] enum VkQueryType : int32 +{ + [NoShow] VK_QUERY_TYPE_OCCLUSION = 0, + [NoShow] VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, // Optional + [NoShow] VK_QUERY_TYPE_TIMESTAMP = 2, + [NoShow] VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, + [NoShow] VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + [NoShow] VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + [NoShow] VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, + [NoShow] VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, + [NoShow] VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + [NoShow] VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, + [NoShow] VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, + [NoShow] VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, + [NoShow] VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, + [NoShow] VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + [NoShow] VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + [NoShow] VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + [NoShow] VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, + // pretty names + Occlusion = 0, + PipelineStatistics = 1, // Optional + Timestamp = 2, + ResultStatusOnlyKHR = 1000023000, + TransformFeedbackStreamEXT = 1000028004, + PerformanceQueryKHR = 1000116000, + AccelerationStructureCompactedSizeKHR = 1000150000, + AccelerationStructureSerializationSizeKHR = 1000150001, + AccelerationStructureCompactedSizeNV = 1000165000, + PerformanceQueryINTEL = 1000210000, + VideoEncodeFeedbackKHR = 1000299000, + MeshPrimitivesGeneratedEXT = 1000328000, + PrimitivesGeneratedEXT = 1000382000, + AccelerationStructureSerializationBottomLevelPointersKHR = 1000386000, + AccelerationStructureSizeKHR = 1000386001, + MicromapSerializationSizeEXT = 1000396000, + MicromapCompactedSizeEXT = 1000396001, +} + +[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); + +// Buffer commands +struct VkBuffer : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_BUFFER; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkBufferCreateFlagBits : int32 +{ + [NoShow] VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1 << 0, // Buffer should support sparse backing + [NoShow] VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 1 << 1, // Buffer should support sparse backing with partial residency + [NoShow] VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 1 << 2, // Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers + [NoShow] VK_BUFFER_CREATE_PROTECTED_BIT = 1 << 3, // Buffer requires protected memory + [NoShow] VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 1 << 4, + [NoShow] VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + [NoShow] VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + [NoShow] VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 1 << 5, + [NoShow] VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 1 << 6, + // pretty names + SparseBinding = 1 << 0, // Buffer should support sparse backing + SparseResidency = 1 << 1, // Buffer should support sparse backing with partial residency + SparseAliased = 1 << 2, // Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers + Protected = 1 << 3, // Buffer requires protected memory + DeviceAddressCaptureReplay = 1 << 4, + DeviceAddressCaptureReplayEXT = DeviceAddressCaptureReplay, + DeviceAddressCaptureReplayKHR = DeviceAddressCaptureReplay, + DescriptorBufferCaptureReplayEXT = 1 << 5, + VideoProfileIndependentKHR = 1 << 6, +} + +typealias VkBufferCreateFlags = VkBufferCreateFlagBits; + +[CRepr] struct VkBufferCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCreateFlags flags = default; // Buffer creation flags + public VkDeviceSize size = default; // Specified in bytes + public VkBufferUsageFlags usage = default; // Buffer usage flags + public VkSharingMode sharingMode = default; + public uint32 queueFamilyIndexCount = 0; + public uint32* pQueueFamilyIndices = null; + public Span queueFamilyIndices + { + get { return .(pQueueFamilyIndices, (.)queueFamilyIndexCount); } + set mut { pQueueFamilyIndices = value.Ptr; queueFamilyIndexCount = (.)value.Length; } + } + + public this(void* pNext, VkBufferCreateFlags flags, VkDeviceSize size, VkBufferUsageFlags usage, VkSharingMode sharingMode, Span queueFamilyIndices = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.size = size; + this.usage = usage; + this.sharingMode = sharingMode; + this.queueFamilyIndices = queueFamilyIndices; + } +} + +[AllowDuplicates] enum VkBufferUsageFlagBits : int32 +{ + [NoShow] VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1 << 0, // Can be used as a source of transfer operations + [NoShow] VK_BUFFER_USAGE_TRANSFER_DST_BIT = 1 << 1, // Can be used as a destination of transfer operations + [NoShow] VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 1 << 2, // Can be used as TBO + [NoShow] VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 1 << 3, // Can be used as IBO + [NoShow] VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 1 << 4, // Can be used as UBO + [NoShow] VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 1 << 5, // Can be used as SSBO + [NoShow] VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 1 << 6, // Can be used as source of fixed-function index fetch (index buffer) + [NoShow] VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 1 << 7, // Can be used as source of fixed-function vertex fetch (VBO) + [NoShow] VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 1 << 8, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) + [NoShow] VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 1 << 17, + [NoShow] VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 1 << 13, + [NoShow] VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 1 << 14, + [NoShow] VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 1 << 11, + [NoShow] VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 1 << 12, + [NoShow] VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 1 << 9, // Specifies the buffer can be used as predicate in conditional rendering + [NoShow] VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 1 << 25, + [NoShow] VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 1 << 19, + [NoShow] VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 1 << 20, + [NoShow] VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 1 << 10, + [NoShow] VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + [NoShow] VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + [NoShow] VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + [NoShow] VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 1 << 15, + [NoShow] VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 1 << 16, + [NoShow] VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 21, + [NoShow] VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 22, + [NoShow] VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 26, + [NoShow] VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 1 << 23, + [NoShow] VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 1 << 24, + [NoShow] VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM = 1 << 27, + // pretty names + TransferSrc = 1 << 0, // Can be used as a source of transfer operations + TransferDst = 1 << 1, // Can be used as a destination of transfer operations + UniformTexelBuffer = 1 << 2, // Can be used as TBO + StorageTexelBuffer = 1 << 3, // Can be used as IBO + UniformBuffer = 1 << 4, // Can be used as UBO + StorageBuffer = 1 << 5, // Can be used as SSBO + IndexBuffer = 1 << 6, // Can be used as source of fixed-function index fetch (index buffer) + VertexBuffer = 1 << 7, // Can be used as source of fixed-function vertex fetch (VBO) + IndirectBuffer = 1 << 8, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) + ShaderDeviceAddress = 1 << 17, + VideoDecodeSrcKHR = 1 << 13, + VideoDecodeDstKHR = 1 << 14, + TransformFeedbackBufferEXT = 1 << 11, + TransformFeedbackCounterBufferEXT = 1 << 12, + ConditionalRenderingEXT = 1 << 9, // Specifies the buffer can be used as predicate in conditional rendering + ExecutionGraphScratchAMDX = 1 << 25, + AccelerationStructureBuildInputReadOnlyKHR = 1 << 19, + AccelerationStructureStorageKHR = 1 << 20, + ShaderBindingTableKHR = 1 << 10, + RayTracingNV = ShaderBindingTableKHR, + ShaderDeviceAddressEXT = ShaderDeviceAddress, + ShaderDeviceAddressKHR = ShaderDeviceAddress, + VideoEncodeDstKHR = 1 << 15, + VideoEncodeSrcKHR = 1 << 16, + SamplerDescriptorBufferEXT = 1 << 21, + ResourceDescriptorBufferEXT = 1 << 22, + PushDescriptorsDescriptorBufferEXT = 1 << 26, + MicromapBuildInputReadOnlyEXT = 1 << 23, + MicromapStorageEXT = 1 << 24, + TileMemoryQCOM = 1 << 27, +} + +typealias VkBufferUsageFlags = VkBufferUsageFlagBits; + +[AllowDuplicates] enum VkSharingMode : int32 +{ + [NoShow] VK_SHARING_MODE_EXCLUSIVE = 0, + [NoShow] VK_SHARING_MODE_CONCURRENT = 1, + // pretty names + Exclusive = 0, + Concurrent = 1, +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateBuffer(VkDevice device, VkBufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBuffer pBuffer); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyBuffer(VkDevice device, VkBuffer buffer = null, VkAllocationCallbacks* pAllocator = null); + +// Image commands +struct VkImage : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_IMAGE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkImageCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCreateFlags flags = default; // Image creation flags + public VkImageType imageType = default; + public VkFormat format = default; + public VkExtent3D extent = default; + public uint32 mipLevels = 0; + public uint32 arrayLayers = 0; + public VkSampleCountFlagBits samples = default; + public VkImageTiling tiling = default; + public VkImageUsageFlags usage = default; // Image usage flags + public VkSharingMode sharingMode = default; // Cross-queue-family sharing mode + public uint32 queueFamilyIndexCount = 0; // Number of queue families to share across + public uint32* pQueueFamilyIndices = null; // Array of queue family indices to share across + public Span queueFamilyIndices + { + get { return .(pQueueFamilyIndices, (.)queueFamilyIndexCount); } + set mut { pQueueFamilyIndices = value.Ptr; queueFamilyIndexCount = (.)value.Length; } + } + public VkImageLayout initialLayout = default; // Initial image layout for all subresources + + public this(void* pNext, VkImageCreateFlags flags, VkImageType imageType, VkFormat format, VkExtent3D extent, uint32 mipLevels, uint32 arrayLayers, VkSampleCountFlagBits samples, VkImageTiling tiling, VkImageUsageFlags usage, VkSharingMode sharingMode, Span queueFamilyIndices, VkImageLayout initialLayout) : this() + { + this.pNext = pNext; + this.flags = flags; + this.imageType = imageType; + this.format = format; + this.extent = extent; + this.mipLevels = mipLevels; + this.arrayLayers = arrayLayers; + this.samples = samples; + this.tiling = tiling; + this.usage = usage; + this.sharingMode = sharingMode; + this.queueFamilyIndices = queueFamilyIndices; + this.initialLayout = initialLayout; + } +} + +[AllowDuplicates] enum VkImageLayout : int32 +{ + [NoShow] VK_IMAGE_LAYOUT_UNDEFINED = 0, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) + [NoShow] VK_IMAGE_LAYOUT_GENERAL = 1, // General layout when image can be used for any kind of access + [NoShow] VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, // Optimal layout when image is only used for color attachment read/write + [NoShow] VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, // Optimal layout when image is only used for depth/stencil attachment read/write + [NoShow] VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, // Optimal layout when image is used for read only depth/stencil attachment and shader access + [NoShow] VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, // Optimal layout when image is used for read only shader access + [NoShow] VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, // Optimal layout when image is used only as source of transfer operations + [NoShow] VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, // Optimal layout when image is used only as destination of transfer operations + [NoShow] VK_IMAGE_LAYOUT_PREINITIALIZED = 8, // Initial layout used when the data is populated by the CPU + [NoShow] VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + [NoShow] VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + [NoShow] VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + [NoShow] VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + [NoShow] VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, + [NoShow] VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ = 1000232000, + [NoShow] VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, + [NoShow] VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + [NoShow] VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + [NoShow] VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + [NoShow] VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, + [NoShow] VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + [NoShow] VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + [NoShow] VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM = 1000460000, + [NoShow] VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, + [NoShow] VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000, + // pretty names + Undefined = 0, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) + General = 1, // General layout when image can be used for any kind of access + ColorAttachmentOptimal = 2, // Optimal layout when image is only used for color attachment read/write + DepthStencilAttachmentOptimal = 3, // Optimal layout when image is only used for depth/stencil attachment read/write + DepthStencilReadOnlyOptimal = 4, // Optimal layout when image is used for read only depth/stencil attachment and shader access + ShaderReadOnlyOptimal = 5, // Optimal layout when image is used for read only shader access + TransferSrcOptimal = 6, // Optimal layout when image is used only as source of transfer operations + TransferDstOptimal = 7, // Optimal layout when image is used only as destination of transfer operations + Preinitialized = 8, // Initial layout used when the data is populated by the CPU + DepthReadOnlyStencilAttachmentOptimal = 1000117000, + DepthAttachmentStencilReadOnlyOptimal = 1000117001, + DepthAttachmentOptimal = 1000241000, + DepthReadOnlyOptimal = 1000241001, + StencilAttachmentOptimal = 1000241002, + StencilReadOnlyOptimal = 1000241003, + ReadOnlyOptimal = 1000314000, + AttachmentOptimal = 1000314001, + RenderingLocalRead = 1000232000, + PresentSrcKHR = 1000001002, + VideoDecodeDstKHR = 1000024000, + VideoDecodeSrcKHR = 1000024001, + VideoDecodeDpbKHR = 1000024002, + SharedPresentKHR = 1000111000, + DepthReadOnlyStencilAttachmentOptimalKHR = DepthReadOnlyStencilAttachmentOptimal, + DepthAttachmentStencilReadOnlyOptimalKHR = DepthAttachmentStencilReadOnlyOptimal, + ShadingRateOptimalNV = FragmentShadingRateAttachmentOptimalKHR, + FragmentDensityMapOptimalEXT = 1000218000, + FragmentShadingRateAttachmentOptimalKHR = 1000164003, + RenderingLocalReadKHR = RenderingLocalRead, + DepthAttachmentOptimalKHR = DepthAttachmentOptimal, + DepthReadOnlyOptimalKHR = DepthReadOnlyOptimal, + StencilAttachmentOptimalKHR = StencilAttachmentOptimal, + StencilReadOnlyOptimalKHR = StencilReadOnlyOptimal, + VideoEncodeDstKHR = 1000299000, + VideoEncodeSrcKHR = 1000299001, + VideoEncodeDpbKHR = 1000299002, + ReadOnlyOptimalKHR = ReadOnlyOptimal, + AttachmentOptimalKHR = AttachmentOptimal, + AttachmentFeedbackLoopOptimalEXT = 1000339000, + TensorAliasingARM = 1000460000, + VideoEncodeQuantizationMapKHR = 1000553000, + ZeroInitializedEXT = 1000620000, +} + +[CRepr] struct VkSubresourceLayout : this() +{ + public VkDeviceSize offset = default; // Specified in bytes + public VkDeviceSize size = default; // Specified in bytes + public VkDeviceSize rowPitch = default; // Specified in bytes + public VkDeviceSize arrayPitch = default; // Specified in bytes + public VkDeviceSize depthPitch = default; // Specified in bytes + + public this(VkDeviceSize offset, VkDeviceSize size, VkDeviceSize rowPitch, VkDeviceSize arrayPitch, VkDeviceSize depthPitch) : this() + { + this.offset = offset; + this.size = size; + this.rowPitch = rowPitch; + this.arrayPitch = arrayPitch; + this.depthPitch = depthPitch; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateImage(VkDevice device, VkImageCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkImage pImage); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyImage(VkDevice device, VkImage image = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageSubresourceLayout(VkDevice device, VkImage image, VkImageSubresource* pSubresource, out VkSubresourceLayout pLayout); + +// Image view commands +[CRepr] struct VkComponentMapping : this() +{ + public VkComponentSwizzle r = default; + public VkComponentSwizzle g = default; + public VkComponentSwizzle b = default; + public VkComponentSwizzle a = default; + + public this(VkComponentSwizzle r, VkComponentSwizzle g, VkComponentSwizzle b, VkComponentSwizzle a) : this() + { + this.r = r; + this.g = g; + this.b = b; + this.a = a; + } +} + +[AllowDuplicates] enum VkComponentSwizzle : int32 +{ + [NoShow] VK_COMPONENT_SWIZZLE_IDENTITY = 0, + [NoShow] VK_COMPONENT_SWIZZLE_ZERO = 1, + [NoShow] VK_COMPONENT_SWIZZLE_ONE = 2, + [NoShow] VK_COMPONENT_SWIZZLE_R = 3, + [NoShow] VK_COMPONENT_SWIZZLE_G = 4, + [NoShow] VK_COMPONENT_SWIZZLE_B = 5, + [NoShow] VK_COMPONENT_SWIZZLE_A = 6, + // pretty names + Identity = 0, + Zero = 1, + One = 2, + R = 3, + G = 4, + B = 5, + A = 6, +} + +[CRepr] struct VkImageSubresourceRange : this() +{ + public VkImageAspectFlags aspectMask = default; + public uint32 baseMipLevel = 0; + public uint32 levelCount = 0; + public uint32 baseArrayLayer = 0; + public uint32 layerCount = 0; + + public this(VkImageAspectFlags aspectMask, uint32 baseMipLevel, uint32 levelCount, uint32 baseArrayLayer, uint32 layerCount) : this() + { + this.aspectMask = aspectMask; + this.baseMipLevel = baseMipLevel; + this.levelCount = levelCount; + this.baseArrayLayer = baseArrayLayer; + this.layerCount = layerCount; + } +} + +struct VkImageView : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_IMAGE_VIEW; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkImageViewCreateFlagBits : int32 +{ + [NoShow] VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 1 << 0, + [NoShow] VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 1 << 2, + [NoShow] VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 1 << 1, + // pretty names + FragmentDensityMapDynamicEXT = 1 << 0, + DescriptorBufferCaptureReplayEXT = 1 << 2, + FragmentDensityMapDeferredEXT = 1 << 1, +} + +typealias VkImageViewCreateFlags = VkImageViewCreateFlagBits; + +[CRepr] struct VkImageViewCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageViewCreateFlags flags = default; + public VkImage image = null; + public VkImageViewType viewType = default; + public VkFormat format = default; + public VkComponentMapping components = default; + public VkImageSubresourceRange subresourceRange = default; + + public this(void* pNext, VkImageViewCreateFlags flags, VkImage image, VkImageViewType viewType, VkFormat format, VkComponentMapping components, VkImageSubresourceRange subresourceRange) : this() + { + this.pNext = pNext; + this.flags = flags; + this.image = image; + this.viewType = viewType; + this.format = format; + this.components = components; + this.subresourceRange = subresourceRange; + } +} + +[AllowDuplicates] enum VkImageViewType : int32 +{ + [NoShow] VK_IMAGE_VIEW_TYPE_1D = 0, + [NoShow] VK_IMAGE_VIEW_TYPE_2D = 1, + [NoShow] VK_IMAGE_VIEW_TYPE_3D = 2, + [NoShow] VK_IMAGE_VIEW_TYPE_CUBE = 3, + [NoShow] VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + [NoShow] VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + [NoShow] VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + // pretty names + _1d = 0, + _2d = 1, + _3d = 2, + Cube = 3, + _1dArray = 4, + _2dArray = 5, + CubeArray = 6, +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateImageView(VkDevice device, VkImageViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkImageView pView); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyImageView(VkDevice device, VkImageView imageView = null, VkAllocationCallbacks* pAllocator = null); + +// Pass commands +[AllowDuplicates] enum VkAccessFlagBits : int32 +{ + [NoShow] VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1 << 0, // Controls coherency of indirect command reads + [NoShow] VK_ACCESS_INDEX_READ_BIT = 1 << 1, // Controls coherency of index reads + [NoShow] VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 1 << 2, // Controls coherency of vertex attribute reads + [NoShow] VK_ACCESS_UNIFORM_READ_BIT = 1 << 3, // Controls coherency of uniform buffer reads + [NoShow] VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 1 << 4, // Controls coherency of input attachment reads + [NoShow] VK_ACCESS_SHADER_READ_BIT = 1 << 5, // Controls coherency of shader reads + [NoShow] VK_ACCESS_SHADER_WRITE_BIT = 1 << 6, // Controls coherency of shader writes + [NoShow] VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 1 << 7, // Controls coherency of color attachment reads + [NoShow] VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 1 << 8, // Controls coherency of color attachment writes + [NoShow] VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 1 << 9, // Controls coherency of depth/stencil attachment reads + [NoShow] VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1 << 10, // Controls coherency of depth/stencil attachment writes + [NoShow] VK_ACCESS_TRANSFER_READ_BIT = 1 << 11, // Controls coherency of transfer reads + [NoShow] VK_ACCESS_TRANSFER_WRITE_BIT = 1 << 12, // Controls coherency of transfer writes + [NoShow] VK_ACCESS_HOST_READ_BIT = 1 << 13, // Controls coherency of host reads + [NoShow] VK_ACCESS_HOST_WRITE_BIT = 1 << 14, // Controls coherency of host writes + [NoShow] VK_ACCESS_MEMORY_READ_BIT = 1 << 15, // Controls coherency of memory reads + [NoShow] VK_ACCESS_MEMORY_WRITE_BIT = 1 << 16, // Controls coherency of memory writes + [NoShow] VK_ACCESS_NONE = 0, + [NoShow] VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 1 << 25, + [NoShow] VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 1 << 26, + [NoShow] VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 1 << 27, + [NoShow] VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 1 << 20, // read access flag for reading conditional rendering predicate + [NoShow] VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 1 << 19, + [NoShow] VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 1 << 21, + [NoShow] VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 1 << 22, + [NoShow] VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + [NoShow] VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + [NoShow] VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + [NoShow] VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 1 << 24, + [NoShow] VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 1 << 23, + [NoShow] VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, + [NoShow] VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT, + [NoShow] VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + [NoShow] VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = 1 << 17, + [NoShow] VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = 1 << 18, + // pretty names + IndirectCommandRead = 1 << 0, // Controls coherency of indirect command reads + IndexRead = 1 << 1, // Controls coherency of index reads + VertexAttributeRead = 1 << 2, // Controls coherency of vertex attribute reads + UniformRead = 1 << 3, // Controls coherency of uniform buffer reads + InputAttachmentRead = 1 << 4, // Controls coherency of input attachment reads + ShaderRead = 1 << 5, // Controls coherency of shader reads + ShaderWrite = 1 << 6, // Controls coherency of shader writes + ColorAttachmentRead = 1 << 7, // Controls coherency of color attachment reads + ColorAttachmentWrite = 1 << 8, // Controls coherency of color attachment writes + DepthStencilAttachmentRead = 1 << 9, // Controls coherency of depth/stencil attachment reads + DepthStencilAttachmentWrite = 1 << 10, // Controls coherency of depth/stencil attachment writes + TransferRead = 1 << 11, // Controls coherency of transfer reads + TransferWrite = 1 << 12, // Controls coherency of transfer writes + HostRead = 1 << 13, // Controls coherency of host reads + HostWrite = 1 << 14, // Controls coherency of host writes + MemoryRead = 1 << 15, // Controls coherency of memory reads + MemoryWrite = 1 << 16, // Controls coherency of memory writes + None = 0, + TransformFeedbackWriteEXT = 1 << 25, + TransformFeedbackCounterReadEXT = 1 << 26, + TransformFeedbackCounterWriteEXT = 1 << 27, + ConditionalRenderingReadEXT = 1 << 20, // read access flag for reading conditional rendering predicate + ColorAttachmentReadNoncoherentEXT = 1 << 19, + AccelerationStructureReadKHR = 1 << 21, + AccelerationStructureWriteKHR = 1 << 22, + ShadingRateImageReadNV = FragmentShadingRateAttachmentReadKHR, + AccelerationStructureReadNV = AccelerationStructureReadKHR, + AccelerationStructureWriteNV = AccelerationStructureWriteKHR, + FragmentDensityMapReadEXT = 1 << 24, + FragmentShadingRateAttachmentReadKHR = 1 << 23, + CommandPreprocessReadNV = CommandPreprocessReadEXT, + CommandPreprocessWriteNV = CommandPreprocessWriteEXT, + NoneKHR = None, + CommandPreprocessReadEXT = 1 << 17, + CommandPreprocessWriteEXT = 1 << 18, +} + +typealias VkAccessFlags = VkAccessFlagBits; + +[AllowDuplicates] enum VkDependencyFlagBits : int32 +{ + [NoShow] VK_DEPENDENCY_BY_REGION_BIT = 1 << 0, // Dependency is per pixel region + [NoShow] VK_DEPENDENCY_DEVICE_GROUP_BIT = 1 << 2, // Dependency is across devices + [NoShow] VK_DEPENDENCY_VIEW_LOCAL_BIT = 1 << 1, + [NoShow] VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + [NoShow] VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + [NoShow] VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 1 << 3, // Dependency may be a feedback loop + [NoShow] VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 1 << 5, + [NoShow] VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 1 << 6, + // pretty names + ByRegion = 1 << 0, // Dependency is per pixel region + DeviceGroup = 1 << 2, // Dependency is across devices + ViewLocal = 1 << 1, + ViewLocalKHR = ViewLocal, + DeviceGroupKHR = DeviceGroup, + FeedbackLoopEXT = 1 << 3, // Dependency may be a feedback loop + QueueFamilyOwnershipTransferUseAllStagesKHR = 1 << 5, + AsymmetricEventKHR = 1 << 6, +} + +typealias VkDependencyFlags = VkDependencyFlagBits; + +// Command pool commands +struct VkCommandPool : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_COMMAND_POOL; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkCommandPoolCreateFlagBits : int32 +{ + [NoShow] VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1 << 0, // Command buffers have a short lifetime + [NoShow] VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 1 << 1, // Command buffers may release their memory individually + [NoShow] VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 1 << 2, // Command buffers allocated from pool are protected command buffers + // pretty names + Transient = 1 << 0, // Command buffers have a short lifetime + ResetCommandBuffer = 1 << 1, // Command buffers may release their memory individually + Protected = 1 << 2, // Command buffers allocated from pool are protected command buffers +} + +typealias VkCommandPoolCreateFlags = VkCommandPoolCreateFlagBits; + +[CRepr] struct VkCommandPoolCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCommandPoolCreateFlags flags = default; // Command pool creation flags + public uint32 queueFamilyIndex = 0; + + public this(void* pNext, VkCommandPoolCreateFlags flags, uint32 queueFamilyIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.queueFamilyIndex = queueFamilyIndex; + } +} + +[AllowDuplicates] enum VkCommandPoolResetFlagBits : int32 +{ + [NoShow] VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1 << 0, // Release resources owned by the pool + // pretty names + ReleaseResources = 1 << 0, // Release resources owned by the pool +} + +typealias VkCommandPoolResetFlags = VkCommandPoolResetFlagBits; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateCommandPool(VkDevice device, VkCommandPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCommandPool pCommandPool); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags = default); + +// Command buffer commands +struct VkCommandBuffer : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_COMMAND_BUFFER; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkCommandBufferAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCommandPool commandPool = null; + public VkCommandBufferLevel level = default; + public uint32 commandBufferCount = 0; + + public this(void* pNext, VkCommandPool commandPool, VkCommandBufferLevel level, uint32 commandBufferCount) : this() + { + this.pNext = pNext; + this.commandPool = commandPool; + this.level = level; + this.commandBufferCount = commandBufferCount; + } +} + +[CRepr] struct VkCommandBufferBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCommandBufferUsageFlags flags = default; // Command buffer usage flags + public VkCommandBufferInheritanceInfo* pInheritanceInfo = null; // Pointer to inheritance info for secondary command buffers + + public this(void* pNext = null, VkCommandBufferUsageFlags flags = default, VkCommandBufferInheritanceInfo* pInheritanceInfo = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pInheritanceInfo = pInheritanceInfo; + } +} + +[CRepr] struct VkCommandBufferInheritanceInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPass renderPass = null; // Render pass for secondary command buffers + public uint32 subpass = 0; + public VkFramebuffer framebuffer = null; // Framebuffer for secondary command buffers + public VkBool32 occlusionQueryEnable = false; // Whether this secondary command buffer may be executed during an occlusion query + public VkQueryControlFlags queryFlags = default; // Query flags used by this secondary command buffer, if executed during an occlusion query + public VkQueryPipelineStatisticFlags pipelineStatistics = default; // Pipeline statistics that may be counted for this secondary command buffer + + public this(void* pNext, VkRenderPass renderPass, uint32 subpass, VkFramebuffer framebuffer, VkBool32 occlusionQueryEnable, VkQueryControlFlags queryFlags = default, VkQueryPipelineStatisticFlags pipelineStatistics = default) : this() + { + this.pNext = pNext; + this.renderPass = renderPass; + this.subpass = subpass; + this.framebuffer = framebuffer; + this.occlusionQueryEnable = occlusionQueryEnable; + this.queryFlags = queryFlags; + this.pipelineStatistics = pipelineStatistics; + } +} + +[AllowDuplicates] enum VkCommandBufferLevel : int32 +{ + [NoShow] VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + [NoShow] VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + // pretty names + Primary = 0, + Secondary = 1, +} + +[AllowDuplicates] enum VkCommandBufferResetFlagBits : int32 +{ + [NoShow] VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1 << 0, // Release resources owned by the buffer + // pretty names + ReleaseResources = 1 << 0, // Release resources owned by the buffer +} + +typealias VkCommandBufferResetFlags = VkCommandBufferResetFlagBits; + +[AllowDuplicates] enum VkCommandBufferUsageFlagBits : int32 +{ + [NoShow] VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1 << 0, + [NoShow] VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 1 << 1, + [NoShow] VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 1 << 2, // Command buffer may be submitted/executed more than once simultaneously + // pretty names + OneTimeSubmit = 1 << 0, + RenderPassContinue = 1 << 1, + SimultaneousUse = 1 << 2, // Command buffer may be submitted/executed more than once simultaneously +} + +typealias VkCommandBufferUsageFlags = VkCommandBufferUsageFlagBits; + +[AllowDuplicates] enum VkQueryControlFlagBits : int32 +{ + [NoShow] VK_QUERY_CONTROL_PRECISE_BIT = 1 << 0, // Require precise results to be collected by the query + // pretty names + Precise = 1 << 0, // Require precise results to be collected by the query +} + +typealias VkQueryControlFlags = VkQueryControlFlagBits; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAllocateCommandBuffers(VkDevice device, VkCommandBufferAllocateInfo* pAllocateInfo, out VkCommandBuffer pCommandBuffers); +[CallingConvention(VKAPI_PTR)] function void PFN_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32 commandBufferCount, VkCommandBuffer* pCommandBuffers); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo* pBeginInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEndCommandBuffer(VkCommandBuffer commandBuffer); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags = default); + +// Command buffer building commands +[CRepr] struct VkBufferCopy : this() +{ + public VkDeviceSize srcOffset = default; // Specified in bytes + public VkDeviceSize dstOffset = default; // Specified in bytes + public VkDeviceSize size = default; // Specified in bytes + + public this(VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size) : this() + { + this.srcOffset = srcOffset; + this.dstOffset = dstOffset; + this.size = size; + } +} + +[CRepr] struct VkBufferImageCopy : this() +{ + public VkDeviceSize bufferOffset = default; // Specified in bytes + public uint32 bufferRowLength = 0; // Specified in texels + public uint32 bufferImageHeight = 0; + public VkImageSubresourceLayers imageSubresource = default; + public VkOffset3D imageOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkExtent3D imageExtent = default; // Specified in pixels for both compressed and uncompressed images + + public this(VkDeviceSize bufferOffset, uint32 bufferRowLength, uint32 bufferImageHeight, VkImageSubresourceLayers imageSubresource, VkOffset3D imageOffset, VkExtent3D imageExtent) : this() + { + this.bufferOffset = bufferOffset; + this.bufferRowLength = bufferRowLength; + this.bufferImageHeight = bufferImageHeight; + this.imageSubresource = imageSubresource; + this.imageOffset = imageOffset; + this.imageExtent = imageExtent; + } +} + +[CRepr] struct VkImageCopy : this() +{ + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D srcOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D dstOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkExtent3D extent = default; // Specified in pixels for both compressed and uncompressed images + + public this(VkImageSubresourceLayers srcSubresource, VkOffset3D srcOffset, VkImageSubresourceLayers dstSubresource, VkOffset3D dstOffset, VkExtent3D extent) : this() + { + this.srcSubresource = srcSubresource; + this.srcOffset = srcOffset; + this.dstSubresource = dstSubresource; + this.dstOffset = dstOffset; + this.extent = extent; + } +} + +[CRepr] struct VkImageSubresourceLayers : this() +{ + public VkImageAspectFlags aspectMask = default; + public uint32 mipLevel = 0; + public uint32 baseArrayLayer = 0; + public uint32 layerCount = 0; + + public this(VkImageAspectFlags aspectMask, uint32 mipLevel, uint32 baseArrayLayer, uint32 layerCount) : this() + { + this.aspectMask = aspectMask; + this.mipLevel = mipLevel; + this.baseArrayLayer = baseArrayLayer; + this.layerCount = layerCount; + } +} + +[AllowDuplicates] enum VkIndexType : int32 +{ + [NoShow] VK_INDEX_TYPE_UINT16 = 0, + [NoShow] VK_INDEX_TYPE_UINT32 = 1, + [NoShow] VK_INDEX_TYPE_UINT8 = 1000265000, + [NoShow] VK_INDEX_TYPE_NONE_KHR = 1000165000, + [NoShow] VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + [NoShow] VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8, + [NoShow] VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8, + // pretty names + Uint16 = 0, + Uint32 = 1, + Uint8 = 1000265000, + NoneKHR = 1000165000, + NoneNV = NoneKHR, + Uint8EXT = Uint8, + Uint8KHR = Uint8, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32 regionCount, VkBufferCopy* pRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageCopy* pRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkBufferImageCopy* pRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32 regionCount, VkBufferImageCopy* pRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void* pData); +// transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32 data); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32 memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32 bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32 imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, VkQueryControlFlags flags = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32 query); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32 commandBufferCount, VkCommandBuffer* pCommandBuffers); + +// Retroactively promoted from VK_EXT_debug_report for compatibility with VulkanSC +// Vulkan compute API interface definitions +// These types are part of the API, though not directly used in API commands or data structures +[CRepr] struct VkDispatchIndirectCommand : this() +{ + public uint32 x = 0; + public uint32 y = 0; + public uint32 z = 0; + + public this(uint32 x, uint32 y, uint32 z) : this() + { + this.x = x; + this.y = y; + this.z = z; + } +} + +[AllowDuplicates] enum VkPipelineCacheHeaderVersion : int32 +{ + [NoShow] VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + [NoShow] VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM = 1000629000, + // pretty names + One = 1, + DataGraphQCOM = 1000629000, +} + +[CRepr] struct VkPipelineCacheHeaderVersionOne : this() +{ + + public uint32 headerSize = 0; + public VkPipelineCacheHeaderVersion headerVersion = default; + public uint32 vendorID = 0; + public uint32 deviceID = 0; + public uint8[VK_UUID_SIZE] pipelineCacheUUID = .(); + + public this(uint32 headerSize, VkPipelineCacheHeaderVersion headerVersion, uint32 vendorID, uint32 deviceID, uint8[VK_UUID_SIZE] pipelineCacheUUID) : this() + { + this.headerSize = headerSize; + this.headerVersion = headerVersion; + this.vendorID = vendorID; + this.deviceID = deviceID; + this.pipelineCacheUUID = pipelineCacheUUID; + } +} + +// Event commands +struct VkEvent : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_EVENT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkEventCreateFlags = VkEventCreateFlagBits; + +[AllowDuplicates] enum VkEventCreateFlagBits : int32 +{ + [NoShow] VK_EVENT_CREATE_DEVICE_ONLY_BIT = 1 << 0, + [NoShow] VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + // pretty names + DeviceOnly = 1 << 0, + DeviceOnlyKHR = DeviceOnly, +} + +[CRepr] struct VkEventCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkEventCreateFlags flags = default; // Event creation flags + + public this(void* pNext = null, VkEventCreateFlags flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateEvent(VkDevice device, VkEventCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkEvent pEvent); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyEvent(VkDevice device, VkEvent event = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetEventStatus(VkDevice device, VkEvent event); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetEvent(VkDevice device, VkEvent event); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkResetEvent(VkDevice device, VkEvent event); + +// Buffer view commands +struct VkBufferView : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_BUFFER_VIEW; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkBufferViewCreateFlags = VkFlags; + +[CRepr] struct VkBufferViewCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferViewCreateFlags flags = default; + public VkBuffer buffer = null; + public VkFormat format = default; // Optionally specifies format of elements + public VkDeviceSize offset = default; // Specified in bytes + public VkDeviceSize range = default; // View size specified in bytes + + public this(void* pNext, VkBufferViewCreateFlags flags, VkBuffer buffer, VkFormat format, VkDeviceSize offset, VkDeviceSize range) : this() + { + this.pNext = pNext; + this.flags = flags; + this.buffer = buffer; + this.format = format; + this.offset = offset; + this.range = range; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateBufferView(VkDevice device, VkBufferViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBufferView pView); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyBufferView(VkDevice device, VkBufferView bufferView = null, VkAllocationCallbacks* pAllocator = null); + +// Shader commands +struct VkShaderModule : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SHADER_MODULE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkShaderModuleCreateFlags = VkFlags; + +[CRepr] struct VkShaderModuleCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; // noautovalidity because this structure can be either an explicit parameter, or passed in a pNext chain + public VkShaderModuleCreateFlags flags = default; + public c_size codeSize = 0; // Specified in bytes + public uint32* pCode = null; // Binary code of size codeSize + + public this(void* pNext, VkShaderModuleCreateFlags flags, c_size codeSize, uint32* pCode) : this() + { + this.pNext = pNext; + this.flags = flags; + this.codeSize = codeSize; + this.pCode = pCode; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateShaderModule(VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkShaderModule pShaderModule); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule = null, VkAllocationCallbacks* pAllocator = null); + +// Pipeline Cache commands +struct VkPipelineCache : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PIPELINE_CACHE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlagBits; + +[CRepr] struct VkPipelineCacheCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCacheCreateFlags flags = default; + public c_size initialDataSize = 0; // Size of initial data to populate cache, in bytes + public void* pInitialData = null; // Initial data to populate cache + public Span initialData + { + get { return .(pInitialData, (.)initialDataSize); } + set mut { pInitialData = value.Ptr; initialDataSize = (.)value.Length; } + } + + public this(void* pNext = null, VkPipelineCacheCreateFlags flags = default, Span initialData = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.initialData = initialData; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreatePipelineCache(VkDevice device, VkPipelineCacheCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineCache pPipelineCache); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, out c_size pDataSize, void* pData = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32 srcCacheCount, VkPipelineCache* pSrcCaches); + +// Compute Pipeline commands +[CRepr] struct VkComputePipelineCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags flags = default; // Pipeline creation flags + public VkPipelineShaderStageCreateInfo stage = default; + public VkPipelineLayout layout = null; // Interface layout of the pipeline + public VkPipeline basePipelineHandle = null; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + public int32 basePipelineIndex = 0; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + public this(void* pNext, VkPipelineCreateFlags flags, VkPipelineShaderStageCreateInfo stage, VkPipelineLayout layout, VkPipeline basePipelineHandle, int32 basePipelineIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stage = stage; + this.layout = layout; + this.basePipelineHandle = basePipelineHandle; + this.basePipelineIndex = basePipelineIndex; + } +} + +struct VkPipeline : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PIPELINE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkPipelineCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1 << 0, + [NoShow] VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 1 << 1, + [NoShow] VK_PIPELINE_CREATE_DERIVATIVE_BIT = 1 << 2, + [NoShow] VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 1 << 4, + [NoShow] VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + [NoShow] VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 1 << 3, + [NoShow] VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 1 << 8, + [NoShow] VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 1 << 9, + [NoShow] VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 1 << 27, + [NoShow] VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 1 << 30, + [NoShow] VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + [NoShow] VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + [NoShow] VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 1 << 14, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 1 << 15, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 1 << 16, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 1 << 17, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 1 << 12, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 1 << 13, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 1 << 19, + [NoShow] VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 1 << 5, + [NoShow] VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 1 << 22, + [NoShow] VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + [NoShow] VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 21, + [NoShow] VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + [NoShow] VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 1 << 6, + [NoShow] VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 1 << 7, + [NoShow] VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 1 << 18, + [NoShow] VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 1 << 11, + [NoShow] VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + [NoShow] VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + [NoShow] VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 29, + [NoShow] VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 1 << 23, + [NoShow] VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 1 << 10, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 1 << 20, + [NoShow] VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1 << 25, + [NoShow] VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1 << 26, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 1 << 24, + [NoShow] VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 1 << 28, + [NoShow] VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, + [NoShow] VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, + // pretty names + DisableOptimization = 1 << 0, + AllowDerivatives = 1 << 1, + Derivative = 1 << 2, + DispatchBase = 1 << 4, + ViewIndexFromDeviceIndex = 1 << 3, + FailOnPipelineCompileRequired = 1 << 8, + EarlyReturnOnFailure = 1 << 9, + NoProtectedAccess = 1 << 27, + ProtectedAccessOnly = 1 << 30, + ViewIndexFromDeviceIndexKHR = ViewIndexFromDeviceIndex, + DispatchBaseKHR = DispatchBase, + RayTracingNoNullAnyHitShadersKHR = 1 << 14, + RayTracingNoNullClosestHitShadersKHR = 1 << 15, + RayTracingNoNullMissShadersKHR = 1 << 16, + RayTracingNoNullIntersectionShadersKHR = 1 << 17, + RayTracingSkipTrianglesKHR = 1 << 12, + RayTracingSkipAabbsKHR = 1 << 13, + RayTracingShaderGroupHandleCaptureReplayKHR = 1 << 19, + DeferCompileNV = 1 << 5, + RenderingFragmentDensityMapAttachmentEXT = 1 << 22, + VkPipelineRasterizationStateCreateFragmentDensityMapAttachmentEXT = RenderingFragmentDensityMapAttachmentEXT, + RenderingFragmentShadingRateAttachmentKHR = 1 << 21, + VkPipelineRasterizationStateCreateFragmentShadingRateAttachmentKHR = RenderingFragmentShadingRateAttachmentKHR, + CaptureStatisticsKHR = 1 << 6, + CaptureInternalRepresentationsKHR = 1 << 7, + IndirectBindableNV = 1 << 18, + LibraryKHR = 1 << 11, + FailOnPipelineCompileRequiredEXT = FailOnPipelineCompileRequired, + EarlyReturnOnFailureEXT = EarlyReturnOnFailure, + DescriptorBufferEXT = 1 << 29, + RetainLinkTimeOptimizationInfoEXT = 1 << 23, + LinkTimeOptimizationEXT = 1 << 10, + RayTracingAllowMotionNV = 1 << 20, + ColorAttachmentFeedbackLoopEXT = 1 << 25, + DepthStencilAttachmentFeedbackLoopEXT = 1 << 26, + RayTracingOpacityMicromapEXT = 1 << 24, + RayTracingDisplacementMicromapNV = 1 << 28, + NoProtectedAccessEXT = NoProtectedAccess, + ProtectedAccessOnlyEXT = ProtectedAccessOnly, +} + +typealias VkPipelineCreateFlags = VkPipelineCreateFlagBits; +typealias VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlagBits; + +[AllowDuplicates] enum VkPipelineShaderStageCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 1 << 0, + [NoShow] VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 1 << 1, + [NoShow] VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, + [NoShow] VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, + // pretty names + AllowVaryingSubgroupSize = 1 << 0, + RequireFullSubgroups = 1 << 1, + AllowVaryingSubgroupSizeEXT = AllowVaryingSubgroupSize, + RequireFullSubgroupsEXT = RequireFullSubgroups, +} + +typealias VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlagBits; + +[CRepr] struct VkPipelineShaderStageCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineShaderStageCreateFlags flags = default; + public VkShaderStageFlagBits stage = default; // Shader stage + public VkShaderModule module = null; // Module containing entry point + public char8* pName = null; // Null-terminated entry point name + public VkSpecializationInfo* pSpecializationInfo = null; + + public this(void* pNext, VkPipelineShaderStageCreateFlags flags, VkShaderStageFlagBits stage, VkShaderModule module, char8* pName, VkSpecializationInfo* pSpecializationInfo = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stage = stage; + this.module = module; + this.pName = pName; + this.pSpecializationInfo = pSpecializationInfo; + } +} + +[AllowDuplicates] enum VkShaderStageFlagBits : int32 +{ + [NoShow] VK_SHADER_STAGE_VERTEX_BIT = 1 << 0, + [NoShow] VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 1 << 1, + [NoShow] VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 1 << 2, + [NoShow] VK_SHADER_STAGE_GEOMETRY_BIT = 1 << 3, + [NoShow] VK_SHADER_STAGE_FRAGMENT_BIT = 1 << 4, + [NoShow] VK_SHADER_STAGE_COMPUTE_BIT = 1 << 5, + [NoShow] VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + [NoShow] VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + [NoShow] VK_SHADER_STAGE_RAYGEN_BIT_KHR = 1 << 8, + [NoShow] VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 1 << 9, + [NoShow] VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 1 << 10, + [NoShow] VK_SHADER_STAGE_MISS_BIT_KHR = 1 << 11, + [NoShow] VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 1 << 12, + [NoShow] VK_SHADER_STAGE_CALLABLE_BIT_KHR = 1 << 13, + [NoShow] VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, + [NoShow] VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, + [NoShow] VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + [NoShow] VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, + [NoShow] VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, + [NoShow] VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + [NoShow] VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, + [NoShow] VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, + [NoShow] VK_SHADER_STAGE_TASK_BIT_EXT = 1 << 6, + [NoShow] VK_SHADER_STAGE_MESH_BIT_EXT = 1 << 7, + [NoShow] VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 1 << 14, + [NoShow] VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 1 << 19, + // pretty names + Vertex = 1 << 0, + TessellationControl = 1 << 1, + TessellationEvaluation = 1 << 2, + Geometry = 1 << 3, + Fragment = 1 << 4, + Compute = 1 << 5, + AllGraphics = 0x0000001F, + All = 0x7FFFFFFF, + RaygenKHR = 1 << 8, + AnyHitKHR = 1 << 9, + ClosestHitKHR = 1 << 10, + MissKHR = 1 << 11, + IntersectionKHR = 1 << 12, + CallableKHR = 1 << 13, + RaygenNV = RaygenKHR, + AnyHitNV = AnyHitKHR, + ClosestHitNV = ClosestHitKHR, + MissNV = MissKHR, + IntersectionNV = IntersectionKHR, + CallableNV = CallableKHR, + TaskNV = TaskEXT, + MeshNV = MeshEXT, + TaskEXT = 1 << 6, + MeshEXT = 1 << 7, + SubpassShadingHUAWEI = 1 << 14, + ClusterCullingHUAWEI = 1 << 19, +} + +typealias VkShaderStageFlags = VkShaderStageFlagBits; + +[CRepr] struct VkSpecializationInfo : this() +{ + public uint32 mapEntryCount = 0; // Number of entries in the map + public VkSpecializationMapEntry* pMapEntries = null; // Array of map entries + public Span mapEntries + { + get { return .(pMapEntries, (.)mapEntryCount); } + set mut { pMapEntries = value.Ptr; mapEntryCount = (.)value.Length; } + } + public c_size dataSize = 0; // Size in bytes of pData + public void* pData = null; // Pointer to SpecConstant data + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(Span mapEntries = default, Span data = default) : this() + { + this.mapEntries = mapEntries; + this.data = data; + } +} + +[CRepr] struct VkSpecializationMapEntry : this() +{ + public uint32 constantID = 0; // The SpecConstant ID specified in the BIL + public uint32 offset = 0; // Offset of the value in the data block + public c_size size = 0; // Size in bytes of the SpecConstant + + public this(uint32 constantID, uint32 offset, c_size size) : this() + { + this.constantID = constantID; + this.offset = offset; + this.size = size; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkComputePipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyPipeline(VkDevice device, VkPipeline pipeline = null, VkAllocationCallbacks* pAllocator = null); + +// Pipeline layout commands +struct VkPipelineLayout : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PIPELINE_LAYOUT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkPipelineLayoutCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineLayoutCreateFlags flags = default; + public uint32 setLayoutCount = 0; // Number of descriptor sets interfaced by the pipeline + public VkDescriptorSetLayout* pSetLayouts = null; // Array of setCount number of descriptor set layout objects defining the layout of the + public Span setLayouts + { + get { return .(pSetLayouts, (.)setLayoutCount); } + set mut { pSetLayouts = value.Ptr; setLayoutCount = (.)value.Length; } + } + public uint32 pushConstantRangeCount = 0; // Number of push-constant ranges used by the pipeline + public VkPushConstantRange* pPushConstantRanges = null; // Array of pushConstantRangeCount number of ranges used by various shader stages + public Span pushConstantRanges + { + get { return .(pPushConstantRanges, (.)pushConstantRangeCount); } + set mut { pPushConstantRanges = value.Ptr; pushConstantRangeCount = (.)value.Length; } + } + + public this(void* pNext = null, VkPipelineLayoutCreateFlags flags = default, Span setLayouts = default, Span pushConstantRanges = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.setLayouts = setLayouts; + this.pushConstantRanges = pushConstantRanges; + } +} + +[CRepr] struct VkPushConstantRange : this() +{ + public VkShaderStageFlags stageFlags = default; // Which stages use the range + public uint32 offset = 0; // Start of the range, in bytes + public uint32 size = 0; // Size of the range, in bytes + + public this(VkShaderStageFlags stageFlags, uint32 offset, uint32 size) : this() + { + this.stageFlags = stageFlags; + this.offset = offset; + this.size = size; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreatePipelineLayout(VkDevice device, VkPipelineLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineLayout pPipelineLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout = null, VkAllocationCallbacks* pAllocator = null); + +// Sampler commands +[AllowDuplicates] enum VkBorderColor : int32 +{ + [NoShow] VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + [NoShow] VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + [NoShow] VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + [NoShow] VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + [NoShow] VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + [NoShow] VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + [NoShow] VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + [NoShow] VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + // pretty names + FloatTransparentBlack = 0, + IntTransparentBlack = 1, + FloatOpaqueBlack = 2, + IntOpaqueBlack = 3, + FloatOpaqueWhite = 4, + IntOpaqueWhite = 5, + FloatCustomEXT = 1000287003, + IntCustomEXT = 1000287004, +} + +[AllowDuplicates] enum VkFilter : int32 +{ + [NoShow] VK_FILTER_NEAREST = 0, + [NoShow] VK_FILTER_LINEAR = 1, + [NoShow] VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + [NoShow] VK_FILTER_CUBIC_EXT = 1000015000, + // pretty names + Nearest = 0, + Linear = 1, + CubicIMG = CubicEXT, + CubicEXT = 1000015000, +} + +struct VkSampler : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SAMPLER; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkSamplerAddressMode : int32 +{ + [NoShow] VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + [NoShow] VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + [NoShow] VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + [NoShow] VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + [NoShow] VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, // No need to add an extnumber attribute, since this uses a core enum value + [NoShow] VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, // Introduced for consistency with extension suffixing rules + // pretty names + Repeat = 0, + MirroredRepeat = 1, + ClampToEdge = 2, + ClampToBorder = 3, + MirrorClampToEdge = 4, // No need to add an extnumber attribute, since this uses a core enum value + MirrorClampToEdgeKHR = MirrorClampToEdge, // Introduced for consistency with extension suffixing rules +} + +[AllowDuplicates] enum VkSamplerCreateFlagBits : int32 +{ + [NoShow] VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 1 << 0, + [NoShow] VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 1 << 1, + [NoShow] VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 1 << 3, + [NoShow] VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 1 << 2, + [NoShow] VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 1 << 4, + // pretty names + SubsampledEXT = 1 << 0, + SubsampledCoarseReconstructionEXT = 1 << 1, + DescriptorBufferCaptureReplayEXT = 1 << 3, + NonSeamlessCubeMapEXT = 1 << 2, + ImageProcessingQCOM = 1 << 4, +} + +typealias VkSamplerCreateFlags = VkSamplerCreateFlagBits; + +[CRepr] struct VkSamplerCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSamplerCreateFlags flags = default; + public VkFilter magFilter = default; // Filter mode for magnification + public VkFilter minFilter = default; // Filter mode for minifiation + public VkSamplerMipmapMode mipmapMode = default; // Mipmap selection mode + public VkSamplerAddressMode addressModeU = default; + public VkSamplerAddressMode addressModeV = default; + public VkSamplerAddressMode addressModeW = default; + public float mipLodBias = 0; + public VkBool32 anisotropyEnable = false; + public float maxAnisotropy = 0; + public VkBool32 compareEnable = false; + public VkCompareOp compareOp = default; + public float minLod = 0; + public float maxLod = 0; + public VkBorderColor borderColor = default; + public VkBool32 unnormalizedCoordinates = false; + + public this(void* pNext, VkSamplerCreateFlags flags, VkFilter magFilter, VkFilter minFilter, VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressModeU, VkSamplerAddressMode addressModeV, VkSamplerAddressMode addressModeW, float mipLodBias, VkBool32 anisotropyEnable, float maxAnisotropy, VkBool32 compareEnable, VkCompareOp compareOp, float minLod, float maxLod, VkBorderColor borderColor, VkBool32 unnormalizedCoordinates) : this() + { + this.pNext = pNext; + this.flags = flags; + this.magFilter = magFilter; + this.minFilter = minFilter; + this.mipmapMode = mipmapMode; + this.addressModeU = addressModeU; + this.addressModeV = addressModeV; + this.addressModeW = addressModeW; + this.mipLodBias = mipLodBias; + this.anisotropyEnable = anisotropyEnable; + this.maxAnisotropy = maxAnisotropy; + this.compareEnable = compareEnable; + this.compareOp = compareOp; + this.minLod = minLod; + this.maxLod = maxLod; + this.borderColor = borderColor; + this.unnormalizedCoordinates = unnormalizedCoordinates; + } +} + +[AllowDuplicates] enum VkSamplerMipmapMode : int32 +{ + [NoShow] VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, // Choose nearest mip level + [NoShow] VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, // Linear filter between mip levels + // pretty names + Nearest = 0, // Choose nearest mip level + Linear = 1, // Linear filter between mip levels +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSampler(VkDevice device, VkSamplerCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSampler pSampler); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroySampler(VkDevice device, VkSampler sampler = null, VkAllocationCallbacks* pAllocator = null); + +// Descriptor set commands +[CRepr] struct VkCopyDescriptorSet : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorSet srcSet = null; // Source descriptor set + public uint32 srcBinding = 0; // Binding within the source descriptor set to copy from + public uint32 srcArrayElement = 0; // Array element within the source binding to copy from + public VkDescriptorSet dstSet = null; // Destination descriptor set + public uint32 dstBinding = 0; // Binding within the destination descriptor set to copy to + public uint32 dstArrayElement = 0; // Array element within the destination binding to copy to + public uint32 descriptorCount = 0; // Number of descriptors to write (determines the size of the array pointed by pDescriptors) + + public this(void* pNext, VkDescriptorSet srcSet, uint32 srcBinding, uint32 srcArrayElement, VkDescriptorSet dstSet, uint32 dstBinding, uint32 dstArrayElement, uint32 descriptorCount) : this() + { + this.pNext = pNext; + this.srcSet = srcSet; + this.srcBinding = srcBinding; + this.srcArrayElement = srcArrayElement; + this.dstSet = dstSet; + this.dstBinding = dstBinding; + this.dstArrayElement = dstArrayElement; + this.descriptorCount = descriptorCount; + } +} + +[CRepr] struct VkDescriptorBufferInfo : this() +{ + public VkBuffer buffer = null; // Buffer used for this descriptor slot. + public VkDeviceSize offset = default; // Base offset from buffer start in bytes to update in the descriptor set. + public VkDeviceSize range = default; // Size in bytes of the buffer resource for this descriptor update. + + public this(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range) : this() + { + this.buffer = buffer; + this.offset = offset; + this.range = range; + } +} + +[CRepr] struct VkDescriptorImageInfo : this() +{ + public VkSampler sampler = null; // Sampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. + public VkImageView imageView = null; // Image view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. + public VkImageLayout imageLayout = default; // Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). + + public this(VkSampler sampler, VkImageView imageView, VkImageLayout imageLayout) : this() + { + this.sampler = sampler; + this.imageView = imageView; + this.imageLayout = imageLayout; + } +} + +struct VkDescriptorPool : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DESCRIPTOR_POOL; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkDescriptorPoolCreateFlagBits : int32 +{ + [NoShow] VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1 << 0, // Descriptor sets may be freed individually + [NoShow] VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 1 << 1, + [NoShow] VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + [NoShow] VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, + [NoShow] VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 1 << 2, + [NoShow] VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 1 << 3, + [NoShow] VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 1 << 4, + // pretty names + FreeDescriptorSet = 1 << 0, // Descriptor sets may be freed individually + UpdateAfterBind = 1 << 1, + UpdateAfterBindEXT = UpdateAfterBind, + HostOnlyVALVE = HostOnlyEXT, + HostOnlyEXT = 1 << 2, + AllowOverallocationSetsNV = 1 << 3, + AllowOverallocationPoolsNV = 1 << 4, +} + +typealias VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlagBits; + +[CRepr] struct VkDescriptorPoolCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorPoolCreateFlags flags = default; + public uint32 maxSets = 0; + public uint32 poolSizeCount = 0; + public VkDescriptorPoolSize* pPoolSizes = null; + public Span poolSizes + { + get { return .(pPoolSizes, (.)poolSizeCount); } + set mut { pPoolSizes = value.Ptr; poolSizeCount = (.)value.Length; } + } + + public this(void* pNext, VkDescriptorPoolCreateFlags flags, uint32 maxSets, Span poolSizes = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.maxSets = maxSets; + this.poolSizes = poolSizes; + } +} + +typealias VkDescriptorPoolResetFlags = VkFlags; + +[CRepr] struct VkDescriptorPoolSize : this() +{ + public VkDescriptorType type = default; + public uint32 descriptorCount = 0; + + public this(VkDescriptorType type, uint32 descriptorCount) : this() + { + this.type = type; + this.descriptorCount = descriptorCount; + } +} + +struct VkDescriptorSet : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DESCRIPTOR_SET; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkDescriptorSetAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorPool descriptorPool = null; + public uint32 descriptorSetCount = 0; + public VkDescriptorSetLayout* pSetLayouts = null; + public Span setLayouts + { + get { return .(pSetLayouts, (.)descriptorSetCount); } + set mut { pSetLayouts = value.Ptr; descriptorSetCount = (.)value.Length; } + } + + public this(void* pNext, VkDescriptorPool descriptorPool, Span setLayouts) : this() + { + this.pNext = pNext; + this.descriptorPool = descriptorPool; + this.setLayouts = setLayouts; + } +} + +struct VkDescriptorSetLayout : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkDescriptorSetLayoutBinding : this() +{ + public uint32 binding = 0; // Binding number for this entry + public VkDescriptorType descriptorType = default; // Type of the descriptors in this binding + public uint32 descriptorCount = 0; // Number of descriptors in this binding + public VkShaderStageFlags stageFlags = default; // Shader stages this binding is visible to + public VkSampler* pImmutableSamplers = null; // Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) + public Span immutableSamplers + { + get { return .(pImmutableSamplers, (.)descriptorCount); } + set mut { pImmutableSamplers = value.Ptr; descriptorCount = (.)value.Length; } + } + + public this(uint32 binding, VkDescriptorType descriptorType, VkShaderStageFlags stageFlags, Span immutableSamplers = default) : this() + { + this.binding = binding; + this.descriptorType = descriptorType; + this.stageFlags = stageFlags; + this.immutableSamplers = immutableSamplers; + } +} + +[AllowDuplicates] enum VkDescriptorSetLayoutCreateFlagBits : int32 +{ + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 1 << 1, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT = 1 << 0, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, // Descriptors are pushed via flink:vkCmdPushDescriptorSet + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 4, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 1 << 5, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 1 << 7, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 1 << 2, + [NoShow] VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 1 << 6, + // pretty names + UpdateAfterBindPool = 1 << 1, + PushDescriptor = 1 << 0, + PushDescriptorKHR = PushDescriptor, // Descriptors are pushed via flink:vkCmdPushDescriptorSet + UpdateAfterBindPoolEXT = UpdateAfterBindPool, + DescriptorBufferEXT = 1 << 4, + EmbeddedImmutableSamplersEXT = 1 << 5, + HostOnlyPoolVALVE = HostOnlyPoolEXT, + IndirectBindableNV = 1 << 7, + HostOnlyPoolEXT = 1 << 2, + PerStageNV = 1 << 6, +} + +typealias VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlagBits; + +[CRepr] struct VkDescriptorSetLayoutCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorSetLayoutCreateFlags flags = default; + public uint32 bindingCount = 0; // Number of bindings in the descriptor set layout + public VkDescriptorSetLayoutBinding* pBindings = null; // Array of descriptor set layout bindings + public Span bindings + { + get { return .(pBindings, (.)bindingCount); } + set mut { pBindings = value.Ptr; bindingCount = (.)value.Length; } + } + + public this(void* pNext = null, VkDescriptorSetLayoutCreateFlags flags = default, Span bindings = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.bindings = bindings; + } +} + +[AllowDuplicates] enum VkDescriptorType : int32 +{ + [NoShow] VK_DESCRIPTOR_TYPE_SAMPLER = 0, + [NoShow] VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + [NoShow] VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + [NoShow] VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + [NoShow] VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + [NoShow] VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + [NoShow] VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + [NoShow] VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + [NoShow] VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + [NoShow] VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + [NoShow] VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + [NoShow] VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, + [NoShow] VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + [NoShow] VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + [NoShow] VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + [NoShow] VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, + [NoShow] VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + [NoShow] VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + [NoShow] VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, + [NoShow] VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, + [NoShow] VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, + // pretty names + Sampler = 0, + CombinedImageSampler = 1, + SampledImage = 2, + StorageImage = 3, + UniformTexelBuffer = 4, + StorageTexelBuffer = 5, + UniformBuffer = 6, + StorageBuffer = 7, + UniformBufferDynamic = 8, + StorageBufferDynamic = 9, + InputAttachment = 10, + InlineUniformBlock = 1000138000, + InlineUniformBlockEXT = InlineUniformBlock, + AccelerationStructureKHR = 1000150000, + AccelerationStructureNV = 1000165000, + MutableVALVE = MutableEXT, + SampleWeightImageQCOM = 1000440000, + BlockMatchImageQCOM = 1000440001, + TensorARM = 1000460000, + MutableEXT = 1000351000, + PartitionedAccelerationStructureNV = 1000570000, +} + +[CRepr] struct VkWriteDescriptorSet : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorSet dstSet = null; // Destination descriptor set + public uint32 dstBinding = 0; // Binding within the destination descriptor set to write + public uint32 dstArrayElement = 0; // Array element within the destination binding to write + public uint32 descriptorCount = 0; // Number of descriptors to write (determines the size of the array pointed by pDescriptors) + public VkDescriptorType descriptorType = default; // Descriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) + public VkDescriptorImageInfo* pImageInfo = null; // Sampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. + public VkDescriptorBufferInfo* pBufferInfo = null; // Raw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. + public VkBufferView* pTexelBufferView = null; // Buffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. + + public this(void* pNext, VkDescriptorSet dstSet, uint32 dstBinding, uint32 dstArrayElement, uint32 descriptorCount, VkDescriptorType descriptorType, VkDescriptorImageInfo* pImageInfo, VkDescriptorBufferInfo* pBufferInfo, VkBufferView* pTexelBufferView) : this() + { + this.pNext = pNext; + this.dstSet = dstSet; + this.dstBinding = dstBinding; + this.dstArrayElement = dstArrayElement; + this.descriptorCount = descriptorCount; + this.descriptorType = descriptorType; + this.pImageInfo = pImageInfo; + this.pBufferInfo = pBufferInfo; + this.pTexelBufferView = pTexelBufferView; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorSetLayout pSetLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorPool pDescriptorPool); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags = default); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAllocateDescriptorSets(VkDevice device, VkDescriptorSetAllocateInfo* pAllocateInfo, out VkDescriptorSet pDescriptorSets); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32 descriptorSetCount, VkDescriptorSet* pDescriptorSets); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUpdateDescriptorSets(VkDevice device, uint32 descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites, uint32 descriptorCopyCount, VkCopyDescriptorSet* pDescriptorCopies); + +// Query commands +[AllowDuplicates] enum VkQueryPipelineStatisticFlagBits : int32 +{ + [NoShow] VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1 << 0, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 1 << 1, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 1 << 2, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 1 << 3, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 1 << 4, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 1 << 5, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 1 << 6, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 1 << 7, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 1 << 8, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 1 << 9, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1 << 10, // Optional + [NoShow] VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 1 << 11, + [NoShow] VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 1 << 12, + [NoShow] VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 1 << 13, + // pretty names + InputAssemblyVertices = 1 << 0, // Optional + InputAssemblyPrimitives = 1 << 1, // Optional + VertexShaderInvocations = 1 << 2, // Optional + GeometryShaderInvocations = 1 << 3, // Optional + GeometryShaderPrimitives = 1 << 4, // Optional + ClippingInvocations = 1 << 5, // Optional + ClippingPrimitives = 1 << 6, // Optional + FragmentShaderInvocations = 1 << 7, // Optional + TessellationControlShaderPatches = 1 << 8, // Optional + TessellationEvaluationShaderInvocations = 1 << 9, // Optional + ComputeShaderInvocations = 1 << 10, // Optional + TaskShaderInvocationsEXT = 1 << 11, + MeshShaderInvocationsEXT = 1 << 12, + ClusterCullingShaderInvocationsHUAWEI = 1 << 13, +} + +typealias VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlagBits; + +// Pass commands +[AllowDuplicates] enum VkPipelineBindPoint : int32 +{ + [NoShow] VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + [NoShow] VK_PIPELINE_BIND_POINT_COMPUTE = 1, + [NoShow] VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000, + [NoShow] VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + [NoShow] VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + [NoShow] VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + [NoShow] VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000, + // pretty names + Graphics = 0, + Compute = 1, + ExecutionGraphAMDX = 1000134000, + RayTracingKHR = 1000165000, + RayTracingNV = RayTracingKHR, + SubpassShadingHUAWEI = 1000369003, + DataGraphARM = 1000507000, +} + +// Command buffer building commands +// Union allowing specification of floating-point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared. +[CRepr, Union] struct VkClearColorValue : this() +{ + public float[4] float32 = .(); + public int32[4] int32 = .(); + public uint32[4] uint32 = .(); + + public this(float[4] float32, int32[4] int32, uint32[4] uint32) : this() + { + this.float32 = float32; + this.int32 = int32; + this.uint32 = uint32; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 firstSet, uint32 descriptorSetCount, VkDescriptorSet* pDescriptorSets, uint32 dynamicOffsetCount, uint32* pDynamicOffsets); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, uint32 rangeCount, VkImageSubresourceRange* pRanges); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32 eventCount, VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32 memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32 bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32 imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32 offset, uint32 size, void* pValues); + +// Vulkan graphics API interface definitions +// API constants +static { public const uint32 VK_ATTACHMENT_UNUSED = (~0U); } +static { public const uint32 VK_SUBPASS_EXTERNAL = (~0U); } + +// These types are part of the API, though not directly used in API commands or data structures +[CRepr] struct VkDrawIndexedIndirectCommand : this() +{ + public uint32 indexCount = 0; + public uint32 instanceCount = 0; + public uint32 firstIndex = 0; + public int32 vertexOffset = 0; + public uint32 firstInstance = 0; + + public this(uint32 indexCount, uint32 instanceCount, uint32 firstIndex, int32 vertexOffset, uint32 firstInstance) : this() + { + this.indexCount = indexCount; + this.instanceCount = instanceCount; + this.firstIndex = firstIndex; + this.vertexOffset = vertexOffset; + this.firstInstance = firstInstance; + } +} + +[CRepr] struct VkDrawIndirectCommand : this() +{ + public uint32 vertexCount = 0; + public uint32 instanceCount = 0; + public uint32 firstVertex = 0; + public uint32 firstInstance = 0; + + public this(uint32 vertexCount, uint32 instanceCount, uint32 firstVertex, uint32 firstInstance) : this() + { + this.vertexCount = vertexCount; + this.instanceCount = instanceCount; + this.firstVertex = firstVertex; + this.firstInstance = firstInstance; + } +} + +// Graphics Pipeline commands +[AllowDuplicates] enum VkBlendFactor : int32 +{ + [NoShow] VK_BLEND_FACTOR_ZERO = 0, + [NoShow] VK_BLEND_FACTOR_ONE = 1, + [NoShow] VK_BLEND_FACTOR_SRC_COLOR = 2, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + [NoShow] VK_BLEND_FACTOR_DST_COLOR = 4, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + [NoShow] VK_BLEND_FACTOR_SRC_ALPHA = 6, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + [NoShow] VK_BLEND_FACTOR_DST_ALPHA = 8, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + [NoShow] VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + [NoShow] VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + [NoShow] VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + [NoShow] VK_BLEND_FACTOR_SRC1_COLOR = 15, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + [NoShow] VK_BLEND_FACTOR_SRC1_ALPHA = 17, + [NoShow] VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + // pretty names + Zero = 0, + One = 1, + SrcColor = 2, + OneMinusSrcColor = 3, + DstColor = 4, + OneMinusDstColor = 5, + SrcAlpha = 6, + OneMinusSrcAlpha = 7, + DstAlpha = 8, + OneMinusDstAlpha = 9, + ConstantColor = 10, + OneMinusConstantColor = 11, + ConstantAlpha = 12, + OneMinusConstantAlpha = 13, + SrcAlphaSaturate = 14, + Src1_Color = 15, + OneMinusSrc1_Color = 16, + Src1_Alpha = 17, + OneMinusSrc1_Alpha = 18, +} + +[AllowDuplicates] enum VkBlendOp : int32 +{ + [NoShow] VK_BLEND_OP_ADD = 0, + [NoShow] VK_BLEND_OP_SUBTRACT = 1, + [NoShow] VK_BLEND_OP_REVERSE_SUBTRACT = 2, + [NoShow] VK_BLEND_OP_MIN = 3, + [NoShow] VK_BLEND_OP_MAX = 4, + [NoShow] VK_BLEND_OP_ZERO_EXT = 1000148000, + [NoShow] VK_BLEND_OP_SRC_EXT = 1000148001, + [NoShow] VK_BLEND_OP_DST_EXT = 1000148002, + [NoShow] VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + [NoShow] VK_BLEND_OP_DST_OVER_EXT = 1000148004, + [NoShow] VK_BLEND_OP_SRC_IN_EXT = 1000148005, + [NoShow] VK_BLEND_OP_DST_IN_EXT = 1000148006, + [NoShow] VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + [NoShow] VK_BLEND_OP_DST_OUT_EXT = 1000148008, + [NoShow] VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + [NoShow] VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + [NoShow] VK_BLEND_OP_XOR_EXT = 1000148011, + [NoShow] VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + [NoShow] VK_BLEND_OP_SCREEN_EXT = 1000148013, + [NoShow] VK_BLEND_OP_OVERLAY_EXT = 1000148014, + [NoShow] VK_BLEND_OP_DARKEN_EXT = 1000148015, + [NoShow] VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + [NoShow] VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + [NoShow] VK_BLEND_OP_COLORBURN_EXT = 1000148018, + [NoShow] VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + [NoShow] VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + [NoShow] VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + [NoShow] VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + [NoShow] VK_BLEND_OP_INVERT_EXT = 1000148023, + [NoShow] VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + [NoShow] VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + [NoShow] VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + [NoShow] VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + [NoShow] VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + [NoShow] VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + [NoShow] VK_BLEND_OP_HARDMIX_EXT = 1000148030, + [NoShow] VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + [NoShow] VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + [NoShow] VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + [NoShow] VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + [NoShow] VK_BLEND_OP_PLUS_EXT = 1000148035, + [NoShow] VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + [NoShow] VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + [NoShow] VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + [NoShow] VK_BLEND_OP_MINUS_EXT = 1000148039, + [NoShow] VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + [NoShow] VK_BLEND_OP_CONTRAST_EXT = 1000148041, + [NoShow] VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + [NoShow] VK_BLEND_OP_RED_EXT = 1000148043, + [NoShow] VK_BLEND_OP_GREEN_EXT = 1000148044, + [NoShow] VK_BLEND_OP_BLUE_EXT = 1000148045, + // pretty names + Add = 0, + Subtract = 1, + ReverseSubtract = 2, + Min = 3, + Max = 4, + ZeroEXT = 1000148000, + SrcEXT = 1000148001, + DstEXT = 1000148002, + SrcOverEXT = 1000148003, + DstOverEXT = 1000148004, + SrcInEXT = 1000148005, + DstInEXT = 1000148006, + SrcOutEXT = 1000148007, + DstOutEXT = 1000148008, + SrcAtopEXT = 1000148009, + DstAtopEXT = 1000148010, + XorEXT = 1000148011, + MultiplyEXT = 1000148012, + ScreenEXT = 1000148013, + OverlayEXT = 1000148014, + DarkenEXT = 1000148015, + LightenEXT = 1000148016, + ColordodgeEXT = 1000148017, + ColorburnEXT = 1000148018, + HardlightEXT = 1000148019, + SoftlightEXT = 1000148020, + DifferenceEXT = 1000148021, + ExclusionEXT = 1000148022, + InvertEXT = 1000148023, + InvertRgbEXT = 1000148024, + LineardodgeEXT = 1000148025, + LinearburnEXT = 1000148026, + VividlightEXT = 1000148027, + LinearlightEXT = 1000148028, + PinlightEXT = 1000148029, + HardmixEXT = 1000148030, + HslHueEXT = 1000148031, + HslSaturationEXT = 1000148032, + HslColorEXT = 1000148033, + HslLuminosityEXT = 1000148034, + PlusEXT = 1000148035, + PlusClampedEXT = 1000148036, + PlusClampedAlphaEXT = 1000148037, + PlusDarkerEXT = 1000148038, + MinusEXT = 1000148039, + MinusClampedEXT = 1000148040, + ContrastEXT = 1000148041, + InvertOvgEXT = 1000148042, + RedEXT = 1000148043, + GreenEXT = 1000148044, + BlueEXT = 1000148045, +} + +[AllowDuplicates] enum VkColorComponentFlagBits : int32 +{ + [NoShow] VK_COLOR_COMPONENT_R_BIT = 1 << 0, + [NoShow] VK_COLOR_COMPONENT_G_BIT = 1 << 1, + [NoShow] VK_COLOR_COMPONENT_B_BIT = 1 << 2, + [NoShow] VK_COLOR_COMPONENT_A_BIT = 1 << 3, + // pretty names + R = 1 << 0, + G = 1 << 1, + B = 1 << 2, + A = 1 << 3, +} + +typealias VkColorComponentFlags = VkColorComponentFlagBits; + +[AllowDuplicates] enum VkCompareOp : int32 +{ + [NoShow] VK_COMPARE_OP_NEVER = 0, + [NoShow] VK_COMPARE_OP_LESS = 1, + [NoShow] VK_COMPARE_OP_EQUAL = 2, + [NoShow] VK_COMPARE_OP_LESS_OR_EQUAL = 3, + [NoShow] VK_COMPARE_OP_GREATER = 4, + [NoShow] VK_COMPARE_OP_NOT_EQUAL = 5, + [NoShow] VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + [NoShow] VK_COMPARE_OP_ALWAYS = 7, + // pretty names + Never = 0, + Less = 1, + Equal = 2, + LessOrEqual = 3, + Greater = 4, + NotEqual = 5, + GreaterOrEqual = 6, + Always = 7, +} + +[AllowDuplicates] enum VkCullModeFlagBits : int32 +{ + [NoShow] VK_CULL_MODE_NONE = 0, + [NoShow] VK_CULL_MODE_FRONT_BIT = 1 << 0, + [NoShow] VK_CULL_MODE_BACK_BIT = 1 << 1, + [NoShow] VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + // pretty names + None = 0, + Front = 1 << 0, + Back = 1 << 1, + FrontAndBack = 0x00000003, +} + +typealias VkCullModeFlags = VkCullModeFlagBits; + +[AllowDuplicates] enum VkDynamicState : int32 +{ + [NoShow] VK_DYNAMIC_STATE_VIEWPORT = 0, + [NoShow] VK_DYNAMIC_STATE_SCISSOR = 1, + [NoShow] VK_DYNAMIC_STATE_LINE_WIDTH = 2, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + [NoShow] VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + [NoShow] VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + [NoShow] VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + [NoShow] VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + [NoShow] VK_DYNAMIC_STATE_CULL_MODE = 1000267000, + [NoShow] VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, + [NoShow] VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, + [NoShow] VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, + [NoShow] VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, + [NoShow] VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, + [NoShow] VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, + [NoShow] VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + [NoShow] VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, + [NoShow] VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, + [NoShow] VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, + [NoShow] VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, + [NoShow] VK_DYNAMIC_STATE_LINE_STIPPLE = 1000259000, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + [NoShow] VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + [NoShow] VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + [NoShow] VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, + [NoShow] VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + [NoShow] VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + [NoShow] VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, + [NoShow] VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + [NoShow] VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + [NoShow] VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE, + [NoShow] VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, + [NoShow] VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, + [NoShow] VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, + [NoShow] VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, + [NoShow] VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, + [NoShow] VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, + [NoShow] VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, + [NoShow] VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, + [NoShow] VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, + [NoShow] VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, + [NoShow] VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + [NoShow] VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, // Not promoted to 1.3 + [NoShow] VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, + [NoShow] VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, + [NoShow] VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, // Not promoted to 1.3 + [NoShow] VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, + [NoShow] VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + [NoShow] VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, + [NoShow] VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, + [NoShow] VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, + [NoShow] VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, + [NoShow] VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + [NoShow] VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + [NoShow] VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, + [NoShow] VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, + [NoShow] VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, + [NoShow] VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + [NoShow] VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + [NoShow] VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, + [NoShow] VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + [NoShow] VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + [NoShow] VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, + [NoShow] VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + [NoShow] VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, + [NoShow] VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, + [NoShow] VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, + [NoShow] VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, + [NoShow] VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + [NoShow] VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, + [NoShow] VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + [NoShow] VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + [NoShow] VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, + [NoShow] VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + [NoShow] VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VK_DYNAMIC_STATE_LINE_STIPPLE, + [NoShow] VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000, + // pretty names + Viewport = 0, + Scissor = 1, + LineWidth = 2, + DepthBias = 3, + BlendConstants = 4, + DepthBounds = 5, + StencilCompareMask = 6, + StencilWriteMask = 7, + StencilReference = 8, + CullMode = 1000267000, + FrontFace = 1000267001, + PrimitiveTopology = 1000267002, + ViewportWithCount = 1000267003, + ScissorWithCount = 1000267004, + VertexInputBindingStride = 1000267005, + DepthTestEnable = 1000267006, + DepthWriteEnable = 1000267007, + DepthCompareOp = 1000267008, + DepthBoundsTestEnable = 1000267009, + StencilTestEnable = 1000267010, + StencilOp = 1000267011, + RasterizerDiscardEnable = 1000377001, + DepthBiasEnable = 1000377002, + PrimitiveRestartEnable = 1000377004, + LineStipple = 1000259000, + ViewportWScalingNV = 1000087000, + DiscardRectangleEXT = 1000099000, + DiscardRectangleEnableEXT = 1000099001, + DiscardRectangleModeEXT = 1000099002, + SampleLocationsEXT = 1000143000, + RayTracingPipelineStackSizeKHR = 1000347000, + ViewportShadingRatePaletteNV = 1000164004, + ViewportCoarseSampleOrderNV = 1000164006, + ExclusiveScissorEnableNV = 1000205000, + ExclusiveScissorNV = 1000205001, + FragmentShadingRateKHR = 1000226000, + LineStippleEXT = LineStipple, + CullModeEXT = CullMode, + FrontFaceEXT = FrontFace, + PrimitiveTopologyEXT = PrimitiveTopology, + ViewportWithCountEXT = ViewportWithCount, + ScissorWithCountEXT = ScissorWithCount, + VertexInputBindingStrideEXT = VertexInputBindingStride, + DepthTestEnableEXT = DepthTestEnable, + DepthWriteEnableEXT = DepthWriteEnable, + DepthCompareOpEXT = DepthCompareOp, + DepthBoundsTestEnableEXT = DepthBoundsTestEnable, + StencilTestEnableEXT = StencilTestEnable, + StencilOpEXT = StencilOp, + VertexInputEXT = 1000352000, + PatchControlPointsEXT = 1000377000, // Not promoted to 1.3 + RasterizerDiscardEnableEXT = RasterizerDiscardEnable, + DepthBiasEnableEXT = DepthBiasEnable, + LogicOpEXT = 1000377003, // Not promoted to 1.3 + PrimitiveRestartEnableEXT = PrimitiveRestartEnable, + ColorWriteEnableEXT = 1000381000, + DepthClampEnableEXT = 1000455003, + PolygonModeEXT = 1000455004, + RasterizationSamplesEXT = 1000455005, + SampleMaskEXT = 1000455006, + AlphaToCoverageEnableEXT = 1000455007, + AlphaToOneEnableEXT = 1000455008, + LogicOpEnableEXT = 1000455009, + ColorBlendEnableEXT = 1000455010, + ColorBlendEquationEXT = 1000455011, + ColorWriteMaskEXT = 1000455012, + TessellationDomainOriginEXT = 1000455002, + RasterizationStreamEXT = 1000455013, + ConservativeRasterizationModeEXT = 1000455014, + ExtraPrimitiveOverestimationSizeEXT = 1000455015, + DepthClipEnableEXT = 1000455016, + SampleLocationsEnableEXT = 1000455017, + ColorBlendAdvancedEXT = 1000455018, + ProvokingVertexModeEXT = 1000455019, + LineRasterizationModeEXT = 1000455020, + LineStippleEnableEXT = 1000455021, + DepthClipNegativeOneToOneEXT = 1000455022, + ViewportWScalingEnableNV = 1000455023, + ViewportSwizzleNV = 1000455024, + CoverageToColorEnableNV = 1000455025, + CoverageToColorLocationNV = 1000455026, + CoverageModulationModeNV = 1000455027, + CoverageModulationTableEnableNV = 1000455028, + CoverageModulationTableNV = 1000455029, + ShadingRateImageEnableNV = 1000455030, + RepresentativeFragmentTestEnableNV = 1000455031, + CoverageReductionModeNV = 1000455032, + AttachmentFeedbackLoopEnableEXT = 1000524000, + LineStippleKHR = LineStipple, + DepthClampRangeEXT = 1000582000, +} + +[AllowDuplicates] enum VkFrontFace : int32 +{ + [NoShow] VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + [NoShow] VK_FRONT_FACE_CLOCKWISE = 1, + // pretty names + CounterClockwise = 0, + Clockwise = 1, +} + +[CRepr] struct VkGraphicsPipelineCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags flags = default; // Pipeline creation flags + public uint32 stageCount = 0; + public VkPipelineShaderStageCreateInfo* pStages = null; // One entry for each active shader stage + public Span stages + { + get { return .(pStages, (.)stageCount); } + set mut { pStages = value.Ptr; stageCount = (.)value.Length; } + } + public VkPipelineVertexInputStateCreateInfo* pVertexInputState = null; + public VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState = null; + public VkPipelineTessellationStateCreateInfo* pTessellationState = null; + public VkPipelineViewportStateCreateInfo* pViewportState = null; + public VkPipelineRasterizationStateCreateInfo* pRasterizationState = null; + public VkPipelineMultisampleStateCreateInfo* pMultisampleState = null; + public VkPipelineDepthStencilStateCreateInfo* pDepthStencilState = null; + public VkPipelineColorBlendStateCreateInfo* pColorBlendState = null; + public VkPipelineDynamicStateCreateInfo* pDynamicState = null; + public VkPipelineLayout layout = null; // Interface layout of the pipeline + public VkRenderPass renderPass = null; + public uint32 subpass = 0; + public VkPipeline basePipelineHandle = null; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + public int32 basePipelineIndex = 0; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + public this(void* pNext, VkPipelineCreateFlags flags, Span stages, VkPipelineVertexInputStateCreateInfo* pVertexInputState, VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState, VkPipelineTessellationStateCreateInfo* pTessellationState, VkPipelineViewportStateCreateInfo* pViewportState, VkPipelineRasterizationStateCreateInfo* pRasterizationState, VkPipelineMultisampleStateCreateInfo* pMultisampleState, VkPipelineDepthStencilStateCreateInfo* pDepthStencilState, VkPipelineColorBlendStateCreateInfo* pColorBlendState, VkPipelineDynamicStateCreateInfo* pDynamicState, VkPipelineLayout layout, VkRenderPass renderPass, uint32 subpass, VkPipeline basePipelineHandle, int32 basePipelineIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stages = stages; + this.pVertexInputState = pVertexInputState; + this.pInputAssemblyState = pInputAssemblyState; + this.pTessellationState = pTessellationState; + this.pViewportState = pViewportState; + this.pRasterizationState = pRasterizationState; + this.pMultisampleState = pMultisampleState; + this.pDepthStencilState = pDepthStencilState; + this.pColorBlendState = pColorBlendState; + this.pDynamicState = pDynamicState; + this.layout = layout; + this.renderPass = renderPass; + this.subpass = subpass; + this.basePipelineHandle = basePipelineHandle; + this.basePipelineIndex = basePipelineIndex; + } +} + +[AllowDuplicates] enum VkLogicOp : int32 +{ + [NoShow] VK_LOGIC_OP_CLEAR = 0, + [NoShow] VK_LOGIC_OP_AND = 1, + [NoShow] VK_LOGIC_OP_AND_REVERSE = 2, + [NoShow] VK_LOGIC_OP_COPY = 3, + [NoShow] VK_LOGIC_OP_AND_INVERTED = 4, + [NoShow] VK_LOGIC_OP_NO_OP = 5, + [NoShow] VK_LOGIC_OP_XOR = 6, + [NoShow] VK_LOGIC_OP_OR = 7, + [NoShow] VK_LOGIC_OP_NOR = 8, + [NoShow] VK_LOGIC_OP_EQUIVALENT = 9, + [NoShow] VK_LOGIC_OP_INVERT = 10, + [NoShow] VK_LOGIC_OP_OR_REVERSE = 11, + [NoShow] VK_LOGIC_OP_COPY_INVERTED = 12, + [NoShow] VK_LOGIC_OP_OR_INVERTED = 13, + [NoShow] VK_LOGIC_OP_NAND = 14, + [NoShow] VK_LOGIC_OP_SET = 15, + // pretty names + Clear = 0, + And = 1, + AndReverse = 2, + Copy = 3, + AndInverted = 4, + NoOp = 5, + Xor = 6, + Or = 7, + Nor = 8, + Equivalent = 9, + Invert = 10, + OrReverse = 11, + CopyInverted = 12, + OrInverted = 13, + Nand = 14, + Set = 15, +} + +[CRepr] struct VkPipelineColorBlendAttachmentState : this() +{ + public VkBool32 blendEnable = false; + public VkBlendFactor srcColorBlendFactor = default; + public VkBlendFactor dstColorBlendFactor = default; + public VkBlendOp colorBlendOp = default; + public VkBlendFactor srcAlphaBlendFactor = default; + public VkBlendFactor dstAlphaBlendFactor = default; + public VkBlendOp alphaBlendOp = default; + public VkColorComponentFlags colorWriteMask = default; + + public this(VkBool32 blendEnable, VkBlendFactor srcColorBlendFactor, VkBlendFactor dstColorBlendFactor, VkBlendOp colorBlendOp, VkBlendFactor srcAlphaBlendFactor, VkBlendFactor dstAlphaBlendFactor, VkBlendOp alphaBlendOp, VkColorComponentFlags colorWriteMask = default) : this() + { + this.blendEnable = blendEnable; + this.srcColorBlendFactor = srcColorBlendFactor; + this.dstColorBlendFactor = dstColorBlendFactor; + this.colorBlendOp = colorBlendOp; + this.srcAlphaBlendFactor = srcAlphaBlendFactor; + this.dstAlphaBlendFactor = dstAlphaBlendFactor; + this.alphaBlendOp = alphaBlendOp; + this.colorWriteMask = colorWriteMask; + } +} + +typealias VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlagBits; + +[CRepr] struct VkPipelineColorBlendStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineColorBlendStateCreateFlags flags = default; + public VkBool32 logicOpEnable = false; + public VkLogicOp logicOp = default; + public uint32 attachmentCount = 0; // # of pAttachments + public VkPipelineColorBlendAttachmentState* pAttachments = null; + public Span attachments + { + get { return .(pAttachments, (.)attachmentCount); } + set mut { pAttachments = value.Ptr; attachmentCount = (.)value.Length; } + } + public float[4] blendConstants = .(); + + public this(void* pNext, VkPipelineColorBlendStateCreateFlags flags, VkBool32 logicOpEnable, VkLogicOp logicOp, Span attachments, float[4] blendConstants) : this() + { + this.pNext = pNext; + this.flags = flags; + this.logicOpEnable = logicOpEnable; + this.logicOp = logicOp; + this.attachments = attachments; + this.blendConstants = blendConstants; + } +} + +typealias VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlagBits; + +[CRepr] struct VkPipelineDepthStencilStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineDepthStencilStateCreateFlags flags = default; + public VkBool32 depthTestEnable = false; + public VkBool32 depthWriteEnable = false; + public VkCompareOp depthCompareOp = default; + public VkBool32 depthBoundsTestEnable = false; // optional (depth_bounds_test) + public VkBool32 stencilTestEnable = false; + public VkStencilOpState front = default; + public VkStencilOpState back = default; + public float minDepthBounds = 0; + public float maxDepthBounds = 0; + + public this(void* pNext, VkPipelineDepthStencilStateCreateFlags flags, VkBool32 depthTestEnable, VkBool32 depthWriteEnable, VkCompareOp depthCompareOp, VkBool32 depthBoundsTestEnable, VkBool32 stencilTestEnable, VkStencilOpState front, VkStencilOpState back, float minDepthBounds, float maxDepthBounds) : this() + { + this.pNext = pNext; + this.flags = flags; + this.depthTestEnable = depthTestEnable; + this.depthWriteEnable = depthWriteEnable; + this.depthCompareOp = depthCompareOp; + this.depthBoundsTestEnable = depthBoundsTestEnable; + this.stencilTestEnable = stencilTestEnable; + this.front = front; + this.back = back; + this.minDepthBounds = minDepthBounds; + this.maxDepthBounds = maxDepthBounds; + } +} + +typealias VkPipelineDynamicStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineDynamicStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineDynamicStateCreateFlags flags = default; + public uint32 dynamicStateCount = 0; + public VkDynamicState* pDynamicStates = null; + public Span dynamicStates + { + get { return .(pDynamicStates, (.)dynamicStateCount); } + set mut { pDynamicStates = value.Ptr; dynamicStateCount = (.)value.Length; } + } + + public this(void* pNext = null, VkPipelineDynamicStateCreateFlags flags = default, Span dynamicStates = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dynamicStates = dynamicStates; + } +} + +typealias VkPipelineInputAssemblyStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineInputAssemblyStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineInputAssemblyStateCreateFlags flags = default; + public VkPrimitiveTopology topology = default; + public VkBool32 primitiveRestartEnable = false; + + public this(void* pNext, VkPipelineInputAssemblyStateCreateFlags flags, VkPrimitiveTopology topology, VkBool32 primitiveRestartEnable) : this() + { + this.pNext = pNext; + this.flags = flags; + this.topology = topology; + this.primitiveRestartEnable = primitiveRestartEnable; + } +} + +typealias VkPipelineMultisampleStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineMultisampleStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineMultisampleStateCreateFlags flags = default; + public VkSampleCountFlagBits rasterizationSamples = default; // Number of samples used for rasterization + public VkBool32 sampleShadingEnable = false; // optional (GL45) + public float minSampleShading = 0; // optional (GL45) + public VkSampleMask* pSampleMask = null; // Array of sampleMask words + public VkBool32 alphaToCoverageEnable = false; + public VkBool32 alphaToOneEnable = false; + + public this(void* pNext, VkPipelineMultisampleStateCreateFlags flags, VkSampleCountFlagBits rasterizationSamples, VkBool32 sampleShadingEnable, float minSampleShading, VkSampleMask* pSampleMask, VkBool32 alphaToCoverageEnable, VkBool32 alphaToOneEnable) : this() + { + this.pNext = pNext; + this.flags = flags; + this.rasterizationSamples = rasterizationSamples; + this.sampleShadingEnable = sampleShadingEnable; + this.minSampleShading = minSampleShading; + this.pSampleMask = pSampleMask; + this.alphaToCoverageEnable = alphaToCoverageEnable; + this.alphaToOneEnable = alphaToOneEnable; + } +} + +typealias VkPipelineRasterizationStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineRasterizationStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRasterizationStateCreateFlags flags = default; + public VkBool32 depthClampEnable = false; + public VkBool32 rasterizerDiscardEnable = false; + public VkPolygonMode polygonMode = default; // optional (GL45) + public VkCullModeFlags cullMode = default; + public VkFrontFace frontFace = default; + public VkBool32 depthBiasEnable = false; + public float depthBiasConstantFactor = 0; + public float depthBiasClamp = 0; + public float depthBiasSlopeFactor = 0; + public float lineWidth = 0; + + public this(void* pNext, VkPipelineRasterizationStateCreateFlags flags, VkBool32 depthClampEnable, VkBool32 rasterizerDiscardEnable, VkPolygonMode polygonMode, VkCullModeFlags cullMode, VkFrontFace frontFace, VkBool32 depthBiasEnable, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, float lineWidth) : this() + { + this.pNext = pNext; + this.flags = flags; + this.depthClampEnable = depthClampEnable; + this.rasterizerDiscardEnable = rasterizerDiscardEnable; + this.polygonMode = polygonMode; + this.cullMode = cullMode; + this.frontFace = frontFace; + this.depthBiasEnable = depthBiasEnable; + this.depthBiasConstantFactor = depthBiasConstantFactor; + this.depthBiasClamp = depthBiasClamp; + this.depthBiasSlopeFactor = depthBiasSlopeFactor; + this.lineWidth = lineWidth; + } +} + +typealias VkPipelineTessellationStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineTessellationStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineTessellationStateCreateFlags flags = default; + public uint32 patchControlPoints = 0; + + public this(void* pNext, VkPipelineTessellationStateCreateFlags flags, uint32 patchControlPoints) : this() + { + this.pNext = pNext; + this.flags = flags; + this.patchControlPoints = patchControlPoints; + } +} + +typealias VkPipelineVertexInputStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineVertexInputStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineVertexInputStateCreateFlags flags = default; + public uint32 vertexBindingDescriptionCount = 0; // number of bindings + public VkVertexInputBindingDescription* pVertexBindingDescriptions = null; + public Span vertexBindingDescriptions + { + get { return .(pVertexBindingDescriptions, (.)vertexBindingDescriptionCount); } + set mut { pVertexBindingDescriptions = value.Ptr; vertexBindingDescriptionCount = (.)value.Length; } + } + public uint32 vertexAttributeDescriptionCount = 0; // number of attributes + public VkVertexInputAttributeDescription* pVertexAttributeDescriptions = null; + public Span vertexAttributeDescriptions + { + get { return .(pVertexAttributeDescriptions, (.)vertexAttributeDescriptionCount); } + set mut { pVertexAttributeDescriptions = value.Ptr; vertexAttributeDescriptionCount = (.)value.Length; } + } + + public this(void* pNext = null, VkPipelineVertexInputStateCreateFlags flags = default, Span vertexBindingDescriptions = default, Span vertexAttributeDescriptions = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.vertexBindingDescriptions = vertexBindingDescriptions; + this.vertexAttributeDescriptions = vertexAttributeDescriptions; + } +} + +typealias VkPipelineViewportStateCreateFlags = VkFlags; + +[CRepr] struct VkPipelineViewportStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineViewportStateCreateFlags flags = default; + public uint32 viewportCount = 0; + public VkViewport* pViewports = null; + public Span viewports + { + get { return .(pViewports, (.)viewportCount); } + set mut { pViewports = value.Ptr; viewportCount = (.)value.Length; } + } + public uint32 scissorCount = 0; + public VkRect2D* pScissors = null; + public Span scissors + { + get { return .(pScissors, (.)scissorCount); } + set mut { pScissors = value.Ptr; scissorCount = (.)value.Length; } + } + + public this(void* pNext = null, VkPipelineViewportStateCreateFlags flags = default, Span viewports = default, Span scissors = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.viewports = viewports; + this.scissors = scissors; + } +} + +[AllowDuplicates] enum VkPolygonMode : int32 +{ + [NoShow] VK_POLYGON_MODE_FILL = 0, + [NoShow] VK_POLYGON_MODE_LINE = 1, + [NoShow] VK_POLYGON_MODE_POINT = 2, + [NoShow] VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + // pretty names + Fill = 0, + Line = 1, + Point = 2, + FillRectangleNV = 1000153000, +} + +[AllowDuplicates] enum VkPrimitiveTopology : int32 +{ + [NoShow] VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + [NoShow] VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + [NoShow] VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + [NoShow] VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + [NoShow] VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + [NoShow] VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + [NoShow] VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + [NoShow] VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + [NoShow] VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + [NoShow] VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + [NoShow] VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + // pretty names + PointList = 0, + LineList = 1, + LineStrip = 2, + TriangleList = 3, + TriangleStrip = 4, + TriangleFan = 5, + LineListWithAdjacency = 6, + LineStripWithAdjacency = 7, + TriangleListWithAdjacency = 8, + TriangleStripWithAdjacency = 9, + PatchList = 10, +} + +typealias VkSampleMask = uint32; + +[AllowDuplicates] enum VkStencilOp : int32 +{ + [NoShow] VK_STENCIL_OP_KEEP = 0, + [NoShow] VK_STENCIL_OP_ZERO = 1, + [NoShow] VK_STENCIL_OP_REPLACE = 2, + [NoShow] VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + [NoShow] VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + [NoShow] VK_STENCIL_OP_INVERT = 5, + [NoShow] VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + [NoShow] VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + // pretty names + Keep = 0, + Zero = 1, + Replace = 2, + IncrementAndClamp = 3, + DecrementAndClamp = 4, + Invert = 5, + IncrementAndWrap = 6, + DecrementAndWrap = 7, +} + +[CRepr] struct VkStencilOpState : this() +{ + public VkStencilOp failOp = default; + public VkStencilOp passOp = default; + public VkStencilOp depthFailOp = default; + public VkCompareOp compareOp = default; + public uint32 compareMask = 0; + public uint32 writeMask = 0; + public uint32 reference = 0; + + public this(VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, uint32 compareMask, uint32 writeMask, uint32 reference) : this() + { + this.failOp = failOp; + this.passOp = passOp; + this.depthFailOp = depthFailOp; + this.compareOp = compareOp; + this.compareMask = compareMask; + this.writeMask = writeMask; + this.reference = reference; + } +} + +[CRepr] struct VkVertexInputAttributeDescription : this() +{ + public uint32 location = 0; // location of the shader vertex attrib + public uint32 binding = 0; // Vertex buffer binding id + public VkFormat format = default; // format of source data + public uint32 offset = 0; // Offset of first element in bytes from base of vertex + + public this(uint32 location, uint32 binding, VkFormat format, uint32 offset) : this() + { + this.location = location; + this.binding = binding; + this.format = format; + this.offset = offset; + } +} + +[CRepr] struct VkVertexInputBindingDescription : this() +{ + public uint32 binding = 0; // Vertex buffer binding id + public uint32 stride = 0; // Distance between vertices in bytes (0 = no advancement) + public VkVertexInputRate inputRate = default; // The rate at which the vertex data is consumed + + public this(uint32 binding, uint32 stride, VkVertexInputRate inputRate) : this() + { + this.binding = binding; + this.stride = stride; + this.inputRate = inputRate; + } +} + +[AllowDuplicates] enum VkVertexInputRate : int32 +{ + [NoShow] VK_VERTEX_INPUT_RATE_VERTEX = 0, + [NoShow] VK_VERTEX_INPUT_RATE_INSTANCE = 1, + // pretty names + Vertex = 0, + Instance = 1, +} + +[CRepr] struct VkViewport : this() +{ + public float x = 0; + public float y = 0; + public float width = 0; + public float height = 0; + public float minDepth = 0; + public float maxDepth = 0; + + public this(float x, float y, float width, float height, float minDepth, float maxDepth) : this() + { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + this.minDepth = minDepth; + this.maxDepth = maxDepth; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkGraphicsPipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); + +// Pass commands +[CRepr] struct VkAttachmentDescription : this() +{ + public VkAttachmentDescriptionFlags flags = default; + public VkFormat format = default; + public VkSampleCountFlagBits samples = default; + public VkAttachmentLoadOp loadOp = default; // Load operation for color or depth data + public VkAttachmentStoreOp storeOp = default; // Store operation for color or depth data + public VkAttachmentLoadOp stencilLoadOp = default; // Load operation for stencil data + public VkAttachmentStoreOp stencilStoreOp = default; // Store operation for stencil data + public VkImageLayout initialLayout = default; + public VkImageLayout finalLayout = default; + + public this(VkAttachmentDescriptionFlags flags, VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp, VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp, VkImageLayout initialLayout, VkImageLayout finalLayout) : this() + { + this.flags = flags; + this.format = format; + this.samples = samples; + this.loadOp = loadOp; + this.storeOp = storeOp; + this.stencilLoadOp = stencilLoadOp; + this.stencilStoreOp = stencilStoreOp; + this.initialLayout = initialLayout; + this.finalLayout = finalLayout; + } +} + +[AllowDuplicates] enum VkAttachmentDescriptionFlagBits : int32 +{ + [NoShow] VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1 << 0, // The attachment may alias physical memory of another attachment in the same render pass + [NoShow] VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 1 << 1, + [NoShow] VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 1 << 2, + // pretty names + MayAlias = 1 << 0, // The attachment may alias physical memory of another attachment in the same render pass + ResolveSkipTransferFunctionKHR = 1 << 1, + ResolveEnableTransferFunctionKHR = 1 << 2, +} + +typealias VkAttachmentDescriptionFlags = VkAttachmentDescriptionFlagBits; + +[AllowDuplicates] enum VkAttachmentLoadOp : int32 +{ + [NoShow] VK_ATTACHMENT_LOAD_OP_LOAD = 0, + [NoShow] VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + [NoShow] VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + [NoShow] VK_ATTACHMENT_LOAD_OP_NONE = 1000400000, + [NoShow] VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE, + [NoShow] VK_ATTACHMENT_LOAD_OP_NONE_KHR = VK_ATTACHMENT_LOAD_OP_NONE, + // pretty names + Load = 0, + Clear = 1, + DontCare = 2, + None = 1000400000, + NoneEXT = None, + NoneKHR = None, +} + +[CRepr] struct VkAttachmentReference : this() +{ + public uint32 attachment = 0; + public VkImageLayout layout = default; + + public this(uint32 attachment, VkImageLayout layout) : this() + { + this.attachment = attachment; + this.layout = layout; + } +} + +[AllowDuplicates] enum VkAttachmentStoreOp : int32 +{ + [NoShow] VK_ATTACHMENT_STORE_OP_STORE = 0, + [NoShow] VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + [NoShow] VK_ATTACHMENT_STORE_OP_NONE = 1000301000, + [NoShow] VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, + [NoShow] VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, + [NoShow] VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, + // pretty names + Store = 0, + DontCare = 1, + None = 1000301000, + NoneKHR = None, + NoneQCOM = None, + NoneEXT = None, +} + +struct VkFramebuffer : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_FRAMEBUFFER; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkFramebufferCreateFlagBits : int32 +{ + [NoShow] VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1 << 0, + [NoShow] VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, + // pretty names + Imageless = 1 << 0, + ImagelessKHR = Imageless, +} + +typealias VkFramebufferCreateFlags = VkFramebufferCreateFlagBits; + +[CRepr] struct VkFramebufferCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFramebufferCreateFlags flags = default; + public VkRenderPass renderPass = null; + public uint32 attachmentCount = 0; + public VkImageView* pAttachments = null; + public Span attachments + { + get { return .(pAttachments, (.)attachmentCount); } + set mut { pAttachments = value.Ptr; attachmentCount = (.)value.Length; } + } + public uint32 width = 0; + public uint32 height = 0; + public uint32 layers = 0; + + public this(void* pNext, VkFramebufferCreateFlags flags, VkRenderPass renderPass, Span attachments, uint32 width, uint32 height, uint32 layers) : this() + { + this.pNext = pNext; + this.flags = flags; + this.renderPass = renderPass; + this.attachments = attachments; + this.width = width; + this.height = height; + this.layers = layers; + } +} + +struct VkRenderPass : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_RENDER_PASS; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkRenderPassCreateFlagBits : int32 +{ + [NoShow] VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 1 << 1, + [NoShow] VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 1 << 2, + // pretty names + TransformQCOM = 1 << 1, + PerLayerFragmentDensityVALVE = 1 << 2, +} + +typealias VkRenderPassCreateFlags = VkRenderPassCreateFlagBits; + +[CRepr] struct VkRenderPassCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPassCreateFlags flags = default; + public uint32 attachmentCount = 0; + public VkAttachmentDescription* pAttachments = null; + public Span attachments + { + get { return .(pAttachments, (.)attachmentCount); } + set mut { pAttachments = value.Ptr; attachmentCount = (.)value.Length; } + } + public uint32 subpassCount = 0; + public VkSubpassDescription* pSubpasses = null; + public Span subpasses + { + get { return .(pSubpasses, (.)subpassCount); } + set mut { pSubpasses = value.Ptr; subpassCount = (.)value.Length; } + } + public uint32 dependencyCount = 0; + public VkSubpassDependency* pDependencies = null; + public Span dependencies + { + get { return .(pDependencies, (.)dependencyCount); } + set mut { pDependencies = value.Ptr; dependencyCount = (.)value.Length; } + } + + public this(void* pNext, VkRenderPassCreateFlags flags, Span attachments, Span subpasses, Span dependencies = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.attachments = attachments; + this.subpasses = subpasses; + this.dependencies = dependencies; + } +} + +[CRepr] struct VkSubpassDependency : this() +{ + public uint32 srcSubpass = 0; + public uint32 dstSubpass = 0; + public VkPipelineStageFlags srcStageMask = default; + public VkPipelineStageFlags dstStageMask = default; + public VkAccessFlags srcAccessMask = default; // Memory accesses from the source of the dependency to synchronize + public VkAccessFlags dstAccessMask = default; // Memory accesses from the destination of the dependency to synchronize + public VkDependencyFlags dependencyFlags = default; + + public this(uint32 srcSubpass, uint32 dstSubpass, VkPipelineStageFlags srcStageMask = default, VkPipelineStageFlags dstStageMask = default, VkAccessFlags srcAccessMask = default, VkAccessFlags dstAccessMask = default, VkDependencyFlags dependencyFlags = default) : this() + { + this.srcSubpass = srcSubpass; + this.dstSubpass = dstSubpass; + this.srcStageMask = srcStageMask; + this.dstStageMask = dstStageMask; + this.srcAccessMask = srcAccessMask; + this.dstAccessMask = dstAccessMask; + this.dependencyFlags = dependencyFlags; + } +} + +[CRepr] struct VkSubpassDescription : this() +{ + public VkSubpassDescriptionFlags flags = default; + public VkPipelineBindPoint pipelineBindPoint = default; // Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now + public uint32 inputAttachmentCount = 0; + public VkAttachmentReference* pInputAttachments = null; + public Span inputAttachments + { + get { return .(pInputAttachments, (.)inputAttachmentCount); } + set mut { pInputAttachments = value.Ptr; inputAttachmentCount = (.)value.Length; } + } + public uint32 colorAttachmentCount = 0; + public VkAttachmentReference* pColorAttachments = null; + public VkAttachmentReference* pResolveAttachments = null; + public VkAttachmentReference* pDepthStencilAttachment = null; + public uint32 preserveAttachmentCount = 0; + public uint32* pPreserveAttachments = null; + public Span preserveAttachments + { + get { return .(pPreserveAttachments, (.)preserveAttachmentCount); } + set mut { pPreserveAttachments = value.Ptr; preserveAttachmentCount = (.)value.Length; } + } + + public this(VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint, Span inputAttachments, uint32 colorAttachmentCount, VkAttachmentReference* pColorAttachments, VkAttachmentReference* pResolveAttachments = null, VkAttachmentReference* pDepthStencilAttachment = null, Span preserveAttachments = default) : this() + { + this.flags = flags; + this.pipelineBindPoint = pipelineBindPoint; + this.inputAttachments = inputAttachments; + this.colorAttachmentCount = colorAttachmentCount; + this.pColorAttachments = pColorAttachments; + this.pResolveAttachments = pResolveAttachments; + this.pDepthStencilAttachment = pDepthStencilAttachment; + this.preserveAttachments = preserveAttachments; + } +} + +[AllowDuplicates] enum VkSubpassDescriptionFlagBits : int32 +{ + [NoShow] VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 1 << 0, + [NoShow] VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 1 << 1, + [NoShow] VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, + [NoShow] VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT, + [NoShow] VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 1 << 8, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 1 << 4, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 1 << 5, + [NoShow] VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 1 << 6, + [NoShow] VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 1 << 7, + [NoShow] VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT = 1 << 2, + [NoShow] VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT = 1 << 3, + // pretty names + PerViewAttributesNVX = 1 << 0, + PerViewPositionXOnlyNVX = 1 << 1, + FragmentRegionQCOM = FragmentRegionEXT, + ShaderResolveQCOM = CustomResolveEXT, + TileShadingApronQCOM = 1 << 8, + RasterizationOrderAttachmentColorAccessARM = RasterizationOrderAttachmentColorAccessEXT, + RasterizationOrderAttachmentDepthAccessARM = RasterizationOrderAttachmentDepthAccessEXT, + RasterizationOrderAttachmentStencilAccessARM = RasterizationOrderAttachmentStencilAccessEXT, + RasterizationOrderAttachmentColorAccessEXT = 1 << 4, + RasterizationOrderAttachmentDepthAccessEXT = 1 << 5, + RasterizationOrderAttachmentStencilAccessEXT = 1 << 6, + EnableLegacyDitheringEXT = 1 << 7, + FragmentRegionEXT = 1 << 2, + CustomResolveEXT = 1 << 3, +} + +typealias VkSubpassDescriptionFlags = VkSubpassDescriptionFlagBits; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateFramebuffer(VkDevice device, VkFramebufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkFramebuffer pFramebuffer); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateRenderPass(VkDevice device, VkRenderPassCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkRenderPass pRenderPass); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, out VkExtent2D pGranularity); + +// Command buffer building commands +[CRepr] struct VkClearAttachment : this() +{ + public VkImageAspectFlags aspectMask = default; + public uint32 colorAttachment = 0; + public VkClearValue clearValue = default; + + public this(VkImageAspectFlags aspectMask, uint32 colorAttachment, VkClearValue clearValue) : this() + { + this.aspectMask = aspectMask; + this.colorAttachment = colorAttachment; + this.clearValue = clearValue; + } +} + +[CRepr] struct VkClearDepthStencilValue : this() +{ + public float depth = 0; + public uint32 stencil = 0; + + public this(float depth, uint32 stencil) : this() + { + this.depth = depth; + this.stencil = stencil; + } +} + +[CRepr] struct VkClearRect : this() +{ + public VkRect2D rect = default; + public uint32 baseArrayLayer = 0; + public uint32 layerCount = 0; + + public this(VkRect2D rect, uint32 baseArrayLayer, uint32 layerCount) : this() + { + this.rect = rect; + this.baseArrayLayer = baseArrayLayer; + this.layerCount = layerCount; + } +} + +// Union allowing specification of color or depth and stencil values. Actual value selected is based on attachment being cleared. +[CRepr, Union] struct VkClearValue : this() +{ + public VkClearColorValue color = default; + public VkClearDepthStencilValue depthStencil = default; + + public this(VkClearColorValue color, VkClearDepthStencilValue depthStencil) : this() + { + this.color = color; + this.depthStencil = depthStencil; + } +} + +[CRepr] struct VkImageBlit : this() +{ + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D[2] srcOffsets = .(); // Specified in pixels for both compressed and uncompressed images + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D[2] dstOffsets = .(); // Specified in pixels for both compressed and uncompressed images + + public this(VkImageSubresourceLayers srcSubresource, VkOffset3D[2] srcOffsets, VkImageSubresourceLayers dstSubresource, VkOffset3D[2] dstOffsets) : this() + { + this.srcSubresource = srcSubresource; + this.srcOffsets = srcOffsets; + this.dstSubresource = dstSubresource; + this.dstOffsets = dstOffsets; + } +} + +[CRepr] struct VkImageResolve : this() +{ + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D srcOffset = default; + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D dstOffset = default; + public VkExtent3D extent = default; + + public this(VkImageSubresourceLayers srcSubresource, VkOffset3D srcOffset, VkImageSubresourceLayers dstSubresource, VkOffset3D dstOffset, VkExtent3D extent) : this() + { + this.srcSubresource = srcSubresource; + this.srcOffset = srcOffset; + this.dstSubresource = dstSubresource; + this.dstOffset = dstOffset; + this.extent = extent; + } +} + +[CRepr] struct VkRenderPassBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPass renderPass = null; + public VkFramebuffer framebuffer = null; + public VkRect2D renderArea = default; + public uint32 clearValueCount = 0; + public VkClearValue* pClearValues = null; + public Span clearValues + { + get { return .(pClearValues, (.)clearValueCount); } + set mut { pClearValues = value.Ptr; clearValueCount = (.)value.Length; } + } + + public this(void* pNext, VkRenderPass renderPass, VkFramebuffer framebuffer, VkRect2D renderArea, Span clearValues = default) : this() + { + this.pNext = pNext; + this.renderPass = renderPass; + this.framebuffer = framebuffer; + this.renderArea = renderArea; + this.clearValues = clearValues; + } +} + +[AllowDuplicates] enum VkStencilFaceFlagBits : int32 +{ + [NoShow] VK_STENCIL_FACE_FRONT_BIT = 1 << 0, // Front face + [NoShow] VK_STENCIL_FACE_BACK_BIT = 1 << 1, // Back face + [NoShow] VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, // Front and back faces + [NoShow] VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + // pretty names + Front = 1 << 0, // Front face + Back = 1 << 1, // Back face + FrontAndBack = 0x00000003, // Front and back faces + VkStencilFrontAndBack = FrontAndBack, +} + +typealias VkStencilFaceFlags = VkStencilFaceFlagBits; + +[AllowDuplicates] enum VkSubpassContents : int32 +{ + [NoShow] VK_SUBPASS_CONTENTS_INLINE = 0, + [NoShow] VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + [NoShow] VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, + [NoShow] VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000, + // pretty names + Inline = 0, + SecondaryCommandBuffers = 1, + InlineAndSecondaryCommandBuffersEXT = InlineAndSecondaryCommandBuffersKHR, + InlineAndSecondaryCommandBuffersKHR = 1000451000, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewport* pViewports); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32 firstScissor, uint32 scissorCount, VkRect2D* pScissors); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, float[4] blendConstants); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 compareMask); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 writeMask); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32 reference); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDraw(VkCommandBuffer commandBuffer, uint32 vertexCount, uint32 instanceCount, uint32 firstVertex, uint32 firstInstance); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32 indexCount, uint32 instanceCount, uint32 firstIndex, int32 vertexOffset, uint32 firstInstance); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageBlit* pRegions, VkFilter filter); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, uint32 rangeCount, VkImageSubresourceRange* pRanges); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32 attachmentCount, VkClearAttachment* pAttachments, uint32 rectCount, VkClearRect* pRects); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32 regionCount, VkImageResolve* pRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndRenderPass(VkCommandBuffer commandBuffer); + +// Vulkan core API interface definitions +// Feature requirements +// Vulkan base 1.1 API interface definitions. +// API version macros +// Vulkan 1.1 version number +static { public const let VK_API_VERSION_1_1 = VK_MAKE_API_VERSION(0, 1, 1, 0); }// Patch version should always be set to 0 + +// Device Initialization +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumerateInstanceVersion(out uint32 pApiVersion); + +// Promoted from VK_KHR_bind_memory2 +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindBufferMemory2(VkDevice device, uint32 bindInfoCount, VkBindBufferMemoryInfo* pBindInfos); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindImageMemory2(VkDevice device, uint32 bindInfoCount, VkBindImageMemoryInfo* pBindInfos); + +[CRepr] struct VkBindBufferMemoryInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + + public this(void* pNext, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) : this() + { + this.pNext = pNext; + this.buffer = buffer; + this.memory = memory; + this.memoryOffset = memoryOffset; + } +} + +[CRepr] struct VkBindImageMemoryInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + + public this(void* pNext, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) : this() + { + this.pNext = pNext; + this.image = image; + this.memory = memory; + this.memoryOffset = memoryOffset; + } +} + +// Promoted from VK_KHR_dedicated_allocation +[CRepr] struct VkMemoryDedicatedRequirements : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 prefersDedicatedAllocation = false; + public VkBool32 requiresDedicatedAllocation = false; +} + +[CRepr] struct VkMemoryDedicatedAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; // Image that this allocation will be bound to + public VkBuffer buffer = null; // Buffer that this allocation will be bound to + + public this(void* pNext = null, VkImage image = null, VkBuffer buffer = null) : this() + { + this.pNext = pNext; + this.image = image; + this.buffer = buffer; + } +} + +// Promoted from VK_KHR_device_group +typealias VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlagBits; + +[AllowDuplicates] enum VkPeerMemoryFeatureFlagBits : int32 +{ + [NoShow] VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1 << 0, // Can read with vkCmdCopy commands + [NoShow] VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 1 << 1, // Can write with vkCmdCopy commands + [NoShow] VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 1 << 2, // Can read with any access type/command + [NoShow] VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 1 << 3, // Can write with and access type/command + [NoShow] VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + [NoShow] VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + [NoShow] VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + [NoShow] VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + // pretty names + CopySrc = 1 << 0, // Can read with vkCmdCopy commands + CopyDst = 1 << 1, // Can write with vkCmdCopy commands + GenericSrc = 1 << 2, // Can read with any access type/command + GenericDst = 1 << 3, // Can write with and access type/command + CopySrcKHR = CopySrc, + CopyDstKHR = CopyDst, + GenericSrcKHR = GenericSrc, + GenericDstKHR = GenericDst, +} + +typealias VkMemoryAllocateFlags = VkMemoryAllocateFlagBits; + +[AllowDuplicates] enum VkMemoryAllocateFlagBits : int32 +{ + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1 << 0, // Force allocation on specific devices + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 1 << 1, + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 1 << 2, + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, + [NoShow] VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + [NoShow] VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT = 1 << 3, + // pretty names + DeviceMask = 1 << 0, // Force allocation on specific devices + DeviceAddress = 1 << 1, + DeviceAddressCaptureReplay = 1 << 2, + DeviceMaskKHR = DeviceMask, + DeviceAddressKHR = DeviceAddress, + DeviceAddressCaptureReplayKHR = DeviceAddressCaptureReplay, + ZeroInitializeEXT = 1 << 3, +} + +[CRepr] struct VkMemoryAllocateFlagsInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryAllocateFlags flags = default; + public uint32 deviceMask = 0; + + public this(void* pNext, VkMemoryAllocateFlags flags, uint32 deviceMask) : this() + { + this.pNext = pNext; + this.flags = flags; + this.deviceMask = deviceMask; + } +} + +[CRepr] struct VkDeviceGroupCommandBufferBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 deviceMask = 0; + + public this(void* pNext, uint32 deviceMask) : this() + { + this.pNext = pNext; + this.deviceMask = deviceMask; + } +} + +[CRepr] struct VkDeviceGroupSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreCount = 0; + public uint32* pWaitSemaphoreDeviceIndices = null; + public Span waitSemaphoreDeviceIndices + { + get { return .(pWaitSemaphoreDeviceIndices, (.)waitSemaphoreCount); } + set mut { pWaitSemaphoreDeviceIndices = value.Ptr; waitSemaphoreCount = (.)value.Length; } + } + public uint32 commandBufferCount = 0; + public uint32* pCommandBufferDeviceMasks = null; + public Span commandBufferDeviceMasks + { + get { return .(pCommandBufferDeviceMasks, (.)commandBufferCount); } + set mut { pCommandBufferDeviceMasks = value.Ptr; commandBufferCount = (.)value.Length; } + } + public uint32 signalSemaphoreCount = 0; + public uint32* pSignalSemaphoreDeviceIndices = null; + public Span signalSemaphoreDeviceIndices + { + get { return .(pSignalSemaphoreDeviceIndices, (.)signalSemaphoreCount); } + set mut { pSignalSemaphoreDeviceIndices = value.Ptr; signalSemaphoreCount = (.)value.Length; } + } + + public this(void* pNext = null, Span waitSemaphoreDeviceIndices = default, Span commandBufferDeviceMasks = default, Span signalSemaphoreDeviceIndices = default) : this() + { + this.pNext = pNext; + this.waitSemaphoreDeviceIndices = waitSemaphoreDeviceIndices; + this.commandBufferDeviceMasks = commandBufferDeviceMasks; + this.signalSemaphoreDeviceIndices = signalSemaphoreDeviceIndices; + } +} + +[CRepr] struct VkDeviceGroupBindSparseInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 resourceDeviceIndex = 0; + public uint32 memoryDeviceIndex = 0; + + public this(void* pNext, uint32 resourceDeviceIndex, uint32 memoryDeviceIndex) : this() + { + this.pNext = pNext; + this.resourceDeviceIndex = resourceDeviceIndex; + this.memoryDeviceIndex = memoryDeviceIndex; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32 heapIndex, uint32 localDeviceIndex, uint32 remoteDeviceIndex, out VkPeerMemoryFeatureFlags pPeerMemoryFeatures); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32 deviceMask); + +// Promoted from VK_KHR_device_group + VK_KHR_bind_memory2 +[CRepr] struct VkBindBufferMemoryDeviceGroupInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 deviceIndexCount = 0; + public uint32* pDeviceIndices = null; + public Span deviceIndices + { + get { return .(pDeviceIndices, (.)deviceIndexCount); } + set mut { pDeviceIndices = value.Ptr; deviceIndexCount = (.)value.Length; } + } + + public this(void* pNext = null, Span deviceIndices = default) : this() + { + this.pNext = pNext; + this.deviceIndices = deviceIndices; + } +} + +[CRepr] struct VkBindImageMemoryDeviceGroupInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 deviceIndexCount = 0; + public uint32* pDeviceIndices = null; + public Span deviceIndices + { + get { return .(pDeviceIndices, (.)deviceIndexCount); } + set mut { pDeviceIndices = value.Ptr; deviceIndexCount = (.)value.Length; } + } + public uint32 splitInstanceBindRegionCount = 0; + public VkRect2D* pSplitInstanceBindRegions = null; + public Span splitInstanceBindRegions + { + get { return .(pSplitInstanceBindRegions, (.)splitInstanceBindRegionCount); } + set mut { pSplitInstanceBindRegions = value.Ptr; splitInstanceBindRegionCount = (.)value.Length; } + } + + public this(void* pNext = null, Span deviceIndices = default, Span splitInstanceBindRegions = default) : this() + { + this.pNext = pNext; + this.deviceIndices = deviceIndices; + this.splitInstanceBindRegions = splitInstanceBindRegions; + } +} + +// Promoted from VK_KHR_device_group_creation +static { public const uint32 VK_MAX_DEVICE_GROUP_SIZE = 32; } + +[CRepr] struct VkPhysicalDeviceGroupProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 physicalDeviceCount = 0; + public VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE] physicalDevices = .(); + public Span hysicalDevices + { + get mut { return .(&physicalDevices, (.)physicalDeviceCount); } + set mut { value.CopyTo(physicalDevices); physicalDeviceCount = (.)value.Length; } + } + public VkBool32 subsetAllocation = false; +} + +[CRepr] struct VkDeviceGroupDeviceCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 physicalDeviceCount = 0; + public VkPhysicalDevice* pPhysicalDevices = null; + public Span physicalDevices + { + get { return .(pPhysicalDevices, (.)physicalDeviceCount); } + set mut { pPhysicalDevices = value.Ptr; physicalDeviceCount = (.)value.Length; } + } + + public this(void* pNext = null, Span physicalDevices = default) : this() + { + this.pNext = pNext; + this.physicalDevices = physicalDevices; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumeratePhysicalDeviceGroups(VkInstance instance, out uint32 pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties = null); + +// Promoted from VK_KHR_get_memory_requirements2 +[CRepr] struct VkBufferMemoryRequirementsInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + + public this(void* pNext, VkBuffer buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkImageMemoryRequirementsInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + + public this(void* pNext, VkImage image) : this() + { + this.pNext = pNext; + this.image = image; + } +} + +[CRepr] struct VkImageSparseMemoryRequirementsInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + + public this(void* pNext, VkImage image) : this() + { + this.pNext = pNext; + this.image = image; + } +} + +[CRepr] struct VkMemoryRequirements2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryRequirements memoryRequirements = default; +} + +[CRepr] struct VkSparseImageMemoryRequirements2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSparseImageMemoryRequirements memoryRequirements = default; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageMemoryRequirements2(VkDevice device, VkImageMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetBufferMemoryRequirements2(VkDevice device, VkBufferMemoryRequirementsInfo2* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageSparseMemoryRequirements2(VkDevice device, VkImageSparseMemoryRequirementsInfo2* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null); + +// Promoted from VK_KHR_get_physical_device_properties2 +[CRepr] struct VkPhysicalDeviceFeatures2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceFeatures features = default; + + public this(void* pNext, VkPhysicalDeviceFeatures features) : this() + { + this.pNext = pNext; + this.features = features; + } +} + +[CRepr] struct VkPhysicalDeviceProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceProperties properties = default; +} + +[CRepr] struct VkFormatProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormatProperties formatProperties = default; +} + +[CRepr] struct VkImageFormatProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageFormatProperties imageFormatProperties = default; +} + +[CRepr] struct VkPhysicalDeviceImageFormatInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public VkImageType type = default; + public VkImageTiling tiling = default; + public VkImageUsageFlags usage = default; + public VkImageCreateFlags flags = default; + + public this(void* pNext, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags = default) : this() + { + this.pNext = pNext; + this.format = format; + this.type = type; + this.tiling = tiling; + this.usage = usage; + this.flags = flags; + } +} + +[CRepr] struct VkQueueFamilyProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueueFamilyProperties queueFamilyProperties = default; +} + +[CRepr] struct VkPhysicalDeviceMemoryProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceMemoryProperties memoryProperties = default; +} + +[CRepr] struct VkSparseImageFormatProperties2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSparseImageFormatProperties properties = default; +} + +[CRepr] struct VkPhysicalDeviceSparseImageFormatInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public VkImageType type = default; + public VkSampleCountFlagBits samples = default; + public VkImageUsageFlags usage = default; + public VkImageTiling tiling = default; + + public this(void* pNext, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling) : this() + { + this.pNext = pNext; + this.format = format; + this.type = type; + this.samples = samples; + this.usage = usage; + this.tiling = tiling; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceFeatures2 pFeatures); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceProperties2 pProperties); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, out VkFormatProperties2 pFormatProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, out VkImageFormatProperties2 pImageFormatProperties); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, out uint32 pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, out VkPhysicalDeviceMemoryProperties2 pMemoryProperties); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, out uint32 pPropertyCount, VkSparseImageFormatProperties2* pProperties = null); + +// Promoted from VK_KHR_maintenance1 +[CallingConvention(VKAPI_PTR)] function void PFN_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags = default); + +typealias VkCommandPoolTrimFlags = VkFlags; + +// Promoted from VK_KHR_maintenance2 +[CRepr] struct VkImageViewUsageCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageUsageFlags usage = default; + + public this(void* pNext, VkImageUsageFlags usage) : this() + { + this.pNext = pNext; + this.usage = usage; + } +} + +// Originally based on VK_KHR_protected_memory (extension 146), which was never published; thus the mystifying large value= numbers below. These are not aliased since they were not actually promoted from an extension. +[AllowDuplicates] enum VkDeviceQueueCreateFlagBits : int32 +{ + [NoShow] VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1 << 0, // Queue is a protected-capable device queue + // pretty names + Protected = 1 << 0, // Queue is a protected-capable device queue +} + +[CRepr] struct VkPhysicalDeviceProtectedMemoryFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 protectedMemory = false; + + public this(void* pNext, VkBool32 protectedMemory) : this() + { + this.pNext = pNext; + this.protectedMemory = protectedMemory; + } +} + +[CRepr] struct VkPhysicalDeviceProtectedMemoryProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 protectedNoFault = false; +} + +[CRepr] struct VkDeviceQueueInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceQueueCreateFlags flags = default; + public uint32 queueFamilyIndex = 0; + public uint32 queueIndex = 0; + + public this(void* pNext, VkDeviceQueueCreateFlags flags, uint32 queueFamilyIndex, uint32 queueIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.queueFamilyIndex = queueFamilyIndex; + this.queueIndex = queueIndex; + } +} + +[CRepr] struct VkProtectedSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 protectedSubmit = false; // Submit protected command buffers + + public this(void* pNext, VkBool32 protectedSubmit) : this() + { + this.pNext = pNext; + this.protectedSubmit = protectedSubmit; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceQueue2(VkDevice device, VkDeviceQueueInfo2* pQueueInfo, out VkQueue pQueue); + +// Promoted from VK_KHR_sampler_ycbcr_conversion +[CRepr] struct VkBindImagePlaneMemoryInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageAspectFlagBits planeAspect = default; + + public this(void* pNext, VkImageAspectFlagBits planeAspect) : this() + { + this.pNext = pNext; + this.planeAspect = planeAspect; + } +} + +[CRepr] struct VkImagePlaneMemoryRequirementsInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageAspectFlagBits planeAspect = default; + + public this(void* pNext, VkImageAspectFlagBits planeAspect) : this() + { + this.pNext = pNext; + this.planeAspect = planeAspect; + } +} + +// Promoted from VK_KHR_external_memory_capabilities +static { public const uint32 VK_LUID_SIZE = 8; } + +typealias VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlagBits; + +[AllowDuplicates] enum VkExternalMemoryHandleTypeFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 1 << 2, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 1 << 3, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 1 << 4, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 1 << 5, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 1 << 6, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 1 << 9, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 1 << 10, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 1 << 7, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 1 << 8, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 1 << 11, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 1 << 12, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS = 1 << 15, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 1 << 14, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 1 << 16, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 1 << 17, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 1 << 18, + // pretty names + OpaqueFd = 1 << 0, + OpaqueWin32 = 1 << 1, + OpaqueWin32_Kmt = 1 << 2, + D3d11_Texture = 1 << 3, + D3d11_TextureKmt = 1 << 4, + D3d12_Heap = 1 << 5, + D3d12_Resource = 1 << 6, + OpaqueFdKHR = OpaqueFd, + OpaqueWin32KHR = OpaqueWin32, + OpaqueWin32_KmtKHR = OpaqueWin32_Kmt, + D3d11_TextureKHR = D3d11_Texture, + D3d11_TextureKmtKHR = D3d11_TextureKmt, + D3d12_HeapKHR = D3d12_Heap, + D3d12_ResourceKHR = D3d12_Resource, + DmaBufEXT = 1 << 9, + AndroidHardwareBufferANDROID = 1 << 10, + HostAllocationEXT = 1 << 7, + HostMappedForeignMemoryEXT = 1 << 8, + ZirconVmoFUCHSIA = 1 << 11, + RdmaAddressNV = 1 << 12, + OhNativeBufferOHOS = 1 << 15, + ScreenBufferQNX = 1 << 14, + MtlbufferEXT = 1 << 16, + MtltextureEXT = 1 << 17, + MtlheapEXT = 1 << 18, +} + +typealias VkExternalMemoryFeatureFlags = VkExternalMemoryFeatureFlagBits; + +[AllowDuplicates] enum VkExternalMemoryFeatureFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 1 << 2, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + // pretty names + DedicatedOnly = 1 << 0, + Exportable = 1 << 1, + Importable = 1 << 2, + DedicatedOnlyKHR = DedicatedOnly, + ExportableKHR = Exportable, + ImportableKHR = Importable, +} + +[CRepr] struct VkExternalMemoryProperties : this() +{ + public VkExternalMemoryFeatureFlags externalMemoryFeatures = default; + public VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes = default; + public VkExternalMemoryHandleTypeFlags compatibleHandleTypes = default; +} + +[CRepr] struct VkPhysicalDeviceExternalImageFormatInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagBits handleType = default) : this() + { + this.pNext = pNext; + this.handleType = handleType; + } +} + +[CRepr] struct VkExternalImageFormatProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryProperties externalMemoryProperties = default; +} + +[CRepr] struct VkPhysicalDeviceExternalBufferInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCreateFlags flags = default; + public VkBufferUsageFlags usage = default; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkBufferCreateFlags flags, VkBufferUsageFlags usage, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.flags = flags; + this.usage = usage; + this.handleType = handleType; + } +} + +[CRepr] struct VkExternalBufferProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryProperties externalMemoryProperties = default; +} + +[CRepr] struct VkPhysicalDeviceIDProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8[VK_UUID_SIZE] deviceUUID = .(); + public uint8[VK_UUID_SIZE] driverUUID = .(); + public uint8[VK_LUID_SIZE] deviceLUID = .(); + public uint32 deviceNodeMask = 0; + public VkBool32 deviceLUIDValid = false; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, out VkExternalBufferProperties pExternalBufferProperties); + +// Promoted from VK_KHR_external_memory +static { public const uint32 VK_QUEUE_FAMILY_EXTERNAL = (~1U); } + +[CRepr] struct VkExternalMemoryImageCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +[CRepr] struct VkExternalMemoryBufferCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +[CRepr] struct VkExportMemoryAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +// Promoted from VK_KHR_external_fence_capabilities +typealias VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlagBits; + +[AllowDuplicates] enum VkExternalFenceHandleTypeFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 1 << 2, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 1 << 3, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + [NoShow] VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + // pretty names + OpaqueFd = 1 << 0, + OpaqueWin32 = 1 << 1, + OpaqueWin32_Kmt = 1 << 2, + SyncFd = 1 << 3, + OpaqueFdKHR = OpaqueFd, + OpaqueWin32KHR = OpaqueWin32, + OpaqueWin32_KmtKHR = OpaqueWin32_Kmt, + SyncFdKHR = SyncFd, +} + +typealias VkExternalFenceFeatureFlags = VkExternalFenceFeatureFlagBits; + +[AllowDuplicates] enum VkExternalFenceFeatureFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + [NoShow] VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + // pretty names + Exportable = 1 << 0, + Importable = 1 << 1, + ExportableKHR = Exportable, + ImportableKHR = Importable, +} + +[CRepr] struct VkPhysicalDeviceExternalFenceInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalFenceHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkExternalFenceHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.handleType = handleType; + } +} + +[CRepr] struct VkExternalFenceProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes = default; + public VkExternalFenceHandleTypeFlags compatibleHandleTypes = default; + public VkExternalFenceFeatureFlags externalFenceFeatures = default; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, out VkExternalFenceProperties pExternalFenceProperties); + +// Promoted from VK_KHR_external_fence +typealias VkFenceImportFlags = VkFenceImportFlagBits; + +[AllowDuplicates] enum VkFenceImportFlagBits : int32 +{ + [NoShow] VK_FENCE_IMPORT_TEMPORARY_BIT = 1 << 0, + [NoShow] VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + // pretty names + Temporary = 1 << 0, + TemporaryKHR = Temporary, +} + +[CRepr] struct VkExportFenceCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalFenceHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalFenceHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +// Promoted from VK_KHR_external_semaphore +typealias VkSemaphoreImportFlags = VkSemaphoreImportFlagBits; + +[AllowDuplicates] enum VkSemaphoreImportFlagBits : int32 +{ + [NoShow] VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1 << 0, + [NoShow] VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + // pretty names + Temporary = 1 << 0, + TemporaryKHR = Temporary, +} + +[CRepr] struct VkExportSemaphoreCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalSemaphoreHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalSemaphoreHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +// Promoted from VK_KHR_external_semaphore_capabilities +typealias VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlagBits; + +[AllowDuplicates] enum VkExternalSemaphoreHandleTypeFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 1 << 2, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 1 << 3, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 1 << 4, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 1 << 7, + // pretty names + OpaqueFd = 1 << 0, + OpaqueWin32 = 1 << 1, + OpaqueWin32_Kmt = 1 << 2, + D3d12_Fence = 1 << 3, + D3d11_Fence = D3d12_Fence, + SyncFd = 1 << 4, + OpaqueFdKHR = OpaqueFd, + OpaqueWin32KHR = OpaqueWin32, + OpaqueWin32_KmtKHR = OpaqueWin32_Kmt, + D3d12_FenceKHR = D3d12_Fence, + SyncFdKHR = SyncFd, + ZirconEventFUCHSIA = 1 << 7, +} + +typealias VkExternalSemaphoreFeatureFlags = VkExternalSemaphoreFeatureFlagBits; + +[AllowDuplicates] enum VkExternalSemaphoreFeatureFlagBits : int32 +{ + [NoShow] VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1 << 0, + [NoShow] VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 1 << 1, + [NoShow] VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + [NoShow] VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + // pretty names + Exportable = 1 << 0, + Importable = 1 << 1, + ExportableKHR = Exportable, + ImportableKHR = Importable, +} + +[CRepr] struct VkPhysicalDeviceExternalSemaphoreInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkExternalSemaphoreHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.handleType = handleType; + } +} + +[CRepr] struct VkExternalSemaphoreProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes = default; + public VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes = default; + public VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures = default; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, out VkExternalSemaphoreProperties pExternalSemaphoreProperties); + +// Vulkan compute 1.1 API interface definitions. +// Promoted from VK_KHR_relaxed_block_layout, which has no API +// Promoted from VK_KHR_storage_buffer_storage_class, which has no API +// Originally based on VK_KHR_subgroup (extension 94), but the actual enum block used was, incorrectly, that of extension 95 +[CRepr] struct VkPhysicalDeviceSubgroupProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 subgroupSize = 0; // The size of a subgroup for this queue. + public VkShaderStageFlags supportedStages = default; // Bitfield of what shader stages support subgroup operations + public VkSubgroupFeatureFlags supportedOperations = default; // Bitfield of what subgroup operations are supported. + public VkBool32 quadOperationsInAllStages = false; // Flag to specify whether quad operations are available in all stages. +} + +typealias VkSubgroupFeatureFlags = VkSubgroupFeatureFlagBits; + +[AllowDuplicates] enum VkSubgroupFeatureFlagBits : int32 +{ + [NoShow] VK_SUBGROUP_FEATURE_BASIC_BIT = 1 << 0, // Basic subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_VOTE_BIT = 1 << 1, // Vote subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 1 << 2, // Arithmetic subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_BALLOT_BIT = 1 << 3, // Ballot subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 1 << 4, // Shuffle subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 1 << 5, // Shuffle relative subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 1 << 6, // Clustered subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_QUAD_BIT = 1 << 7, // Quad subgroup operations + [NoShow] VK_SUBGROUP_FEATURE_ROTATE_BIT = 1 << 9, + [NoShow] VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 1 << 10, + [NoShow] VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 1 << 8, + [NoShow] VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT, + [NoShow] VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, + // pretty names + Basic = 1 << 0, // Basic subgroup operations + Vote = 1 << 1, // Vote subgroup operations + Arithmetic = 1 << 2, // Arithmetic subgroup operations + Ballot = 1 << 3, // Ballot subgroup operations + Shuffle = 1 << 4, // Shuffle subgroup operations + ShuffleRelative = 1 << 5, // Shuffle relative subgroup operations + Clustered = 1 << 6, // Clustered subgroup operations + Quad = 1 << 7, // Quad subgroup operations + Rotate = 1 << 9, + RotateClustered = 1 << 10, + PartitionedNV = 1 << 8, + RotateKHR = Rotate, + RotateClusteredKHR = RotateClustered, +} + +// Promoted from VK_KHR_16bit_storage +[CRepr] struct VkPhysicalDevice16BitStorageFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 storageBuffer16BitAccess = false; // 16-bit integer/floating-point variables supported in BufferBlock + public VkBool32 uniformAndStorageBuffer16BitAccess = false; // 16-bit integer/floating-point variables supported in BufferBlock and Block + public VkBool32 storagePushConstant16 = false; // 16-bit integer/floating-point variables supported in PushConstant + public VkBool32 storageInputOutput16 = false; // 16-bit integer/floating-point variables supported in shader inputs and outputs + + public this(void* pNext, VkBool32 storageBuffer16BitAccess, VkBool32 uniformAndStorageBuffer16BitAccess, VkBool32 storagePushConstant16, VkBool32 storageInputOutput16) : this() + { + this.pNext = pNext; + this.storageBuffer16BitAccess = storageBuffer16BitAccess; + this.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess; + this.storagePushConstant16 = storagePushConstant16; + this.storageInputOutput16 = storageInputOutput16; + } +} + +// Promoted from VK_KHR_device_group +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32 baseGroupX, uint32 baseGroupY, uint32 baseGroupZ, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ); + +// Promoted from VK_KHR_variable_pointers +typealias VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures; + +[CRepr] struct VkPhysicalDeviceVariablePointersFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 variablePointersStorageBuffer = false; + public VkBool32 variablePointers = false; + + public this(void* pNext, VkBool32 variablePointersStorageBuffer, VkBool32 variablePointers) : this() + { + this.pNext = pNext; + this.variablePointersStorageBuffer = variablePointersStorageBuffer; + this.variablePointers = variablePointers; + } +} + +// Promoted from VK_KHR_descriptor_update_template +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDescriptorUpdateTemplate pDescriptorUpdateTemplate); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void* pData); + +struct VkDescriptorUpdateTemplate : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkDescriptorUpdateTemplateCreateFlags = VkFlags; + +[AllowDuplicates] enum VkDescriptorUpdateTemplateType : int32 +{ + [NoShow] VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, // Create descriptor update template for descriptor set updates + [NoShow] VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1, + [NoShow] VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, // Create descriptor update template for pushed descriptor updates + [NoShow] VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + // pretty names + DescriptorSet = 0, // Create descriptor update template for descriptor set updates + PushDescriptors = 1, + PushDescriptorsKHR = PushDescriptors, // Create descriptor update template for pushed descriptor updates + DescriptorSetKHR = DescriptorSet, +} + +[CRepr] struct VkDescriptorUpdateTemplateEntry : this() +{ + public uint32 dstBinding = 0; // Binding within the destination descriptor set to write + public uint32 dstArrayElement = 0; // Array element within the destination binding to write + public uint32 descriptorCount = 0; // Number of descriptors to write + public VkDescriptorType descriptorType = default; // Descriptor type to write + public c_size offset = 0; // Offset into pData where the descriptors to update are stored + public c_size stride = 0; // Stride between two descriptors in pData when writing more than one descriptor + + public this(uint32 dstBinding, uint32 dstArrayElement, uint32 descriptorCount, VkDescriptorType descriptorType, c_size offset, c_size stride) : this() + { + this.dstBinding = dstBinding; + this.dstArrayElement = dstArrayElement; + this.descriptorCount = descriptorCount; + this.descriptorType = descriptorType; + this.offset = offset; + this.stride = stride; + } +} + +[CRepr] struct VkDescriptorUpdateTemplateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorUpdateTemplateCreateFlags flags = default; + public uint32 descriptorUpdateEntryCount = 0; // Number of descriptor update entries to use for the update template + public VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries = null; // Descriptor update entries for the template + public Span descriptorUpdateEntries + { + get { return .(pDescriptorUpdateEntries, (.)descriptorUpdateEntryCount); } + set mut { pDescriptorUpdateEntries = value.Ptr; descriptorUpdateEntryCount = (.)value.Length; } + } + public VkDescriptorUpdateTemplateType templateType = default; + public VkDescriptorSetLayout descriptorSetLayout = null; + public VkPipelineBindPoint pipelineBindPoint = default; + public VkPipelineLayout pipelineLayout = null; // If used for push descriptors, this is the only allowed layout + public uint32 set = 0; + + public this(void* pNext, VkDescriptorUpdateTemplateCreateFlags flags, Span descriptorUpdateEntries, VkDescriptorUpdateTemplateType templateType, VkDescriptorSetLayout descriptorSetLayout, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout pipelineLayout, uint32 set) : this() + { + this.pNext = pNext; + this.flags = flags; + this.descriptorUpdateEntries = descriptorUpdateEntries; + this.templateType = templateType; + this.descriptorSetLayout = descriptorSetLayout; + this.pipelineBindPoint = pipelineBindPoint; + this.pipelineLayout = pipelineLayout; + this.set = set; + } +} + +// Promoted from VK_KHR_maintenance3 +[CRepr] struct VkPhysicalDeviceMaintenance3Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxPerSetDescriptors = 0; + public VkDeviceSize maxMemoryAllocationSize = default; +} + +[CRepr] struct VkDescriptorSetLayoutSupport : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 supported = false; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorSetLayoutSupport(VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, out VkDescriptorSetLayoutSupport pSupport); + +// Promoted from VK_KHR_sampler_ycbcr_conversion +[CRepr] struct VkSamplerYcbcrConversionCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public VkSamplerYcbcrModelConversion ycbcrModel = default; + public VkSamplerYcbcrRange ycbcrRange = default; + public VkComponentMapping components = default; + public VkChromaLocation xChromaOffset = default; + public VkChromaLocation yChromaOffset = default; + public VkFilter chromaFilter = default; + public VkBool32 forceExplicitReconstruction = false; + + public this(void* pNext, VkFormat format, VkSamplerYcbcrModelConversion ycbcrModel, VkSamplerYcbcrRange ycbcrRange, VkComponentMapping components, VkChromaLocation xChromaOffset, VkChromaLocation yChromaOffset, VkFilter chromaFilter, VkBool32 forceExplicitReconstruction) : this() + { + this.pNext = pNext; + this.format = format; + this.ycbcrModel = ycbcrModel; + this.ycbcrRange = ycbcrRange; + this.components = components; + this.xChromaOffset = xChromaOffset; + this.yChromaOffset = yChromaOffset; + this.chromaFilter = chromaFilter; + this.forceExplicitReconstruction = forceExplicitReconstruction; + } +} + +[CRepr] struct VkSamplerYcbcrConversionInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSamplerYcbcrConversion conversion = null; + + public this(void* pNext, VkSamplerYcbcrConversion conversion) : this() + { + this.pNext = pNext; + this.conversion = conversion; + } +} + +[CRepr] struct VkPhysicalDeviceSamplerYcbcrConversionFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 samplerYcbcrConversion = false; // Sampler color conversion supported + + public this(void* pNext, VkBool32 samplerYcbcrConversion) : this() + { + this.pNext = pNext; + this.samplerYcbcrConversion = samplerYcbcrConversion; + } +} + +[CRepr] struct VkSamplerYcbcrConversionImageFormatProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 combinedImageSamplerDescriptorCount = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversionCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSamplerYcbcrConversion pYcbcrConversion); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion = null, VkAllocationCallbacks* pAllocator = null); + +struct VkSamplerYcbcrConversion : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkSamplerYcbcrModelConversion : int32 +{ + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, // just range expansion + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, // aka HD YUV + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, // aka SD YUV + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, // aka UHD YUV + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + [NoShow] VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + // pretty names + RgbIdentity = 0, + YcbcrIdentity = 1, // just range expansion + Ycbcr709 = 2, // aka HD YUV + Ycbcr601 = 3, // aka SD YUV + Ycbcr2020 = 4, // aka UHD YUV + RgbIdentityKHR = RgbIdentity, + YcbcrIdentityKHR = YcbcrIdentity, + Ycbcr709KHR = Ycbcr709, + Ycbcr601KHR = Ycbcr601, + Ycbcr2020KHR = Ycbcr2020, +} + +[AllowDuplicates] enum VkSamplerYcbcrRange : int32 +{ + [NoShow] VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, // Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped) + [NoShow] VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, // Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240 + [NoShow] VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + [NoShow] VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + // pretty names + ItuFull = 0, // Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped) + ItuNarrow = 1, // Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240 + ItuFullKHR = ItuFull, + ItuNarrowKHR = ItuNarrow, +} + +[AllowDuplicates] enum VkChromaLocation : int32 +{ + [NoShow] VK_CHROMA_LOCATION_COSITED_EVEN = 0, + [NoShow] VK_CHROMA_LOCATION_MIDPOINT = 1, + [NoShow] VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + [NoShow] VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + // pretty names + CositedEven = 0, + Midpoint = 1, + CositedEvenKHR = CositedEven, + MidpointKHR = Midpoint, +} + +// Vulkan graphics 1.1 API interface definitions. +// Promoted from VK_KHR_device_group +[CRepr] struct VkDeviceGroupRenderPassBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 deviceMask = 0; + public uint32 deviceRenderAreaCount = 0; + public VkRect2D* pDeviceRenderAreas = null; + public Span deviceRenderAreas + { + get { return .(pDeviceRenderAreas, (.)deviceRenderAreaCount); } + set mut { pDeviceRenderAreas = value.Ptr; deviceRenderAreaCount = (.)value.Length; } + } + + public this(void* pNext, uint32 deviceMask, Span deviceRenderAreas = default) : this() + { + this.pNext = pNext; + this.deviceMask = deviceMask; + this.deviceRenderAreas = deviceRenderAreas; + } +} + +// Promoted from VK_KHR_maintenance2 +[CRepr] struct VkPhysicalDevicePointClippingProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPointClippingBehavior pointClippingBehavior = default; +} + +[AllowDuplicates] enum VkPointClippingBehavior : int32 +{ + [NoShow] VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + [NoShow] VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + [NoShow] VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + [NoShow] VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + // pretty names + AllClipPlanes = 0, + UserClipPlanesOnly = 1, + AllClipPlanesKHR = AllClipPlanes, + UserClipPlanesOnlyKHR = UserClipPlanesOnly, +} + +[CRepr] struct VkRenderPassInputAttachmentAspectCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 aspectReferenceCount = 0; + public VkInputAttachmentAspectReference* pAspectReferences = null; + public Span aspectReferences + { + get { return .(pAspectReferences, (.)aspectReferenceCount); } + set mut { pAspectReferences = value.Ptr; aspectReferenceCount = (.)value.Length; } + } + + public this(void* pNext, Span aspectReferences) : this() + { + this.pNext = pNext; + this.aspectReferences = aspectReferences; + } +} + +[CRepr] struct VkInputAttachmentAspectReference : this() +{ + public uint32 subpass = 0; + public uint32 inputAttachmentIndex = 0; + public VkImageAspectFlags aspectMask = default; + + public this(uint32 subpass, uint32 inputAttachmentIndex, VkImageAspectFlags aspectMask) : this() + { + this.subpass = subpass; + this.inputAttachmentIndex = inputAttachmentIndex; + this.aspectMask = aspectMask; + } +} + +[AllowDuplicates] enum VkTessellationDomainOrigin : int32 +{ + [NoShow] VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + [NoShow] VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + [NoShow] VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + [NoShow] VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + // pretty names + UpperLeft = 0, + LowerLeft = 1, + UpperLeftKHR = UpperLeft, + LowerLeftKHR = LowerLeft, +} + +[CRepr] struct VkPipelineTessellationDomainOriginStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTessellationDomainOrigin domainOrigin = default; + + public this(void* pNext, VkTessellationDomainOrigin domainOrigin) : this() + { + this.pNext = pNext; + this.domainOrigin = domainOrigin; + } +} + +// Promoted from VK_KHR_multiview +[CRepr] struct VkRenderPassMultiviewCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 subpassCount = 0; + public uint32* pViewMasks = null; + public Span viewMasks + { + get { return .(pViewMasks, (.)subpassCount); } + set mut { pViewMasks = value.Ptr; subpassCount = (.)value.Length; } + } + public uint32 dependencyCount = 0; + public int32* pViewOffsets = null; + public Span viewOffsets + { + get { return .(pViewOffsets, (.)dependencyCount); } + set mut { pViewOffsets = value.Ptr; dependencyCount = (.)value.Length; } + } + public uint32 correlationMaskCount = 0; + public uint32* pCorrelationMasks = null; + public Span correlationMasks + { + get { return .(pCorrelationMasks, (.)correlationMaskCount); } + set mut { pCorrelationMasks = value.Ptr; correlationMaskCount = (.)value.Length; } + } + + public this(void* pNext = null, Span viewMasks = default, Span viewOffsets = default, Span correlationMasks = default) : this() + { + this.pNext = pNext; + this.viewMasks = viewMasks; + this.viewOffsets = viewOffsets; + this.correlationMasks = correlationMasks; + } +} + +[CRepr] struct VkPhysicalDeviceMultiviewFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multiview = false; // Multiple views in a render pass + public VkBool32 multiviewGeometryShader = false; // Multiple views in a render pass w/ geometry shader + public VkBool32 multiviewTessellationShader = false; // Multiple views in a render pass w/ tessellation shader + + public this(void* pNext, VkBool32 multiview, VkBool32 multiviewGeometryShader, VkBool32 multiviewTessellationShader) : this() + { + this.pNext = pNext; + this.multiview = multiview; + this.multiviewGeometryShader = multiviewGeometryShader; + this.multiviewTessellationShader = multiviewTessellationShader; + } +} + +[CRepr] struct VkPhysicalDeviceMultiviewProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxMultiviewViewCount = 0; // max number of views in a subpass + public uint32 maxMultiviewInstanceIndex = 0; // max instance index for a draw in a multiview subpass +} + +// Promoted from VK_KHR_shader_draw_parameters, with a feature support query added +typealias VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures; + +[CRepr] struct VkPhysicalDeviceShaderDrawParametersFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderDrawParameters = false; + + public this(void* pNext, VkBool32 shaderDrawParameters) : this() + { + this.pNext = pNext; + this.shaderDrawParameters = shaderDrawParameters; + } +} + +// Vulkan 1.1 core API interface definitions +// Feature requirements +// Vulkan base 1.2 API interface definitions. +// API version macros +// Vulkan 1.2 version number +static { public const let VK_API_VERSION_1_2 = VK_MAKE_API_VERSION(0, 1, 2, 0); }// Patch version should always be set to 0 + +[CRepr] struct VkPhysicalDeviceVulkan11Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 storageBuffer16BitAccess = false; // 16-bit integer/floating-point variables supported in BufferBlock + public VkBool32 uniformAndStorageBuffer16BitAccess = false; // 16-bit integer/floating-point variables supported in BufferBlock and Block + public VkBool32 storagePushConstant16 = false; // 16-bit integer/floating-point variables supported in PushConstant + public VkBool32 storageInputOutput16 = false; // 16-bit integer/floating-point variables supported in shader inputs and outputs + public VkBool32 multiview = false; // Multiple views in a render pass + public VkBool32 multiviewGeometryShader = false; // Multiple views in a render pass w/ geometry shader + public VkBool32 multiviewTessellationShader = false; // Multiple views in a render pass w/ tessellation shader + public VkBool32 variablePointersStorageBuffer = false; + public VkBool32 variablePointers = false; + public VkBool32 protectedMemory = false; + public VkBool32 samplerYcbcrConversion = false; // Sampler color conversion supported + public VkBool32 shaderDrawParameters = false; + + public this(void* pNext, VkBool32 storageBuffer16BitAccess, VkBool32 uniformAndStorageBuffer16BitAccess, VkBool32 storagePushConstant16, VkBool32 storageInputOutput16, VkBool32 multiview, VkBool32 multiviewGeometryShader, VkBool32 multiviewTessellationShader, VkBool32 variablePointersStorageBuffer, VkBool32 variablePointers, VkBool32 protectedMemory, VkBool32 samplerYcbcrConversion, VkBool32 shaderDrawParameters) : this() + { + this.pNext = pNext; + this.storageBuffer16BitAccess = storageBuffer16BitAccess; + this.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess; + this.storagePushConstant16 = storagePushConstant16; + this.storageInputOutput16 = storageInputOutput16; + this.multiview = multiview; + this.multiviewGeometryShader = multiviewGeometryShader; + this.multiviewTessellationShader = multiviewTessellationShader; + this.variablePointersStorageBuffer = variablePointersStorageBuffer; + this.variablePointers = variablePointers; + this.protectedMemory = protectedMemory; + this.samplerYcbcrConversion = samplerYcbcrConversion; + this.shaderDrawParameters = shaderDrawParameters; + } +} + +[CRepr] struct VkPhysicalDeviceVulkan11Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8[VK_UUID_SIZE] deviceUUID = .(); + public uint8[VK_UUID_SIZE] driverUUID = .(); + public uint8[VK_LUID_SIZE] deviceLUID = .(); + public uint32 deviceNodeMask = 0; + public VkBool32 deviceLUIDValid = false; + public uint32 subgroupSize = 0; // The size of a subgroup for this queue. + public VkShaderStageFlags subgroupSupportedStages = default; // Bitfield of what shader stages support subgroup operations + public VkSubgroupFeatureFlags subgroupSupportedOperations = default; // Bitfield of what subgroup operations are supported. + public VkBool32 subgroupQuadOperationsInAllStages = false; // Flag to specify whether quad operations are available in all stages. + public VkPointClippingBehavior pointClippingBehavior = default; + public uint32 maxMultiviewViewCount = 0; // max number of views in a subpass + public uint32 maxMultiviewInstanceIndex = 0; // max instance index for a draw in a multiview subpass + public VkBool32 protectedNoFault = false; + public uint32 maxPerSetDescriptors = 0; + public VkDeviceSize maxMemoryAllocationSize = default; +} + +[CRepr] struct VkPhysicalDeviceVulkan12Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 samplerMirrorClampToEdge = false; + public VkBool32 drawIndirectCount = false; + public VkBool32 storageBuffer8BitAccess = false; // 8-bit integer variables supported in StorageBuffer + public VkBool32 uniformAndStorageBuffer8BitAccess = false; // 8-bit integer variables supported in StorageBuffer and Uniform + public VkBool32 storagePushConstant8 = false; // 8-bit integer variables supported in PushConstant + public VkBool32 shaderBufferInt64Atomics = false; + public VkBool32 shaderSharedInt64Atomics = false; + public VkBool32 shaderFloat16 = false; // 16-bit floats (halfs) in shaders + public VkBool32 shaderInt8 = false; // 8-bit integers in shaders + public VkBool32 descriptorIndexing = false; + public VkBool32 shaderInputAttachmentArrayDynamicIndexing = false; + public VkBool32 shaderUniformTexelBufferArrayDynamicIndexing = false; + public VkBool32 shaderStorageTexelBufferArrayDynamicIndexing = false; + public VkBool32 shaderUniformBufferArrayNonUniformIndexing = false; + public VkBool32 shaderSampledImageArrayNonUniformIndexing = false; + public VkBool32 shaderStorageBufferArrayNonUniformIndexing = false; + public VkBool32 shaderStorageImageArrayNonUniformIndexing = false; + public VkBool32 shaderInputAttachmentArrayNonUniformIndexing = false; + public VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing = false; + public VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing = false; + public VkBool32 descriptorBindingUniformBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingSampledImageUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageImageUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingUpdateUnusedWhilePending = false; + public VkBool32 descriptorBindingPartiallyBound = false; + public VkBool32 descriptorBindingVariableDescriptorCount = false; + public VkBool32 runtimeDescriptorArray = false; + public VkBool32 samplerFilterMinmax = false; + public VkBool32 scalarBlockLayout = false; + public VkBool32 imagelessFramebuffer = false; + public VkBool32 uniformBufferStandardLayout = false; + public VkBool32 shaderSubgroupExtendedTypes = false; + public VkBool32 separateDepthStencilLayouts = false; + public VkBool32 hostQueryReset = false; + public VkBool32 timelineSemaphore = false; + public VkBool32 bufferDeviceAddress = false; + public VkBool32 bufferDeviceAddressCaptureReplay = false; + public VkBool32 bufferDeviceAddressMultiDevice = false; + public VkBool32 vulkanMemoryModel = false; + public VkBool32 vulkanMemoryModelDeviceScope = false; + public VkBool32 vulkanMemoryModelAvailabilityVisibilityChains = false; + public VkBool32 shaderOutputViewportIndex = false; + public VkBool32 shaderOutputLayer = false; + public VkBool32 subgroupBroadcastDynamicId = false; + + public this(void* pNext, VkBool32 samplerMirrorClampToEdge, VkBool32 drawIndirectCount, VkBool32 storageBuffer8BitAccess, VkBool32 uniformAndStorageBuffer8BitAccess, VkBool32 storagePushConstant8, VkBool32 shaderBufferInt64Atomics, VkBool32 shaderSharedInt64Atomics, VkBool32 shaderFloat16, VkBool32 shaderInt8, VkBool32 descriptorIndexing, VkBool32 shaderInputAttachmentArrayDynamicIndexing, VkBool32 shaderUniformTexelBufferArrayDynamicIndexing, VkBool32 shaderStorageTexelBufferArrayDynamicIndexing, VkBool32 shaderUniformBufferArrayNonUniformIndexing, VkBool32 shaderSampledImageArrayNonUniformIndexing, VkBool32 shaderStorageBufferArrayNonUniformIndexing, VkBool32 shaderStorageImageArrayNonUniformIndexing, VkBool32 shaderInputAttachmentArrayNonUniformIndexing, VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing, VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing, VkBool32 descriptorBindingUniformBufferUpdateAfterBind, VkBool32 descriptorBindingSampledImageUpdateAfterBind, VkBool32 descriptorBindingStorageImageUpdateAfterBind, VkBool32 descriptorBindingStorageBufferUpdateAfterBind, VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind, VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind, VkBool32 descriptorBindingUpdateUnusedWhilePending, VkBool32 descriptorBindingPartiallyBound, VkBool32 descriptorBindingVariableDescriptorCount, VkBool32 runtimeDescriptorArray, VkBool32 samplerFilterMinmax, VkBool32 scalarBlockLayout, VkBool32 imagelessFramebuffer, VkBool32 uniformBufferStandardLayout, VkBool32 shaderSubgroupExtendedTypes, VkBool32 separateDepthStencilLayouts, VkBool32 hostQueryReset, VkBool32 timelineSemaphore, VkBool32 bufferDeviceAddress, VkBool32 bufferDeviceAddressCaptureReplay, VkBool32 bufferDeviceAddressMultiDevice, VkBool32 vulkanMemoryModel, VkBool32 vulkanMemoryModelDeviceScope, VkBool32 vulkanMemoryModelAvailabilityVisibilityChains, VkBool32 shaderOutputViewportIndex, VkBool32 shaderOutputLayer, VkBool32 subgroupBroadcastDynamicId) : this() + { + this.pNext = pNext; + this.samplerMirrorClampToEdge = samplerMirrorClampToEdge; + this.drawIndirectCount = drawIndirectCount; + this.storageBuffer8BitAccess = storageBuffer8BitAccess; + this.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess; + this.storagePushConstant8 = storagePushConstant8; + this.shaderBufferInt64Atomics = shaderBufferInt64Atomics; + this.shaderSharedInt64Atomics = shaderSharedInt64Atomics; + this.shaderFloat16 = shaderFloat16; + this.shaderInt8 = shaderInt8; + this.descriptorIndexing = descriptorIndexing; + this.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing; + this.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing; + this.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing; + this.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing; + this.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing; + this.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing; + this.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing; + this.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing; + this.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing; + this.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing; + this.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind; + this.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind; + this.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind; + this.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind; + this.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind; + this.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind; + this.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending; + this.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound; + this.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount; + this.runtimeDescriptorArray = runtimeDescriptorArray; + this.samplerFilterMinmax = samplerFilterMinmax; + this.scalarBlockLayout = scalarBlockLayout; + this.imagelessFramebuffer = imagelessFramebuffer; + this.uniformBufferStandardLayout = uniformBufferStandardLayout; + this.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes; + this.separateDepthStencilLayouts = separateDepthStencilLayouts; + this.hostQueryReset = hostQueryReset; + this.timelineSemaphore = timelineSemaphore; + this.bufferDeviceAddress = bufferDeviceAddress; + this.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay; + this.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice; + this.vulkanMemoryModel = vulkanMemoryModel; + this.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope; + this.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains; + this.shaderOutputViewportIndex = shaderOutputViewportIndex; + this.shaderOutputLayer = shaderOutputLayer; + this.subgroupBroadcastDynamicId = subgroupBroadcastDynamicId; + } +} + +[CRepr] struct VkPhysicalDeviceVulkan12Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDriverId driverID = default; + public char8[VK_MAX_DRIVER_NAME_SIZE] driverName = .(); + public char8[VK_MAX_DRIVER_INFO_SIZE] driverInfo = .(); + public VkConformanceVersion conformanceVersion = default; + public VkShaderFloatControlsIndependence denormBehaviorIndependence = default; + public VkShaderFloatControlsIndependence roundingModeIndependence = default; + public VkBool32 shaderSignedZeroInfNanPreserveFloat16 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderSignedZeroInfNanPreserveFloat32 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderSignedZeroInfNanPreserveFloat64 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderDenormPreserveFloat16 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormPreserveFloat32 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormPreserveFloat64 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormFlushToZeroFloat16 = false; // An implementation can flush to zero denormals + public VkBool32 shaderDenormFlushToZeroFloat32 = false; // An implementation can flush to zero denormals + public VkBool32 shaderDenormFlushToZeroFloat64 = false; // An implementation can flush to zero denormals + public VkBool32 shaderRoundingModeRTEFloat16 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTEFloat32 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTEFloat64 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTZFloat16 = false; // An implementation can support RTZ + public VkBool32 shaderRoundingModeRTZFloat32 = false; // An implementation can support RTZ + public VkBool32 shaderRoundingModeRTZFloat64 = false; // An implementation can support RTZ + public uint32 maxUpdateAfterBindDescriptorsInAllPools = 0; + public VkBool32 shaderUniformBufferArrayNonUniformIndexingNative = false; + public VkBool32 shaderSampledImageArrayNonUniformIndexingNative = false; + public VkBool32 shaderStorageBufferArrayNonUniformIndexingNative = false; + public VkBool32 shaderStorageImageArrayNonUniformIndexingNative = false; + public VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative = false; + public VkBool32 robustBufferAccessUpdateAfterBind = false; + public VkBool32 quadDivergentImplicitLod = false; + public uint32 maxPerStageDescriptorUpdateAfterBindSamplers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindSampledImages = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindStorageImages = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; + public uint32 maxPerStageUpdateAfterBindResources = 0; + public uint32 maxDescriptorSetUpdateAfterBindSamplers = 0; + public uint32 maxDescriptorSetUpdateAfterBindUniformBuffers = 0; + public uint32 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageBuffers = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindSampledImages = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageImages = 0; + public uint32 maxDescriptorSetUpdateAfterBindInputAttachments = 0; + public VkResolveModeFlags supportedDepthResolveModes = default; // supported depth resolve modes + public VkResolveModeFlags supportedStencilResolveModes = default; // supported stencil resolve modes + public VkBool32 independentResolveNone = false; // depth and stencil resolve modes can be set independently if one of them is none + public VkBool32 independentResolve = false; // depth and stencil resolve modes can be set independently + public VkBool32 filterMinmaxSingleComponentFormats = false; + public VkBool32 filterMinmaxImageComponentMapping = false; + public uint64 maxTimelineSemaphoreValueDifference = 0; + public VkSampleCountFlags framebufferIntegerColorSampleCounts = default; +} + +// Promoted from VK_KHR_image_format_list (extension 148) +[CRepr] struct VkImageFormatListCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 viewFormatCount = 0; + public VkFormat* pViewFormats = null; + public Span viewFormats + { + get { return .(pViewFormats, (.)viewFormatCount); } + set mut { pViewFormats = value.Ptr; viewFormatCount = (.)value.Length; } + } + + public this(void* pNext = null, Span viewFormats = default) : this() + { + this.pNext = pNext; + this.viewFormats = viewFormats; + } +} + +// Promoted from VK_KHR_sampler_mirror_clamp_to_edge (extension 15) +// Promoted from VK_KHR_driver_properties (extension 197) +static { public const uint32 VK_MAX_DRIVER_NAME_SIZE = 256; } +static { public const uint32 VK_MAX_DRIVER_INFO_SIZE = 256; } + +[AllowDuplicates] enum VkDriverId : int32 +{ + [NoShow] VK_DRIVER_ID_AMD_PROPRIETARY = 1, // Advanced Micro Devices, Inc. + [NoShow] VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, // Advanced Micro Devices, Inc. + [NoShow] VK_DRIVER_ID_MESA_RADV = 3, // Mesa open source project + [NoShow] VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, // NVIDIA Corporation + [NoShow] VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, // Intel Corporation + [NoShow] VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, // Intel Corporation + [NoShow] VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, // Imagination Technologies + [NoShow] VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, // Qualcomm Technologies, Inc. + [NoShow] VK_DRIVER_ID_ARM_PROPRIETARY = 9, // Arm Limited + [NoShow] VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, // Google LLC + [NoShow] VK_DRIVER_ID_GGP_PROPRIETARY = 11, // Google LLC + [NoShow] VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, // Broadcom Inc. + [NoShow] VK_DRIVER_ID_MESA_LLVMPIPE = 13, // Mesa + [NoShow] VK_DRIVER_ID_MOLTENVK = 14, // MoltenVK + [NoShow] VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, // Core Avionics & Industrial Inc. + [NoShow] VK_DRIVER_ID_JUICE_PROPRIETARY = 16, // Juice Technologies, Inc. + [NoShow] VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, // Verisilicon, Inc. + [NoShow] VK_DRIVER_ID_MESA_TURNIP = 18, // Mesa open source project + [NoShow] VK_DRIVER_ID_MESA_V3DV = 19, // Mesa open source project + [NoShow] VK_DRIVER_ID_MESA_PANVK = 20, // Mesa open source project + [NoShow] VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, // Samsung Electronics Co., Ltd. + [NoShow] VK_DRIVER_ID_MESA_VENUS = 22, // Mesa open source project + [NoShow] VK_DRIVER_ID_MESA_DOZEN = 23, // Mesa open source project + [NoShow] VK_DRIVER_ID_MESA_NVK = 24, // Mesa open source project + [NoShow] VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, // Imagination Technologies + [NoShow] VK_DRIVER_ID_MESA_HONEYKRISP = 26, // Mesa open source project + [NoShow] VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, // Vulkan SC Emulation on Vulkan + [NoShow] VK_DRIVER_ID_MESA_KOSMICKRISP = 28, // Mesa open source project + [NoShow] VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, + [NoShow] VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, + [NoShow] VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, + [NoShow] VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, + [NoShow] VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, + [NoShow] VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, + [NoShow] VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, + [NoShow] VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, + [NoShow] VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, + [NoShow] VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, + [NoShow] VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, + [NoShow] VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, + // pretty names + AmdProprietary = 1, // Advanced Micro Devices, Inc. + AmdOpenSource = 2, // Advanced Micro Devices, Inc. + MesaRadv = 3, // Mesa open source project + NvidiaProprietary = 4, // NVIDIA Corporation + IntelProprietaryWindows = 5, // Intel Corporation + IntelOpenSourceMESA = 6, // Intel Corporation + ImaginationProprietary = 7, // Imagination Technologies + QualcommProprietary = 8, // Qualcomm Technologies, Inc. + ArmProprietary = 9, // Arm Limited + GoogleSwiftshader = 10, // Google LLC + GgpProprietary = 11, // Google LLC + BroadcomProprietary = 12, // Broadcom Inc. + MesaLlvmpipe = 13, // Mesa + Moltenvk = 14, // MoltenVK + CoreaviProprietary = 15, // Core Avionics & Industrial Inc. + JuiceProprietary = 16, // Juice Technologies, Inc. + VerisiliconProprietary = 17, // Verisilicon, Inc. + MesaTurnip = 18, // Mesa open source project + MesaV3dv = 19, // Mesa open source project + MesaPanvk = 20, // Mesa open source project + SamsungProprietary = 21, // Samsung Electronics Co., Ltd. + MesaVenus = 22, // Mesa open source project + MesaDozen = 23, // Mesa open source project + MesaNvk = 24, // Mesa open source project + ImaginationOpenSourceMESA = 25, // Imagination Technologies + MesaHoneykrisp = 26, // Mesa open source project + VulkanScEmulationOnVulkan = 27, // Vulkan SC Emulation on Vulkan + MesaKosmickrisp = 28, // Mesa open source project + AmdProprietaryKHR = AmdProprietary, + AmdOpenSourceKHR = AmdOpenSource, + MesaRadvKHR = MesaRadv, + NvidiaProprietaryKHR = NvidiaProprietary, + IntelProprietaryWindowsKHR = IntelProprietaryWindows, + IntelOpenSourceMesaKHR = IntelOpenSourceMESA, + ImaginationProprietaryKHR = ImaginationProprietary, + QualcommProprietaryKHR = QualcommProprietary, + ArmProprietaryKHR = ArmProprietary, + GoogleSwiftshaderKHR = GoogleSwiftshader, + GgpProprietaryKHR = GgpProprietary, + BroadcomProprietaryKHR = BroadcomProprietary, +} + +[CRepr] struct VkConformanceVersion : this() +{ + public uint8 major = 0; + public uint8 minor = 0; + public uint8 subminor = 0; + public uint8 patch = 0; + + public this(uint8 major, uint8 minor, uint8 subminor, uint8 patch) : this() + { + this.major = major; + this.minor = minor; + this.subminor = subminor; + this.patch = patch; + } +} + +[CRepr] struct VkPhysicalDeviceDriverProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDriverId driverID = default; + public char8[VK_MAX_DRIVER_NAME_SIZE] driverName = .(); + public char8[VK_MAX_DRIVER_INFO_SIZE] driverInfo = .(); + public VkConformanceVersion conformanceVersion = default; +} + +// Promoted from VK_KHR_vulkan_memory_model (extension 212) +[CRepr] struct VkPhysicalDeviceVulkanMemoryModelFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 vulkanMemoryModel = false; + public VkBool32 vulkanMemoryModelDeviceScope = false; + public VkBool32 vulkanMemoryModelAvailabilityVisibilityChains = false; + + public this(void* pNext, VkBool32 vulkanMemoryModel, VkBool32 vulkanMemoryModelDeviceScope, VkBool32 vulkanMemoryModelAvailabilityVisibilityChains) : this() + { + this.pNext = pNext; + this.vulkanMemoryModel = vulkanMemoryModel; + this.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope; + this.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains; + } +} + +// Promoted from VK_EXT_host_query_reset (extension 262) +[CRepr] struct VkPhysicalDeviceHostQueryResetFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hostQueryReset = false; + + public this(void* pNext, VkBool32 hostQueryReset) : this() + { + this.pNext = pNext; + this.hostQueryReset = hostQueryReset; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount); + +// Promoted from VK_KHR_timeline_semaphore (extension 208) +[AllowDuplicates] enum VkSemaphoreType : int32 +{ + [NoShow] VK_SEMAPHORE_TYPE_BINARY = 0, + [NoShow] VK_SEMAPHORE_TYPE_TIMELINE = 1, + [NoShow] VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, + [NoShow] VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, + // pretty names + Binary = 0, + Timeline = 1, + BinaryKHR = Binary, + TimelineKHR = Timeline, +} + +[CRepr] struct VkPhysicalDeviceTimelineSemaphoreFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 timelineSemaphore = false; + + public this(void* pNext, VkBool32 timelineSemaphore) : this() + { + this.pNext = pNext; + this.timelineSemaphore = timelineSemaphore; + } +} + +[CRepr] struct VkPhysicalDeviceTimelineSemaphoreProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 maxTimelineSemaphoreValueDifference = 0; +} + +[CRepr] struct VkSemaphoreTypeCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphoreType semaphoreType = default; + public uint64 initialValue = 0; + + public this(void* pNext, VkSemaphoreType semaphoreType, uint64 initialValue) : this() + { + this.pNext = pNext; + this.semaphoreType = semaphoreType; + this.initialValue = initialValue; + } +} + +[CRepr] struct VkTimelineSemaphoreSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreValueCount = 0; + public uint64* pWaitSemaphoreValues = null; + public Span waitSemaphoreValues + { + get { return .(pWaitSemaphoreValues, (.)waitSemaphoreValueCount); } + set mut { pWaitSemaphoreValues = value.Ptr; waitSemaphoreValueCount = (.)value.Length; } + } + public uint32 signalSemaphoreValueCount = 0; + public uint64* pSignalSemaphoreValues = null; + public Span signalSemaphoreValues + { + get { return .(pSignalSemaphoreValues, (.)signalSemaphoreValueCount); } + set mut { pSignalSemaphoreValues = value.Ptr; signalSemaphoreValueCount = (.)value.Length; } + } + + public this(void* pNext = null, Span waitSemaphoreValues = default, Span signalSemaphoreValues = default) : this() + { + this.pNext = pNext; + this.waitSemaphoreValues = waitSemaphoreValues; + this.signalSemaphoreValues = signalSemaphoreValues; + } +} + +[AllowDuplicates] enum VkSemaphoreWaitFlagBits : int32 +{ + [NoShow] VK_SEMAPHORE_WAIT_ANY_BIT = 1 << 0, + [NoShow] VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, + // pretty names + Any = 1 << 0, + AnyKHR = Any, +} + +typealias VkSemaphoreWaitFlags = VkSemaphoreWaitFlagBits; + +[CRepr] struct VkSemaphoreWaitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphoreWaitFlags flags = default; + public uint32 semaphoreCount = 0; + public VkSemaphore* pSemaphores = null; + public uint64* pValues = null; + + public this(void* pNext, VkSemaphoreWaitFlags flags, uint32 semaphoreCount, VkSemaphore* pSemaphores, uint64* pValues) : this() + { + this.pNext = pNext; + this.flags = flags; + this.semaphoreCount = semaphoreCount; + this.pSemaphores = pSemaphores; + this.pValues = pValues; + } +} + +[CRepr] struct VkSemaphoreSignalInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public uint64 value = 0; + + public this(void* pNext, VkSemaphore semaphore, uint64 value) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.value = value; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, out uint64 pValue); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWaitSemaphores(VkDevice device, VkSemaphoreWaitInfo* pWaitInfo, uint64 timeout); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSignalSemaphore(VkDevice device, VkSemaphoreSignalInfo* pSignalInfo); + +// Promoted from VK_KHR_buffer_device_address (extension 258) +[CRepr] struct VkPhysicalDeviceBufferDeviceAddressFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 bufferDeviceAddress = false; + public VkBool32 bufferDeviceAddressCaptureReplay = false; + public VkBool32 bufferDeviceAddressMultiDevice = false; + + public this(void* pNext, VkBool32 bufferDeviceAddress, VkBool32 bufferDeviceAddressCaptureReplay, VkBool32 bufferDeviceAddressMultiDevice) : this() + { + this.pNext = pNext; + this.bufferDeviceAddress = bufferDeviceAddress; + this.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay; + this.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice; + } +} + +[CRepr] struct VkBufferDeviceAddressInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + + public this(void* pNext, VkBuffer buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkBufferOpaqueCaptureAddressCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 opaqueCaptureAddress = 0; + + public this(void* pNext, uint64 opaqueCaptureAddress) : this() + { + this.pNext = pNext; + this.opaqueCaptureAddress = opaqueCaptureAddress; + } +} + +[CRepr] struct VkMemoryOpaqueCaptureAddressAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 opaqueCaptureAddress = 0; + + public this(void* pNext, uint64 opaqueCaptureAddress) : this() + { + this.pNext = pNext; + this.opaqueCaptureAddress = opaqueCaptureAddress; + } +} + +[CRepr] struct VkDeviceMemoryOpaqueCaptureAddressInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + + public this(void* pNext, VkDeviceMemory memory) : this() + { + this.pNext = pNext; + this.memory = memory; + } +} + +[CallingConvention(VKAPI_PTR)] function VkDeviceAddress PFN_vkGetBufferDeviceAddress(VkDevice device, VkBufferDeviceAddressInfo* pInfo); +[CallingConvention(VKAPI_PTR)] function uint64 PFN_vkGetBufferOpaqueCaptureAddress(VkDevice device, VkBufferDeviceAddressInfo* pInfo); +[CallingConvention(VKAPI_PTR)] function uint64 PFN_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +// Vulkan compute 1.2 API interface definitions. +// Promoted from VK_KHR_8bit_storage (extension 178) +[CRepr] struct VkPhysicalDevice8BitStorageFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 storageBuffer8BitAccess = false; // 8-bit integer variables supported in StorageBuffer + public VkBool32 uniformAndStorageBuffer8BitAccess = false; // 8-bit integer variables supported in StorageBuffer and Uniform + public VkBool32 storagePushConstant8 = false; // 8-bit integer variables supported in PushConstant + + public this(void* pNext, VkBool32 storageBuffer8BitAccess, VkBool32 uniformAndStorageBuffer8BitAccess, VkBool32 storagePushConstant8) : this() + { + this.pNext = pNext; + this.storageBuffer8BitAccess = storageBuffer8BitAccess; + this.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess; + this.storagePushConstant8 = storagePushConstant8; + } +} + +// Promoted from VK_KHR_shader_atomic_int64 (extension 181) +[CRepr] struct VkPhysicalDeviceShaderAtomicInt64Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderBufferInt64Atomics = false; + public VkBool32 shaderSharedInt64Atomics = false; + + public this(void* pNext, VkBool32 shaderBufferInt64Atomics, VkBool32 shaderSharedInt64Atomics) : this() + { + this.pNext = pNext; + this.shaderBufferInt64Atomics = shaderBufferInt64Atomics; + this.shaderSharedInt64Atomics = shaderSharedInt64Atomics; + } +} + +// Promoted from VK_KHR_shader_float16_int8 (extension 83) +[CRepr] struct VkPhysicalDeviceShaderFloat16Int8Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderFloat16 = false; // 16-bit floats (halfs) in shaders + public VkBool32 shaderInt8 = false; // 8-bit integers in shaders + + public this(void* pNext, VkBool32 shaderFloat16, VkBool32 shaderInt8) : this() + { + this.pNext = pNext; + this.shaderFloat16 = shaderFloat16; + this.shaderInt8 = shaderInt8; + } +} + +// Promoted from VK_KHR_shader_float_controls (extension 198) +[CRepr] struct VkPhysicalDeviceFloatControlsProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderFloatControlsIndependence denormBehaviorIndependence = default; + public VkShaderFloatControlsIndependence roundingModeIndependence = default; + public VkBool32 shaderSignedZeroInfNanPreserveFloat16 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderSignedZeroInfNanPreserveFloat32 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderSignedZeroInfNanPreserveFloat64 = false; // An implementation can preserve signed zero, nan, inf + public VkBool32 shaderDenormPreserveFloat16 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormPreserveFloat32 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormPreserveFloat64 = false; // An implementation can preserve denormals + public VkBool32 shaderDenormFlushToZeroFloat16 = false; // An implementation can flush to zero denormals + public VkBool32 shaderDenormFlushToZeroFloat32 = false; // An implementation can flush to zero denormals + public VkBool32 shaderDenormFlushToZeroFloat64 = false; // An implementation can flush to zero denormals + public VkBool32 shaderRoundingModeRTEFloat16 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTEFloat32 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTEFloat64 = false; // An implementation can support RTE + public VkBool32 shaderRoundingModeRTZFloat16 = false; // An implementation can support RTZ + public VkBool32 shaderRoundingModeRTZFloat32 = false; // An implementation can support RTZ + public VkBool32 shaderRoundingModeRTZFloat64 = false; // An implementation can support RTZ +} + +[AllowDuplicates] enum VkShaderFloatControlsIndependence : int32 +{ + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, + [NoShow] VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, + // pretty names + _32_BitOnly = 0, + All = 1, + None = 2, + _32_BitOnlyKHR = _32_BitOnly, + AllKHR = All, + NoneKHR = None, +} + +// Promoted from VK_EXT_descriptor_indexing (extension 162) +[CRepr] struct VkDescriptorSetLayoutBindingFlagsCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 bindingCount = 0; + public VkDescriptorBindingFlags* pBindingFlags = null; + public Span bindingFlags + { + get { return .(pBindingFlags, (.)bindingCount); } + set mut { pBindingFlags = value.Ptr; bindingCount = (.)value.Length; } + } + + public this(void* pNext = null, Span bindingFlags = default) : this() + { + this.pNext = pNext; + this.bindingFlags = bindingFlags; + } +} + +[CRepr] struct VkPhysicalDeviceDescriptorIndexingFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderInputAttachmentArrayDynamicIndexing = false; + public VkBool32 shaderUniformTexelBufferArrayDynamicIndexing = false; + public VkBool32 shaderStorageTexelBufferArrayDynamicIndexing = false; + public VkBool32 shaderUniformBufferArrayNonUniformIndexing = false; + public VkBool32 shaderSampledImageArrayNonUniformIndexing = false; + public VkBool32 shaderStorageBufferArrayNonUniformIndexing = false; + public VkBool32 shaderStorageImageArrayNonUniformIndexing = false; + public VkBool32 shaderInputAttachmentArrayNonUniformIndexing = false; + public VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing = false; + public VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing = false; + public VkBool32 descriptorBindingUniformBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingSampledImageUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageImageUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind = false; + public VkBool32 descriptorBindingUpdateUnusedWhilePending = false; + public VkBool32 descriptorBindingPartiallyBound = false; + public VkBool32 descriptorBindingVariableDescriptorCount = false; + public VkBool32 runtimeDescriptorArray = false; + + public this(void* pNext, VkBool32 shaderInputAttachmentArrayDynamicIndexing, VkBool32 shaderUniformTexelBufferArrayDynamicIndexing, VkBool32 shaderStorageTexelBufferArrayDynamicIndexing, VkBool32 shaderUniformBufferArrayNonUniformIndexing, VkBool32 shaderSampledImageArrayNonUniformIndexing, VkBool32 shaderStorageBufferArrayNonUniformIndexing, VkBool32 shaderStorageImageArrayNonUniformIndexing, VkBool32 shaderInputAttachmentArrayNonUniformIndexing, VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing, VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing, VkBool32 descriptorBindingUniformBufferUpdateAfterBind, VkBool32 descriptorBindingSampledImageUpdateAfterBind, VkBool32 descriptorBindingStorageImageUpdateAfterBind, VkBool32 descriptorBindingStorageBufferUpdateAfterBind, VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind, VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind, VkBool32 descriptorBindingUpdateUnusedWhilePending, VkBool32 descriptorBindingPartiallyBound, VkBool32 descriptorBindingVariableDescriptorCount, VkBool32 runtimeDescriptorArray) : this() + { + this.pNext = pNext; + this.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing; + this.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing; + this.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing; + this.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing; + this.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing; + this.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing; + this.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing; + this.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing; + this.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing; + this.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing; + this.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind; + this.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind; + this.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind; + this.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind; + this.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind; + this.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind; + this.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending; + this.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound; + this.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount; + this.runtimeDescriptorArray = runtimeDescriptorArray; + } +} + +[CRepr] struct VkPhysicalDeviceDescriptorIndexingProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxUpdateAfterBindDescriptorsInAllPools = 0; + public VkBool32 shaderUniformBufferArrayNonUniformIndexingNative = false; + public VkBool32 shaderSampledImageArrayNonUniformIndexingNative = false; + public VkBool32 shaderStorageBufferArrayNonUniformIndexingNative = false; + public VkBool32 shaderStorageImageArrayNonUniformIndexingNative = false; + public VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative = false; + public VkBool32 robustBufferAccessUpdateAfterBind = false; + public VkBool32 quadDivergentImplicitLod = false; + public uint32 maxPerStageDescriptorUpdateAfterBindSamplers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindSampledImages = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindStorageImages = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; + public uint32 maxPerStageUpdateAfterBindResources = 0; + public uint32 maxDescriptorSetUpdateAfterBindSamplers = 0; + public uint32 maxDescriptorSetUpdateAfterBindUniformBuffers = 0; + public uint32 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageBuffers = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindSampledImages = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageImages = 0; + public uint32 maxDescriptorSetUpdateAfterBindInputAttachments = 0; +} + +[CRepr] struct VkDescriptorSetVariableDescriptorCountAllocateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 descriptorSetCount = 0; + public uint32* pDescriptorCounts = null; + public Span descriptorCounts + { + get { return .(pDescriptorCounts, (.)descriptorSetCount); } + set mut { pDescriptorCounts = value.Ptr; descriptorSetCount = (.)value.Length; } + } + + public this(void* pNext = null, Span descriptorCounts = default) : this() + { + this.pNext = pNext; + this.descriptorCounts = descriptorCounts; + } +} + +[CRepr] struct VkDescriptorSetVariableDescriptorCountLayoutSupport : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxVariableDescriptorCount = 0; +} + +[AllowDuplicates] enum VkDescriptorBindingFlagBits : int32 +{ + [NoShow] VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1 << 0, + [NoShow] VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 1 << 1, + [NoShow] VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 1 << 2, + [NoShow] VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 1 << 3, + [NoShow] VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, + [NoShow] VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, + [NoShow] VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, + [NoShow] VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, + // pretty names + UpdateAfterBind = 1 << 0, + UpdateUnusedWhilePending = 1 << 1, + PartiallyBound = 1 << 2, + VariableDescriptorCount = 1 << 3, + UpdateAfterBindEXT = UpdateAfterBind, + UpdateUnusedWhilePendingEXT = UpdateUnusedWhilePending, + PartiallyBoundEXT = PartiallyBound, + VariableDescriptorCountEXT = VariableDescriptorCount, +} + +typealias VkDescriptorBindingFlags = VkDescriptorBindingFlagBits; + +// Promoted from VK_EXT_scalar_block_layout (extension 222)) +[CRepr] struct VkPhysicalDeviceScalarBlockLayoutFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 scalarBlockLayout = false; + + public this(void* pNext, VkBool32 scalarBlockLayout) : this() + { + this.pNext = pNext; + this.scalarBlockLayout = scalarBlockLayout; + } +} + +// Promoted from VK_EXT_sampler_filter_minmax (extension 131) +[AllowDuplicates] enum VkSamplerReductionMode : int32 +{ + [NoShow] VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + [NoShow] VK_SAMPLER_REDUCTION_MODE_MIN = 1, + [NoShow] VK_SAMPLER_REDUCTION_MODE_MAX = 2, + [NoShow] VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, + [NoShow] VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, + [NoShow] VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, + [NoShow] VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000, + // pretty names + WeightedAverage = 0, + Min = 1, + Max = 2, + WeightedAverageEXT = WeightedAverage, + MinEXT = Min, + MaxEXT = Max, + WeightedAverageRangeclampQCOM = 1000521000, +} + +[CRepr] struct VkSamplerReductionModeCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSamplerReductionMode reductionMode = default; + + public this(void* pNext, VkSamplerReductionMode reductionMode) : this() + { + this.pNext = pNext; + this.reductionMode = reductionMode; + } +} + +[CRepr] struct VkPhysicalDeviceSamplerFilterMinmaxProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 filterMinmaxSingleComponentFormats = false; + public VkBool32 filterMinmaxImageComponentMapping = false; +} + +// Promoted from VK_KHR_uniform_buffer_standard_layout (extension 254) +[CRepr] struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 uniformBufferStandardLayout = false; + + public this(void* pNext, VkBool32 uniformBufferStandardLayout) : this() + { + this.pNext = pNext; + this.uniformBufferStandardLayout = uniformBufferStandardLayout; + } +} + +// Promoted from VK_KHR_shader_subgroup_extended_types (extension 176) +[CRepr] struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderSubgroupExtendedTypes = false; // Flag to specify whether subgroup operations with extended types are supported + + public this(void* pNext, VkBool32 shaderSubgroupExtendedTypes) : this() + { + this.pNext = pNext; + this.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes; + } +} + +// Promoted from VK_KHR_spirv_1_4 (extension 237) +// Vulkan graphics 1.2 API interface definitions. +// Promoted from VK_KHR_draw_indirect_count (extension 170) +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride); + +// Promoted from VK_KHR_create_renderpass2 (extension 110) +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateRenderPass2(VkDevice device, VkRenderPassCreateInfo2* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkRenderPass pRenderPass); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassBeginInfo* pSubpassBeginInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, VkSubpassBeginInfo* pSubpassBeginInfo, VkSubpassEndInfo* pSubpassEndInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, VkSubpassEndInfo* pSubpassEndInfo); + +[CRepr] struct VkRenderPassCreateInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPassCreateFlags flags = default; + public uint32 attachmentCount = 0; + public VkAttachmentDescription2* pAttachments = null; + public Span attachments + { + get { return .(pAttachments, (.)attachmentCount); } + set mut { pAttachments = value.Ptr; attachmentCount = (.)value.Length; } + } + public uint32 subpassCount = 0; + public VkSubpassDescription2* pSubpasses = null; + public Span subpasses + { + get { return .(pSubpasses, (.)subpassCount); } + set mut { pSubpasses = value.Ptr; subpassCount = (.)value.Length; } + } + public uint32 dependencyCount = 0; + public VkSubpassDependency2* pDependencies = null; + public Span dependencies + { + get { return .(pDependencies, (.)dependencyCount); } + set mut { pDependencies = value.Ptr; dependencyCount = (.)value.Length; } + } + public uint32 correlatedViewMaskCount = 0; + public uint32* pCorrelatedViewMasks = null; + public Span correlatedViewMasks + { + get { return .(pCorrelatedViewMasks, (.)correlatedViewMaskCount); } + set mut { pCorrelatedViewMasks = value.Ptr; correlatedViewMaskCount = (.)value.Length; } + } + + public this(void* pNext, VkRenderPassCreateFlags flags, Span attachments, Span subpasses, Span dependencies = default, Span correlatedViewMasks = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.attachments = attachments; + this.subpasses = subpasses; + this.dependencies = dependencies; + this.correlatedViewMasks = correlatedViewMasks; + } +} + +[CRepr] struct VkAttachmentDescription2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAttachmentDescriptionFlags flags = default; + public VkFormat format = default; + public VkSampleCountFlagBits samples = default; + public VkAttachmentLoadOp loadOp = default; // Load operation for color or depth data + public VkAttachmentStoreOp storeOp = default; // Store operation for color or depth data + public VkAttachmentLoadOp stencilLoadOp = default; // Load operation for stencil data + public VkAttachmentStoreOp stencilStoreOp = default; // Store operation for stencil data + public VkImageLayout initialLayout = default; + public VkImageLayout finalLayout = default; + + public this(void* pNext, VkAttachmentDescriptionFlags flags, VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp, VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp, VkImageLayout initialLayout, VkImageLayout finalLayout) : this() + { + this.pNext = pNext; + this.flags = flags; + this.format = format; + this.samples = samples; + this.loadOp = loadOp; + this.storeOp = storeOp; + this.stencilLoadOp = stencilLoadOp; + this.stencilStoreOp = stencilStoreOp; + this.initialLayout = initialLayout; + this.finalLayout = finalLayout; + } +} + +[CRepr] struct VkAttachmentReference2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 attachment = 0; + public VkImageLayout layout = default; + public VkImageAspectFlags aspectMask = default; + + public this(void* pNext, uint32 attachment, VkImageLayout layout, VkImageAspectFlags aspectMask) : this() + { + this.pNext = pNext; + this.attachment = attachment; + this.layout = layout; + this.aspectMask = aspectMask; + } +} + +[CRepr] struct VkSubpassDescription2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSubpassDescriptionFlags flags = default; + public VkPipelineBindPoint pipelineBindPoint = default; + public uint32 viewMask = 0; + public uint32 inputAttachmentCount = 0; + public VkAttachmentReference2* pInputAttachments = null; + public Span inputAttachments + { + get { return .(pInputAttachments, (.)inputAttachmentCount); } + set mut { pInputAttachments = value.Ptr; inputAttachmentCount = (.)value.Length; } + } + public uint32 colorAttachmentCount = 0; + public VkAttachmentReference2* pColorAttachments = null; + public VkAttachmentReference2* pResolveAttachments = null; + public VkAttachmentReference2* pDepthStencilAttachment = null; + public uint32 preserveAttachmentCount = 0; + public uint32* pPreserveAttachments = null; + public Span preserveAttachments + { + get { return .(pPreserveAttachments, (.)preserveAttachmentCount); } + set mut { pPreserveAttachments = value.Ptr; preserveAttachmentCount = (.)value.Length; } + } + + public this(void* pNext, VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint, uint32 viewMask, Span inputAttachments, uint32 colorAttachmentCount, VkAttachmentReference2* pColorAttachments, VkAttachmentReference2* pResolveAttachments = null, VkAttachmentReference2* pDepthStencilAttachment = null, Span preserveAttachments = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pipelineBindPoint = pipelineBindPoint; + this.viewMask = viewMask; + this.inputAttachments = inputAttachments; + this.colorAttachmentCount = colorAttachmentCount; + this.pColorAttachments = pColorAttachments; + this.pResolveAttachments = pResolveAttachments; + this.pDepthStencilAttachment = pDepthStencilAttachment; + this.preserveAttachments = preserveAttachments; + } +} + +[CRepr] struct VkSubpassDependency2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 srcSubpass = 0; + public uint32 dstSubpass = 0; + public VkPipelineStageFlags srcStageMask = default; + public VkPipelineStageFlags dstStageMask = default; + public VkAccessFlags srcAccessMask = default; + public VkAccessFlags dstAccessMask = default; + public VkDependencyFlags dependencyFlags = default; + public int32 viewOffset = 0; + + public this(void* pNext, uint32 srcSubpass, uint32 dstSubpass, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkDependencyFlags dependencyFlags, int32 viewOffset) : this() + { + this.pNext = pNext; + this.srcSubpass = srcSubpass; + this.dstSubpass = dstSubpass; + this.srcStageMask = srcStageMask; + this.dstStageMask = dstStageMask; + this.srcAccessMask = srcAccessMask; + this.dstAccessMask = dstAccessMask; + this.dependencyFlags = dependencyFlags; + this.viewOffset = viewOffset; + } +} + +[CRepr] struct VkSubpassBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSubpassContents contents = default; + + public this(void* pNext, VkSubpassContents contents) : this() + { + this.pNext = pNext; + this.contents = contents; + } +} + +[CRepr] struct VkSubpassEndInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_END_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +// Promoted from VK_KHR_depth_stencil_resolve (extension 200) +[CRepr] struct VkSubpassDescriptionDepthStencilResolve : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkResolveModeFlagBits depthResolveMode = default; // depth resolve mode + public VkResolveModeFlagBits stencilResolveMode = default; // stencil resolve mode + public VkAttachmentReference2* pDepthStencilResolveAttachment = null; // depth/stencil resolve attachment + + public this(void* pNext, VkResolveModeFlagBits depthResolveMode, VkResolveModeFlagBits stencilResolveMode, VkAttachmentReference2* pDepthStencilResolveAttachment = null) : this() + { + this.pNext = pNext; + this.depthResolveMode = depthResolveMode; + this.stencilResolveMode = stencilResolveMode; + this.pDepthStencilResolveAttachment = pDepthStencilResolveAttachment; + } +} + +[CRepr] struct VkPhysicalDeviceDepthStencilResolveProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkResolveModeFlags supportedDepthResolveModes = default; // supported depth resolve modes + public VkResolveModeFlags supportedStencilResolveModes = default; // supported stencil resolve modes + public VkBool32 independentResolveNone = false; // depth and stencil resolve modes can be set independently if one of them is none + public VkBool32 independentResolve = false; // depth and stencil resolve modes can be set independently +} + +[AllowDuplicates] enum VkResolveModeFlagBits : int32 +{ + [NoShow] VK_RESOLVE_MODE_NONE = 0, + [NoShow] VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1 << 0, + [NoShow] VK_RESOLVE_MODE_AVERAGE_BIT = 1 << 1, + [NoShow] VK_RESOLVE_MODE_MIN_BIT = 1 << 2, + [NoShow] VK_RESOLVE_MODE_MAX_BIT = 1 << 3, + [NoShow] VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, + [NoShow] VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + [NoShow] VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, + [NoShow] VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, + [NoShow] VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, + [NoShow] VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID = 1 << 4, + [NoShow] VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, + [NoShow] VK_RESOLVE_MODE_CUSTOM_BIT_EXT = 1 << 5, + // pretty names + None = 0, + SampleZero = 1 << 0, + Average = 1 << 1, + Min = 1 << 2, + Max = 1 << 3, + NoneKHR = None, + SampleZeroKHR = SampleZero, + AverageKHR = Average, + MinKHR = Min, + MaxKHR = Max, + ExternalFormatDownsampleANDROID = 1 << 4, + CustomEXT = 1 << 5, +} + +typealias VkResolveModeFlags = VkResolveModeFlagBits; + +// Promoted from VK_EXT_separate_stencil_usage (extension 247) +[CRepr] struct VkImageStencilUsageCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageUsageFlags stencilUsage = default; + + public this(void* pNext, VkImageUsageFlags stencilUsage) : this() + { + this.pNext = pNext; + this.stencilUsage = stencilUsage; + } +} + +// Promoted from VK_KHR_imageless_framebuffer (extension 109) +[CRepr] struct VkPhysicalDeviceImagelessFramebufferFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imagelessFramebuffer = false; + + public this(void* pNext, VkBool32 imagelessFramebuffer) : this() + { + this.pNext = pNext; + this.imagelessFramebuffer = imagelessFramebuffer; + } +} + +[CRepr] struct VkFramebufferAttachmentsCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 attachmentImageInfoCount = 0; + public VkFramebufferAttachmentImageInfo* pAttachmentImageInfos = null; + public Span attachmentImageInfos + { + get { return .(pAttachmentImageInfos, (.)attachmentImageInfoCount); } + set mut { pAttachmentImageInfos = value.Ptr; attachmentImageInfoCount = (.)value.Length; } + } + + public this(void* pNext = null, Span attachmentImageInfos = default) : this() + { + this.pNext = pNext; + this.attachmentImageInfos = attachmentImageInfos; + } +} + +[CRepr] struct VkFramebufferAttachmentImageInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCreateFlags flags = default; // Image creation flags + public VkImageUsageFlags usage = default; // Image usage flags + public uint32 width = 0; + public uint32 height = 0; + public uint32 layerCount = 0; + public uint32 viewFormatCount = 0; + public VkFormat* pViewFormats = null; + public Span viewFormats + { + get { return .(pViewFormats, (.)viewFormatCount); } + set mut { pViewFormats = value.Ptr; viewFormatCount = (.)value.Length; } + } + + public this(void* pNext, VkImageCreateFlags flags, VkImageUsageFlags usage, uint32 width, uint32 height, uint32 layerCount, Span viewFormats = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.usage = usage; + this.width = width; + this.height = height; + this.layerCount = layerCount; + this.viewFormats = viewFormats; + } +} + +[CRepr] struct VkRenderPassAttachmentBeginInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 attachmentCount = 0; + public VkImageView* pAttachments = null; + public Span attachments + { + get { return .(pAttachments, (.)attachmentCount); } + set mut { pAttachments = value.Ptr; attachmentCount = (.)value.Length; } + } + + public this(void* pNext = null, Span attachments = default) : this() + { + this.pNext = pNext; + this.attachments = attachments; + } +} + +// Promoted from VK_KHR_separate_depth_stencil_layouts (extension 242) +[CRepr] struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 separateDepthStencilLayouts = false; + + public this(void* pNext, VkBool32 separateDepthStencilLayouts) : this() + { + this.pNext = pNext; + this.separateDepthStencilLayouts = separateDepthStencilLayouts; + } +} + +[CRepr] struct VkAttachmentReferenceStencilLayout : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageLayout stencilLayout = default; + + public this(void* pNext, VkImageLayout stencilLayout) : this() + { + this.pNext = pNext; + this.stencilLayout = stencilLayout; + } +} + +[CRepr] struct VkAttachmentDescriptionStencilLayout : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageLayout stencilInitialLayout = default; + public VkImageLayout stencilFinalLayout = default; + + public this(void* pNext, VkImageLayout stencilInitialLayout, VkImageLayout stencilFinalLayout) : this() + { + this.pNext = pNext; + this.stencilInitialLayout = stencilInitialLayout; + this.stencilFinalLayout = stencilFinalLayout; + } +} + +// Vulkan 1.2 core API interface definitions +// Feature requirements +// Vulkan base 1.3 API interface definitions. +// API version macros +// Vulkan 1.3 version number +static { public const let VK_API_VERSION_1_3 = VK_MAKE_API_VERSION(0, 1, 3, 0); }// Patch version should always be set to 0 +typealias VkFlags64 = uint64; + +[CRepr] struct VkPhysicalDeviceVulkan13Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 robustImageAccess = false; + public VkBool32 inlineUniformBlock = false; + public VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind = false; + public VkBool32 pipelineCreationCacheControl = false; + public VkBool32 privateData = false; + public VkBool32 shaderDemoteToHelperInvocation = false; + public VkBool32 shaderTerminateInvocation = false; + public VkBool32 subgroupSizeControl = false; + public VkBool32 computeFullSubgroups = false; + public VkBool32 synchronization2 = false; + public VkBool32 textureCompressionASTC_HDR = false; + public VkBool32 shaderZeroInitializeWorkgroupMemory = false; + public VkBool32 dynamicRendering = false; + public VkBool32 shaderIntegerDotProduct = false; + public VkBool32 maintenance4 = false; + + public this(void* pNext, VkBool32 robustImageAccess, VkBool32 inlineUniformBlock, VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind, VkBool32 pipelineCreationCacheControl, VkBool32 privateData, VkBool32 shaderDemoteToHelperInvocation, VkBool32 shaderTerminateInvocation, VkBool32 subgroupSizeControl, VkBool32 computeFullSubgroups, VkBool32 synchronization2, VkBool32 textureCompressionASTC_HDR, VkBool32 shaderZeroInitializeWorkgroupMemory, VkBool32 dynamicRendering, VkBool32 shaderIntegerDotProduct, VkBool32 maintenance4) : this() + { + this.pNext = pNext; + this.robustImageAccess = robustImageAccess; + this.inlineUniformBlock = inlineUniformBlock; + this.descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind; + this.pipelineCreationCacheControl = pipelineCreationCacheControl; + this.privateData = privateData; + this.shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation; + this.shaderTerminateInvocation = shaderTerminateInvocation; + this.subgroupSizeControl = subgroupSizeControl; + this.computeFullSubgroups = computeFullSubgroups; + this.synchronization2 = synchronization2; + this.textureCompressionASTC_HDR = textureCompressionASTC_HDR; + this.shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory; + this.dynamicRendering = dynamicRendering; + this.shaderIntegerDotProduct = shaderIntegerDotProduct; + this.maintenance4 = maintenance4; + } +} + +[CRepr] struct VkPhysicalDeviceVulkan13Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 minSubgroupSize = 0; // The minimum subgroup size supported by this device + public uint32 maxSubgroupSize = 0; // The maximum subgroup size supported by this device + public uint32 maxComputeWorkgroupSubgroups = 0; // The maximum number of subgroups supported in a workgroup + public VkShaderStageFlags requiredSubgroupSizeStages = default; // The shader stages that support specifying a subgroup size + public uint32 maxInlineUniformBlockSize = 0; + public uint32 maxPerStageDescriptorInlineUniformBlocks = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 0; + public uint32 maxDescriptorSetInlineUniformBlocks = 0; + public uint32 maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 0; + public uint32 maxInlineUniformTotalSize = 0; + public VkBool32 integerDotProduct8BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct8BitSignedAccelerated = false; + public VkBool32 integerDotProduct8BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedSignedAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct16BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct16BitSignedAccelerated = false; + public VkBool32 integerDotProduct16BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct32BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct32BitSignedAccelerated = false; + public VkBool32 integerDotProduct32BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct64BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct64BitSignedAccelerated = false; + public VkBool32 integerDotProduct64BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = false; + public VkDeviceSize storageTexelBufferOffsetAlignmentBytes = default; + public VkBool32 storageTexelBufferOffsetSingleTexelAlignment = false; + public VkDeviceSize uniformTexelBufferOffsetAlignmentBytes = default; + public VkBool32 uniformTexelBufferOffsetSingleTexelAlignment = false; + public VkDeviceSize maxBufferSize = default; +} + +// Promoted from VK_EXT_tooling_info (extension 246) +[AllowDuplicates] enum VkToolPurposeFlagBits : int32 +{ + [NoShow] VK_TOOL_PURPOSE_VALIDATION_BIT = 1 << 0, + [NoShow] VK_TOOL_PURPOSE_PROFILING_BIT = 1 << 1, + [NoShow] VK_TOOL_PURPOSE_TRACING_BIT = 1 << 2, + [NoShow] VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 1 << 3, + [NoShow] VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 1 << 4, + [NoShow] VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, + [NoShow] VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, + [NoShow] VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, + [NoShow] VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, + [NoShow] VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, + [NoShow] VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 1 << 5, + [NoShow] VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 1 << 6, + // pretty names + Validation = 1 << 0, + Profiling = 1 << 1, + Tracing = 1 << 2, + AdditionalFeatures = 1 << 3, + ModifyingFeatures = 1 << 4, + ValidationEXT = Validation, + ProfilingEXT = Profiling, + TracingEXT = Tracing, + AdditionalFeaturesEXT = AdditionalFeatures, + ModifyingFeaturesEXT = ModifyingFeatures, + DebugReportingEXT = 1 << 5, + DebugMarkersEXT = 1 << 6, +} + +typealias VkToolPurposeFlags = VkToolPurposeFlagBits; + +[CRepr] struct VkPhysicalDeviceToolProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public char8[VK_MAX_EXTENSION_NAME_SIZE] name = .(); + public char8[VK_MAX_EXTENSION_NAME_SIZE] version = .(); + public VkToolPurposeFlags purposes = default; + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); + public char8[VK_MAX_EXTENSION_NAME_SIZE] layer = .(); +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, out uint32 pToolCount, VkPhysicalDeviceToolProperties* pToolProperties = null); + +// Promoted from VK_EXT_private_data (extension 296) +[CRepr] struct VkPhysicalDevicePrivateDataFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 privateData = false; + + public this(void* pNext, VkBool32 privateData) : this() + { + this.pNext = pNext; + this.privateData = privateData; + } +} + +[CRepr] struct VkDevicePrivateDataCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 privateDataSlotRequestCount = 0; + + public this(void* pNext, uint32 privateDataSlotRequestCount) : this() + { + this.pNext = pNext; + this.privateDataSlotRequestCount = privateDataSlotRequestCount; + } +} + +[CRepr] struct VkPrivateDataSlotCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPrivateDataSlotCreateFlags flags = default; + + public this(void* pNext, VkPrivateDataSlotCreateFlags flags) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +struct VkPrivateDataSlot : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PRIVATE_DATA_SLOT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkPrivateDataSlotCreateFlags = VkFlags; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreatePrivateDataSlot(VkDevice device, VkPrivateDataSlotCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPrivateDataSlot pPrivateDataSlot); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, uint64 data); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64 objectHandle, VkPrivateDataSlot privateDataSlot, out uint64 pData); + +// Promoted from VK_KHR_synchronization2 (extension 315) +typealias VkPipelineStageFlags2 = VkFlags64; + +[AllowDuplicates] enum VkPipelineStageFlagBits2 : int32 +{ + [NoShow] VK_PIPELINE_STAGE_2_NONE = 0, + [NoShow] VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 1 << 0, + [NoShow] VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 1 << 1, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 1 << 2, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 1 << 3, + [NoShow] VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 1 << 4, + [NoShow] VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 1 << 5, + [NoShow] VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 1 << 6, + [NoShow] VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 1 << 7, + [NoShow] VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 1 << 8, + [NoShow] VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 1 << 9, + [NoShow] VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 1 << 10, + [NoShow] VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 1 << 11, + [NoShow] VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 1 << 12, + [NoShow] VK_PIPELINE_STAGE_2_TRANSFER_BIT = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 1 << 13, + [NoShow] VK_PIPELINE_STAGE_2_HOST_BIT = 1 << 14, + [NoShow] VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 1 << 15, + [NoShow] VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 1 << 16, + [NoShow] VK_PIPELINE_STAGE_2_COPY_BIT = 1 << 32, + [NoShow] VK_PIPELINE_STAGE_2_RESOLVE_BIT = 1 << 33, + [NoShow] VK_PIPELINE_STAGE_2_BLIT_BIT = 1 << 34, + [NoShow] VK_PIPELINE_STAGE_2_CLEAR_BIT = 1 << 35, + [NoShow] VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 1 << 36, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 1 << 37, + [NoShow] VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 1 << 38, + [NoShow] VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 1 << 26, + [NoShow] VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 1 << 27, + [NoShow] VK_PIPELINE_STAGE_2_NONE_KHR = VK_PIPELINE_STAGE_2_NONE, + [NoShow] VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, + [NoShow] VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT, + [NoShow] VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT, + [NoShow] VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, + [NoShow] VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, + [NoShow] VK_PIPELINE_STAGE_2_HOST_BIT_KHR = VK_PIPELINE_STAGE_2_HOST_BIT, + [NoShow] VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, + [NoShow] VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + [NoShow] VK_PIPELINE_STAGE_2_COPY_BIT_KHR = VK_PIPELINE_STAGE_2_COPY_BIT, + [NoShow] VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = VK_PIPELINE_STAGE_2_RESOLVE_BIT, + [NoShow] VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = VK_PIPELINE_STAGE_2_BLIT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = VK_PIPELINE_STAGE_2_CLEAR_BIT, + [NoShow] VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT, + [NoShow] VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT, + [NoShow] VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 1 << 24, + [NoShow] VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 1 << 18, // A pipeline stage for conditional rendering predicate fetch + [NoShow] VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 1 << 17, + [NoShow] VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 22, + [NoShow] VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 1 << 25, + [NoShow] VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 1 << 21, + [NoShow] VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + [NoShow] VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 1 << 23, + [NoShow] VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT, + [NoShow] VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 1 << 19, + [NoShow] VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 1 << 20, + [NoShow] VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 1 << 39, + [NoShow] VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI, + [NoShow] VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 1 << 40, + [NoShow] VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 1 << 28, + [NoShow] VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 1 << 30, + [NoShow] VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 1 << 41, + [NoShow] VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 1 << 29, + [NoShow] VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 1 << 44, + [NoShow] VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 1 << 42, + [NoShow] VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 1 << 46, + [NoShow] VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 1 << 45, + // pretty names + VkPipelineStage2_None = 0, + VkPipelineStage2_TopOfPipe = 1 << 0, + VkPipelineStage2_DrawIndirect = 1 << 1, + VkPipelineStage2_VertexInput = 1 << 2, + VkPipelineStage2_VertexShader = 1 << 3, + VkPipelineStage2_TessellationControlShader = 1 << 4, + VkPipelineStage2_TessellationEvaluationShader = 1 << 5, + VkPipelineStage2_GeometryShader = 1 << 6, + VkPipelineStage2_FragmentShader = 1 << 7, + VkPipelineStage2_EarlyFragmentTests = 1 << 8, + VkPipelineStage2_LateFragmentTests = 1 << 9, + VkPipelineStage2_ColorAttachmentOutput = 1 << 10, + VkPipelineStage2_ComputeShader = 1 << 11, + VkPipelineStage2_AllTransfer = 1 << 12, + VkPipelineStage2_Transfer = VkPipelineStage2_AllTransfer, + VkPipelineStage2_BottomOfPipe = 1 << 13, + VkPipelineStage2_Host = 1 << 14, + VkPipelineStage2_AllGraphics = 1 << 15, + VkPipelineStage2_AllCommands = 1 << 16, + VkPipelineStage2_Copy = 1 << 32, + VkPipelineStage2_Resolve = 1 << 33, + VkPipelineStage2_Blit = 1 << 34, + VkPipelineStage2_Clear = 1 << 35, + VkPipelineStage2_IndexInput = 1 << 36, + VkPipelineStage2_VertexAttributeInput = 1 << 37, + VkPipelineStage2_PreRasterizationShaders = 1 << 38, + VkPipelineStage2_VideoDecodeKHR = 1 << 26, + VkPipelineStage2_VideoEncodeKHR = 1 << 27, + VkPipelineStage2_NoneKHR = VkPipelineStage2_None, + VkPipelineStage2_TopOfPipeKHR = VkPipelineStage2_TopOfPipe, + VkPipelineStage2_DrawIndirectKHR = VkPipelineStage2_DrawIndirect, + VkPipelineStage2_VertexInputKHR = VkPipelineStage2_VertexInput, + VkPipelineStage2_VertexShaderKHR = VkPipelineStage2_VertexShader, + VkPipelineStage2_TessellationControlShaderKHR = VkPipelineStage2_TessellationControlShader, + VkPipelineStage2_TessellationEvaluationShaderKHR = VkPipelineStage2_TessellationEvaluationShader, + VkPipelineStage2_GeometryShaderKHR = VkPipelineStage2_GeometryShader, + VkPipelineStage2_FragmentShaderKHR = VkPipelineStage2_FragmentShader, + VkPipelineStage2_EarlyFragmentTestsKHR = VkPipelineStage2_EarlyFragmentTests, + VkPipelineStage2_LateFragmentTestsKHR = VkPipelineStage2_LateFragmentTests, + VkPipelineStage2_ColorAttachmentOutputKHR = VkPipelineStage2_ColorAttachmentOutput, + VkPipelineStage2_ComputeShaderKHR = VkPipelineStage2_ComputeShader, + VkPipelineStage2_AllTransferKHR = VkPipelineStage2_AllTransfer, + VkPipelineStage2_TransferKHR = VkPipelineStage2_AllTransfer, + VkPipelineStage2_BottomOfPipeKHR = VkPipelineStage2_BottomOfPipe, + VkPipelineStage2_HostKHR = VkPipelineStage2_Host, + VkPipelineStage2_AllGraphicsKHR = VkPipelineStage2_AllGraphics, + VkPipelineStage2_AllCommandsKHR = VkPipelineStage2_AllCommands, + VkPipelineStage2_CopyKHR = VkPipelineStage2_Copy, + VkPipelineStage2_ResolveKHR = VkPipelineStage2_Resolve, + VkPipelineStage2_BlitKHR = VkPipelineStage2_Blit, + VkPipelineStage2_ClearKHR = VkPipelineStage2_Clear, + VkPipelineStage2_IndexInputKHR = VkPipelineStage2_IndexInput, + VkPipelineStage2_VertexAttributeInputKHR = VkPipelineStage2_VertexAttributeInput, + VkPipelineStage2_PreRasterizationShadersKHR = VkPipelineStage2_PreRasterizationShaders, + VkPipelineStage2_TransformFeedbackEXT = 1 << 24, + VkPipelineStage2_ConditionalRenderingEXT = 1 << 18, // A pipeline stage for conditional rendering predicate fetch + VkPipelineStage2_CommandPreprocessNV = VkPipelineStage2_CommandPreprocessEXT, + VkPipelineStage2_CommandPreprocessEXT = 1 << 17, + VkPipelineStage2_FragmentShadingRateAttachmentKHR = 1 << 22, + VkPipelineStage2_ShadingRateImageNV = VkPipelineStage2_FragmentShadingRateAttachmentKHR, + VkPipelineStage2_AccelerationStructureBuildKHR = 1 << 25, + VkPipelineStage2_RayTracingShaderKHR = 1 << 21, + VkPipelineStage2_RayTracingShaderNV = VkPipelineStage2_RayTracingShaderKHR, + VkPipelineStage2_AccelerationStructureBuildNV = VkPipelineStage2_AccelerationStructureBuildKHR, + VkPipelineStage2_FragmentDensityProcessEXT = 1 << 23, + VkPipelineStage2_TaskShaderNV = VkPipelineStage2_TaskShaderEXT, + VkPipelineStage2_MeshShaderNV = VkPipelineStage2_MeshShaderEXT, + VkPipelineStage2_TaskShaderEXT = 1 << 19, + VkPipelineStage2_MeshShaderEXT = 1 << 20, + VkPipelineStage2_SubpassShaderHUAWEI = 1 << 39, + VkPipelineStage2_SubpassShadingHUAWEI = VkPipelineStage2_SubpassShaderHUAWEI, + VkPipelineStage2_InvocationMaskHUAWEI = 1 << 40, + VkPipelineStage2_AccelerationStructureCopyKHR = 1 << 28, + VkPipelineStage2_MicromapBuildEXT = 1 << 30, + VkPipelineStage2_ClusterCullingShaderHUAWEI = 1 << 41, + VkPipelineStage2_OpticalFlowNV = 1 << 29, + VkPipelineStage2_ConvertCooperativeVectorMatrixNV = 1 << 44, + VkPipelineStage2_DataGraphARM = 1 << 42, + VkPipelineStage2_CopyIndirectKHR = 1 << 46, + VkPipelineStage2_MemoryDecompressionEXT = 1 << 45, +} + +typealias VkAccessFlags2 = VkFlags64; + +[AllowDuplicates] enum VkAccessFlagBits2 : int32 +{ + [NoShow] VK_ACCESS_2_NONE = 0, + [NoShow] VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 1 << 0, + [NoShow] VK_ACCESS_2_INDEX_READ_BIT = 1 << 1, + [NoShow] VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 1 << 2, + [NoShow] VK_ACCESS_2_UNIFORM_READ_BIT = 1 << 3, + [NoShow] VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 1 << 4, + [NoShow] VK_ACCESS_2_SHADER_READ_BIT = 1 << 5, + [NoShow] VK_ACCESS_2_SHADER_WRITE_BIT = 1 << 6, + [NoShow] VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 1 << 7, + [NoShow] VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 1 << 8, + [NoShow] VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 1 << 9, + [NoShow] VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1 << 10, + [NoShow] VK_ACCESS_2_TRANSFER_READ_BIT = 1 << 11, + [NoShow] VK_ACCESS_2_TRANSFER_WRITE_BIT = 1 << 12, + [NoShow] VK_ACCESS_2_HOST_READ_BIT = 1 << 13, + [NoShow] VK_ACCESS_2_HOST_WRITE_BIT = 1 << 14, + [NoShow] VK_ACCESS_2_MEMORY_READ_BIT = 1 << 15, + [NoShow] VK_ACCESS_2_MEMORY_WRITE_BIT = 1 << 16, + [NoShow] VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 1 << 32, + [NoShow] VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 1 << 33, + [NoShow] VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 1 << 34, + [NoShow] VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 1 << 35, + [NoShow] VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 1 << 36, + [NoShow] VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 1 << 37, + [NoShow] VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 1 << 38, + [NoShow] VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 1 << 51, + [NoShow] VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 1 << 52, + [NoShow] VK_ACCESS_2_NONE_KHR = VK_ACCESS_2_NONE, + [NoShow] VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT, + [NoShow] VK_ACCESS_2_INDEX_READ_BIT_KHR = VK_ACCESS_2_INDEX_READ_BIT, + [NoShow] VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT, + [NoShow] VK_ACCESS_2_UNIFORM_READ_BIT_KHR = VK_ACCESS_2_UNIFORM_READ_BIT, + [NoShow] VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT, + [NoShow] VK_ACCESS_2_SHADER_READ_BIT_KHR = VK_ACCESS_2_SHADER_READ_BIT, + [NoShow] VK_ACCESS_2_SHADER_WRITE_BIT_KHR = VK_ACCESS_2_SHADER_WRITE_BIT, + [NoShow] VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT, + [NoShow] VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + [NoShow] VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + [NoShow] VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + [NoShow] VK_ACCESS_2_TRANSFER_READ_BIT_KHR = VK_ACCESS_2_TRANSFER_READ_BIT, + [NoShow] VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = VK_ACCESS_2_TRANSFER_WRITE_BIT, + [NoShow] VK_ACCESS_2_HOST_READ_BIT_KHR = VK_ACCESS_2_HOST_READ_BIT, + [NoShow] VK_ACCESS_2_HOST_WRITE_BIT_KHR = VK_ACCESS_2_HOST_WRITE_BIT, + [NoShow] VK_ACCESS_2_MEMORY_READ_BIT_KHR = VK_ACCESS_2_MEMORY_READ_BIT, + [NoShow] VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = VK_ACCESS_2_MEMORY_WRITE_BIT, + [NoShow] VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, + [NoShow] VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = VK_ACCESS_2_SHADER_STORAGE_READ_BIT, + [NoShow] VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, + [NoShow] VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 1 << 25, + [NoShow] VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 1 << 26, + [NoShow] VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 1 << 27, + [NoShow] VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 1 << 20, // read access flag for reading conditional rendering predicate + [NoShow] VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT, + [NoShow] VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT, + [NoShow] VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 1 << 17, + [NoShow] VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 1 << 18, + [NoShow] VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 1 << 23, + [NoShow] VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + [NoShow] VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 1 << 21, + [NoShow] VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 1 << 22, + [NoShow] VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, + [NoShow] VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + [NoShow] VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 1 << 24, + [NoShow] VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 1 << 19, + [NoShow] VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 1 << 41, + [NoShow] VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 1 << 39, + [NoShow] VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 1 << 40, + [NoShow] VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 1 << 44, + [NoShow] VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 1 << 45, + [NoShow] VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 1 << 42, + [NoShow] VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 1 << 43, + [NoShow] VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM = 1 << 47, + [NoShow] VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM = 1 << 48, + [NoShow] VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT = 1 << 55, + [NoShow] VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT = 1 << 56, + // pretty names + VkAccess2_None = 0, + VkAccess2_IndirectCommandRead = 1 << 0, + VkAccess2_IndexRead = 1 << 1, + VkAccess2_VertexAttributeRead = 1 << 2, + VkAccess2_UniformRead = 1 << 3, + VkAccess2_InputAttachmentRead = 1 << 4, + VkAccess2_ShaderRead = 1 << 5, + VkAccess2_ShaderWrite = 1 << 6, + VkAccess2_ColorAttachmentRead = 1 << 7, + VkAccess2_ColorAttachmentWrite = 1 << 8, + VkAccess2_DepthStencilAttachmentRead = 1 << 9, + VkAccess2_DepthStencilAttachmentWrite = 1 << 10, + VkAccess2_TransferRead = 1 << 11, + VkAccess2_TransferWrite = 1 << 12, + VkAccess2_HostRead = 1 << 13, + VkAccess2_HostWrite = 1 << 14, + VkAccess2_MemoryRead = 1 << 15, + VkAccess2_MemoryWrite = 1 << 16, + VkAccess2_ShaderSampledRead = 1 << 32, + VkAccess2_ShaderStorageRead = 1 << 33, + VkAccess2_ShaderStorageWrite = 1 << 34, + VkAccess2_VideoDecodeReadKHR = 1 << 35, + VkAccess2_VideoDecodeWriteKHR = 1 << 36, + VkAccess2_VideoEncodeReadKHR = 1 << 37, + VkAccess2_VideoEncodeWriteKHR = 1 << 38, + VkAccess2_ShaderTileAttachmentReadQCOM = 1 << 51, + VkAccess2_ShaderTileAttachmentWriteQCOM = 1 << 52, + VkAccess2_NoneKHR = VkAccess2_None, + VkAccess2_IndirectCommandReadKHR = VkAccess2_IndirectCommandRead, + VkAccess2_IndexReadKHR = VkAccess2_IndexRead, + VkAccess2_VertexAttributeReadKHR = VkAccess2_VertexAttributeRead, + VkAccess2_UniformReadKHR = VkAccess2_UniformRead, + VkAccess2_InputAttachmentReadKHR = VkAccess2_InputAttachmentRead, + VkAccess2_ShaderReadKHR = VkAccess2_ShaderRead, + VkAccess2_ShaderWriteKHR = VkAccess2_ShaderWrite, + VkAccess2_ColorAttachmentReadKHR = VkAccess2_ColorAttachmentRead, + VkAccess2_ColorAttachmentWriteKHR = VkAccess2_ColorAttachmentWrite, + VkAccess2_DepthStencilAttachmentReadKHR = VkAccess2_DepthStencilAttachmentRead, + VkAccess2_DepthStencilAttachmentWriteKHR = VkAccess2_DepthStencilAttachmentWrite, + VkAccess2_TransferReadKHR = VkAccess2_TransferRead, + VkAccess2_TransferWriteKHR = VkAccess2_TransferWrite, + VkAccess2_HostReadKHR = VkAccess2_HostRead, + VkAccess2_HostWriteKHR = VkAccess2_HostWrite, + VkAccess2_MemoryReadKHR = VkAccess2_MemoryRead, + VkAccess2_MemoryWriteKHR = VkAccess2_MemoryWrite, + VkAccess2_ShaderSampledReadKHR = VkAccess2_ShaderSampledRead, + VkAccess2_ShaderStorageReadKHR = VkAccess2_ShaderStorageRead, + VkAccess2_ShaderStorageWriteKHR = VkAccess2_ShaderStorageWrite, + VkAccess2_TransformFeedbackWriteEXT = 1 << 25, + VkAccess2_TransformFeedbackCounterReadEXT = 1 << 26, + VkAccess2_TransformFeedbackCounterWriteEXT = 1 << 27, + VkAccess2_ConditionalRenderingReadEXT = 1 << 20, // read access flag for reading conditional rendering predicate + VkAccess2_CommandPreprocessReadNV = VkAccess2_CommandPreprocessReadEXT, + VkAccess2_CommandPreprocessWriteNV = VkAccess2_CommandPreprocessWriteEXT, + VkAccess2_CommandPreprocessReadEXT = 1 << 17, + VkAccess2_CommandPreprocessWriteEXT = 1 << 18, + VkAccess2_FragmentShadingRateAttachmentReadKHR = 1 << 23, + VkAccess2_ShadingRateImageReadNV = VkAccess2_FragmentShadingRateAttachmentReadKHR, + VkAccess2_AccelerationStructureReadKHR = 1 << 21, + VkAccess2_AccelerationStructureWriteKHR = 1 << 22, + VkAccess2_AccelerationStructureReadNV = VkAccess2_AccelerationStructureReadKHR, + VkAccess2_AccelerationStructureWriteNV = VkAccess2_AccelerationStructureWriteKHR, + VkAccess2_FragmentDensityMapReadEXT = 1 << 24, + VkAccess2_ColorAttachmentReadNoncoherentEXT = 1 << 19, + VkAccess2_DescriptorBufferReadEXT = 1 << 41, + VkAccess2_InvocationMaskReadHUAWEI = 1 << 39, + VkAccess2_ShaderBindingTableReadKHR = 1 << 40, + VkAccess2_MicromapReadEXT = 1 << 44, + VkAccess2_MicromapWriteEXT = 1 << 45, + VkAccess2_OpticalFlowReadNV = 1 << 42, + VkAccess2_OpticalFlowWriteNV = 1 << 43, + VkAccess2_DataGraphReadARM = 1 << 47, + VkAccess2_DataGraphWriteARM = 1 << 48, + VkAccess2_MemoryDecompressionReadEXT = 1 << 55, + VkAccess2_MemoryDecompressionWriteEXT = 1 << 56, +} + +[CRepr] struct VkMemoryBarrier2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_BARRIER_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 srcStageMask = default; + public VkAccessFlags2 srcAccessMask = default; + public VkPipelineStageFlags2 dstStageMask = default; + public VkAccessFlags2 dstAccessMask = default; + + public this(void* pNext = null, VkPipelineStageFlags2 srcStageMask = default, VkAccessFlags2 srcAccessMask = default, VkPipelineStageFlags2 dstStageMask = default, VkAccessFlags2 dstAccessMask = default) : this() + { + this.pNext = pNext; + this.srcStageMask = srcStageMask; + this.srcAccessMask = srcAccessMask; + this.dstStageMask = dstStageMask; + this.dstAccessMask = dstAccessMask; + } +} + +[CRepr] struct VkBufferMemoryBarrier2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 srcStageMask = default; + public VkAccessFlags2 srcAccessMask = default; + public VkPipelineStageFlags2 dstStageMask = default; + public VkAccessFlags2 dstAccessMask = default; + public uint32 srcQueueFamilyIndex = 0; + public uint32 dstQueueFamilyIndex = 0; + public VkBuffer buffer = null; + public VkDeviceSize offset = default; + public VkDeviceSize size = default; + + public this(void* pNext, VkPipelineStageFlags2 srcStageMask, VkAccessFlags2 srcAccessMask, VkPipelineStageFlags2 dstStageMask, VkAccessFlags2 dstAccessMask, uint32 srcQueueFamilyIndex, uint32 dstQueueFamilyIndex, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.srcStageMask = srcStageMask; + this.srcAccessMask = srcAccessMask; + this.dstStageMask = dstStageMask; + this.dstAccessMask = dstAccessMask; + this.srcQueueFamilyIndex = srcQueueFamilyIndex; + this.dstQueueFamilyIndex = dstQueueFamilyIndex; + this.buffer = buffer; + this.offset = offset; + this.size = size; + } +} + +[CRepr] struct VkImageMemoryBarrier2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 srcStageMask = default; + public VkAccessFlags2 srcAccessMask = default; + public VkPipelineStageFlags2 dstStageMask = default; + public VkAccessFlags2 dstAccessMask = default; + public VkImageLayout oldLayout = default; + public VkImageLayout newLayout = default; + public uint32 srcQueueFamilyIndex = 0; + public uint32 dstQueueFamilyIndex = 0; + public VkImage image = null; + public VkImageSubresourceRange subresourceRange = default; + + public this(void* pNext, VkPipelineStageFlags2 srcStageMask, VkAccessFlags2 srcAccessMask, VkPipelineStageFlags2 dstStageMask, VkAccessFlags2 dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, uint32 srcQueueFamilyIndex, uint32 dstQueueFamilyIndex, VkImage image, VkImageSubresourceRange subresourceRange) : this() + { + this.pNext = pNext; + this.srcStageMask = srcStageMask; + this.srcAccessMask = srcAccessMask; + this.dstStageMask = dstStageMask; + this.dstAccessMask = dstAccessMask; + this.oldLayout = oldLayout; + this.newLayout = newLayout; + this.srcQueueFamilyIndex = srcQueueFamilyIndex; + this.dstQueueFamilyIndex = dstQueueFamilyIndex; + this.image = image; + this.subresourceRange = subresourceRange; + } +} + +[CRepr] struct VkDependencyInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEPENDENCY_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDependencyFlags dependencyFlags = default; + public uint32 memoryBarrierCount = 0; + public VkMemoryBarrier2* pMemoryBarriers = null; + public Span memoryBarriers + { + get { return .(pMemoryBarriers, (.)memoryBarrierCount); } + set mut { pMemoryBarriers = value.Ptr; memoryBarrierCount = (.)value.Length; } + } + public uint32 bufferMemoryBarrierCount = 0; + public VkBufferMemoryBarrier2* pBufferMemoryBarriers = null; + public Span bufferMemoryBarriers + { + get { return .(pBufferMemoryBarriers, (.)bufferMemoryBarrierCount); } + set mut { pBufferMemoryBarriers = value.Ptr; bufferMemoryBarrierCount = (.)value.Length; } + } + public uint32 imageMemoryBarrierCount = 0; + public VkImageMemoryBarrier2* pImageMemoryBarriers = null; + public Span imageMemoryBarriers + { + get { return .(pImageMemoryBarriers, (.)imageMemoryBarrierCount); } + set mut { pImageMemoryBarriers = value.Ptr; imageMemoryBarrierCount = (.)value.Length; } + } + + public this(void* pNext = null, VkDependencyFlags dependencyFlags = default, Span memoryBarriers = default, Span bufferMemoryBarriers = default, Span imageMemoryBarriers = default) : this() + { + this.pNext = pNext; + this.dependencyFlags = dependencyFlags; + this.memoryBarriers = memoryBarriers; + this.bufferMemoryBarriers = bufferMemoryBarriers; + this.imageMemoryBarriers = imageMemoryBarriers; + } +} + +[CRepr] struct VkSubmitInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBMIT_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSubmitFlags flags = default; + public uint32 waitSemaphoreInfoCount = 0; + public VkSemaphoreSubmitInfo* pWaitSemaphoreInfos = null; + public Span waitSemaphoreInfos + { + get { return .(pWaitSemaphoreInfos, (.)waitSemaphoreInfoCount); } + set mut { pWaitSemaphoreInfos = value.Ptr; waitSemaphoreInfoCount = (.)value.Length; } + } + public uint32 commandBufferInfoCount = 0; + public VkCommandBufferSubmitInfo* pCommandBufferInfos = null; + public Span commandBufferInfos + { + get { return .(pCommandBufferInfos, (.)commandBufferInfoCount); } + set mut { pCommandBufferInfos = value.Ptr; commandBufferInfoCount = (.)value.Length; } + } + public uint32 signalSemaphoreInfoCount = 0; + public VkSemaphoreSubmitInfo* pSignalSemaphoreInfos = null; + public Span signalSemaphoreInfos + { + get { return .(pSignalSemaphoreInfos, (.)signalSemaphoreInfoCount); } + set mut { pSignalSemaphoreInfos = value.Ptr; signalSemaphoreInfoCount = (.)value.Length; } + } + + public this(void* pNext = null, VkSubmitFlags flags = default, Span waitSemaphoreInfos = default, Span commandBufferInfos = default, Span signalSemaphoreInfos = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.waitSemaphoreInfos = waitSemaphoreInfos; + this.commandBufferInfos = commandBufferInfos; + this.signalSemaphoreInfos = signalSemaphoreInfos; + } +} + +[CRepr] struct VkSemaphoreSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public uint64 value = 0; + public VkPipelineStageFlags2 stageMask = default; + public uint32 deviceIndex = 0; + + public this(void* pNext, VkSemaphore semaphore, uint64 value, VkPipelineStageFlags2 stageMask, uint32 deviceIndex) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.value = value; + this.stageMask = stageMask; + this.deviceIndex = deviceIndex; + } +} + +[CRepr] struct VkCommandBufferSubmitInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCommandBuffer commandBuffer = null; + public uint32 deviceMask = 0; + + public this(void* pNext, VkCommandBuffer commandBuffer, uint32 deviceMask) : this() + { + this.pNext = pNext; + this.commandBuffer = commandBuffer; + this.deviceMask = deviceMask; + } +} + +[AllowDuplicates] enum VkSubmitFlagBits : int32 +{ + [NoShow] VK_SUBMIT_PROTECTED_BIT = 1 << 0, + [NoShow] VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, + // pretty names + Protected = 1 << 0, + ProtectedKHR = Protected, +} + +typealias VkSubmitFlags = VkSubmitFlagBits; + +[CRepr] struct VkPhysicalDeviceSynchronization2Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 synchronization2 = false; + + public this(void* pNext, VkBool32 synchronization2) : this() + { + this.pNext = pNext; + this.synchronization2 = synchronization2; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, VkDependencyInfo* pDependencyInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32 query); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueSubmit2(VkQueue queue, uint32 submitCount, VkSubmitInfo2* pSubmits, VkFence fence = null); + +// Promoted from VK_KHR_copy_commands2 (extension 338) +[CRepr] struct VkCopyBufferInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer srcBuffer = null; + public VkBuffer dstBuffer = null; + public uint32 regionCount = 0; + public VkBufferCopy2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkBuffer srcBuffer, VkBuffer dstBuffer, Span regions) : this() + { + this.pNext = pNext; + this.srcBuffer = srcBuffer; + this.dstBuffer = dstBuffer; + this.regions = regions; + } +} + +[CRepr] struct VkCopyImageInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkImageCopy2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkCopyBufferToImageInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer srcBuffer = null; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkBufferImageCopy2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.srcBuffer = srcBuffer; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkCopyImageToBufferInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public VkBuffer dstBuffer = null; + public uint32 regionCount = 0; + public VkBufferImageCopy2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, Span regions) : this() + { + this.pNext = pNext; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.dstBuffer = dstBuffer; + this.regions = regions; + } +} + +[CRepr] struct VkBufferCopy2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COPY_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize srcOffset = default; // Specified in bytes + public VkDeviceSize dstOffset = default; // Specified in bytes + public VkDeviceSize size = default; // Specified in bytes + + public this(void* pNext, VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.srcOffset = srcOffset; + this.dstOffset = dstOffset; + this.size = size; + } +} + +[CRepr] struct VkImageCopy2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_COPY_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D srcOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D dstOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkExtent3D extent = default; // Specified in pixels for both compressed and uncompressed images + + public this(void* pNext, VkImageSubresourceLayers srcSubresource, VkOffset3D srcOffset, VkImageSubresourceLayers dstSubresource, VkOffset3D dstOffset, VkExtent3D extent) : this() + { + this.pNext = pNext; + this.srcSubresource = srcSubresource; + this.srcOffset = srcOffset; + this.dstSubresource = dstSubresource; + this.dstOffset = dstOffset; + this.extent = extent; + } +} + +[CRepr] struct VkBufferImageCopy2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize bufferOffset = default; // Specified in bytes + public uint32 bufferRowLength = 0; // Specified in texels + public uint32 bufferImageHeight = 0; + public VkImageSubresourceLayers imageSubresource = default; + public VkOffset3D imageOffset = default; // Specified in pixels for both compressed and uncompressed images + public VkExtent3D imageExtent = default; // Specified in pixels for both compressed and uncompressed images + + public this(void* pNext, VkDeviceSize bufferOffset, uint32 bufferRowLength, uint32 bufferImageHeight, VkImageSubresourceLayers imageSubresource, VkOffset3D imageOffset, VkExtent3D imageExtent) : this() + { + this.pNext = pNext; + this.bufferOffset = bufferOffset; + this.bufferRowLength = bufferRowLength; + this.bufferImageHeight = bufferImageHeight; + this.imageSubresource = imageSubresource; + this.imageOffset = imageOffset; + this.imageExtent = imageExtent; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, VkCopyBufferInfo2* pCopyBufferInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyImage2(VkCommandBuffer commandBuffer, VkCopyImageInfo2* pCopyImageInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +// Promoted from VK_EXT_ycbcr_2plane_444_formats (does not promote the Feature struct, just the formats) (extension 331) +// Promoted from VK_EXT_4444_formats (does not promote the Feature struct, just the formats) (extension 341) +// Promoted from VK_EXT_texture_compression_astc_hdr (Feature struct is promoted, but becomes optional) (extension 67) +[CRepr] struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 textureCompressionASTC_HDR = false; + + public this(void* pNext, VkBool32 textureCompressionASTC_HDR) : this() + { + this.pNext = pNext; + this.textureCompressionASTC_HDR = textureCompressionASTC_HDR; + } +} + +// Promoted from VK_KHR_format_feature_flags2 (extension 361) +typealias VkFormatFeatureFlags2 = VkFlags64; + +[AllowDuplicates] enum VkFormatFeatureFlagBits2 : int32 +{ + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 1 << 0, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 1 << 1, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 1 << 2, + [NoShow] VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 1 << 3, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 1 << 4, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 1 << 5, + [NoShow] VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 1 << 6, + [NoShow] VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 1 << 7, + [NoShow] VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 1 << 8, + [NoShow] VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 1 << 9, + [NoShow] VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 1 << 10, + [NoShow] VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 1 << 11, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 1 << 12, + [NoShow] VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 1 << 14, + [NoShow] VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 1 << 15, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 1 << 16, + [NoShow] VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 1 << 17, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 1 << 18, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 1 << 19, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1 << 20, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 1 << 21, + [NoShow] VK_FORMAT_FEATURE_2_DISJOINT_BIT = 1 << 22, + [NoShow] VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 1 << 23, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 1 << 31, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 1 << 32, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 1 << 33, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 1 << 13, // This is an interaction with EXT_filter_cubic, though not tagged that way + [NoShow] VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT = 1 << 46, + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 1 << 25, + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 1 << 26, + [NoShow] VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 1 << 29, + [NoShow] VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 1 << 24, + [NoShow] VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 30, + [NoShow] VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT, // Host image copies are supported + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 1 << 27, + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 1 << 28, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT, + [NoShow] VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + [NoShow] VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT, + [NoShow] VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT, + [NoShow] VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, + [NoShow] VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = VK_FORMAT_FEATURE_2_BLIT_DST_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT, + [NoShow] VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, + [NoShow] VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, + [NoShow] VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + [NoShow] VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_2_DISJOINT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + [NoShow] VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT, + [NoShow] VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 1 << 51, + [NoShow] VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 1 << 38, // Format support linear image as render target, it cannot be mixed with non linear attachment + [NoShow] VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 1 << 34, + [NoShow] VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 1 << 35, + [NoShow] VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 1 << 36, + [NoShow] VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 1 << 37, + [NoShow] VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM = 1 << 39, + [NoShow] VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM = 1 << 43, + [NoShow] VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 1 << 40, + [NoShow] VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 1 << 41, + [NoShow] VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 1 << 42, + [NoShow] VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 1 << 48, + [NoShow] VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 1 << 59, + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 1 << 49, + [NoShow] VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 1 << 50, + [NoShow] VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 1 << 52, + [NoShow] VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 1 << 53, + [NoShow] VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 1 << 54, + [NoShow] VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 1 << 55, + // pretty names + VkFormatFeature2_SampledImage = 1 << 0, + VkFormatFeature2_StorageImage = 1 << 1, + VkFormatFeature2_StorageImageAtomic = 1 << 2, + VkFormatFeature2_UniformTexelBuffer = 1 << 3, + VkFormatFeature2_StorageTexelBuffer = 1 << 4, + VkFormatFeature2_StorageTexelBufferAtomic = 1 << 5, + VkFormatFeature2_VertexBuffer = 1 << 6, + VkFormatFeature2_ColorAttachment = 1 << 7, + VkFormatFeature2_ColorAttachmentBlend = 1 << 8, + VkFormatFeature2_DepthStencilAttachment = 1 << 9, + VkFormatFeature2_BlitSrc = 1 << 10, + VkFormatFeature2_BlitDst = 1 << 11, + VkFormatFeature2_SampledImageFilterLinear = 1 << 12, + VkFormatFeature2_TransferSrc = 1 << 14, + VkFormatFeature2_TransferDst = 1 << 15, + VkFormatFeature2_SampledImageFilterMinmax = 1 << 16, + VkFormatFeature2_MidpointChromaSamples = 1 << 17, + VkFormatFeature2_SampledImageYcbcrConversionLinearFilter = 1 << 18, + VkFormatFeature2_SampledImageYcbcrConversionSeparateReconstructionFilter = 1 << 19, + VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicit = 1 << 20, + VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicitForceable = 1 << 21, + VkFormatFeature2_Disjoint = 1 << 22, + VkFormatFeature2_CositedChromaSamples = 1 << 23, + VkFormatFeature2_StorageReadWithoutFormat = 1 << 31, + VkFormatFeature2_StorageWriteWithoutFormat = 1 << 32, + VkFormatFeature2_SampledImageDepthComparison = 1 << 33, + VkFormatFeature2_SampledImageFilterCubic = 1 << 13, // This is an interaction with EXT_filter_cubic, though not tagged that way + VkFormatFeature2_HostImageTransfer = 1 << 46, + VkFormatFeature2_VideoDecodeOutputKHR = 1 << 25, + VkFormatFeature2_VideoDecodeDpbKHR = 1 << 26, + VkFormatFeature2_AccelerationStructureVertexBufferKHR = 1 << 29, + VkFormatFeature2_FragmentDensityMapEXT = 1 << 24, + VkFormatFeature2_FragmentShadingRateAttachmentKHR = 1 << 30, + VkFormatFeature2_HostImageTransferEXT = VkFormatFeature2_HostImageTransfer, // Host image copies are supported + VkFormatFeature2_VideoEncodeInputKHR = 1 << 27, + VkFormatFeature2_VideoEncodeDpbKHR = 1 << 28, + VkFormatFeature2_SampledImageKHR = VkFormatFeature2_SampledImage, + VkFormatFeature2_StorageImageKHR = VkFormatFeature2_StorageImage, + VkFormatFeature2_StorageImageAtomicKHR = VkFormatFeature2_StorageImageAtomic, + VkFormatFeature2_UniformTexelBufferKHR = VkFormatFeature2_UniformTexelBuffer, + VkFormatFeature2_StorageTexelBufferKHR = VkFormatFeature2_StorageTexelBuffer, + VkFormatFeature2_StorageTexelBufferAtomicKHR = VkFormatFeature2_StorageTexelBufferAtomic, + VkFormatFeature2_VertexBufferKHR = VkFormatFeature2_VertexBuffer, + VkFormatFeature2_ColorAttachmentKHR = VkFormatFeature2_ColorAttachment, + VkFormatFeature2_ColorAttachmentBlendKHR = VkFormatFeature2_ColorAttachmentBlend, + VkFormatFeature2_DepthStencilAttachmentKHR = VkFormatFeature2_DepthStencilAttachment, + VkFormatFeature2_BlitSrcKHR = VkFormatFeature2_BlitSrc, + VkFormatFeature2_BlitDstKHR = VkFormatFeature2_BlitDst, + VkFormatFeature2_SampledImageFilterLinearKHR = VkFormatFeature2_SampledImageFilterLinear, + VkFormatFeature2_TransferSrcKHR = VkFormatFeature2_TransferSrc, + VkFormatFeature2_TransferDstKHR = VkFormatFeature2_TransferDst, + VkFormatFeature2_MidpointChromaSamplesKHR = VkFormatFeature2_MidpointChromaSamples, + VkFormatFeature2_SampledImageYcbcrConversionLinearFilterKHR = VkFormatFeature2_SampledImageYcbcrConversionLinearFilter, + VkFormatFeature2_SampledImageYcbcrConversionSeparateReconstructionFilterKHR = VkFormatFeature2_SampledImageYcbcrConversionSeparateReconstructionFilter, + VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicitKHR = VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicit, + VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VkFormatFeature2_SampledImageYcbcrConversionChromaReconstructionExplicitForceable, + VkFormatFeature2_DisjointKHR = VkFormatFeature2_Disjoint, + VkFormatFeature2_CositedChromaSamplesKHR = VkFormatFeature2_CositedChromaSamples, + VkFormatFeature2_StorageReadWithoutFormatKHR = VkFormatFeature2_StorageReadWithoutFormat, + VkFormatFeature2_StorageWriteWithoutFormatKHR = VkFormatFeature2_StorageWriteWithoutFormat, + VkFormatFeature2_SampledImageDepthComparisonKHR = VkFormatFeature2_SampledImageDepthComparison, + VkFormatFeature2_SampledImageFilterMinmaxKHR = VkFormatFeature2_SampledImageFilterMinmax, + VkFormatFeature2_SampledImageFilterCubicEXT = VkFormatFeature2_SampledImageFilterCubic, + VkFormatFeature2_AccelerationStructureRadiusBufferNV = 1 << 51, + VkFormatFeature2_LinearColorAttachmentNV = 1 << 38, // Format support linear image as render target, it cannot be mixed with non linear attachment + VkFormatFeature2_WeightImageQCOM = 1 << 34, + VkFormatFeature2_WeightSampledImageQCOM = 1 << 35, + VkFormatFeature2_BlockMatchingQCOM = 1 << 36, + VkFormatFeature2_BoxFilterSampledQCOM = 1 << 37, + VkFormatFeature2_TensorShaderARM = 1 << 39, + VkFormatFeature2_TensorImageAliasingARM = 1 << 43, + VkFormatFeature2_OpticalFlowImageNV = 1 << 40, + VkFormatFeature2_OpticalFlowVectorNV = 1 << 41, + VkFormatFeature2_OpticalFlowCostNV = 1 << 42, + VkFormatFeature2_TensorDataGraphARM = 1 << 48, + VkFormatFeature2_CopyImageIndirectDstKHR = 1 << 59, + VkFormatFeature2_VideoEncodeQuantizationDeltaMapKHR = 1 << 49, + VkFormatFeature2_VideoEncodeEmphasisMapKHR = 1 << 50, + VkFormatFeature2_DepthCopyOnComputeQueueKHR = 1 << 52, + VkFormatFeature2_DepthCopyOnTransferQueueKHR = 1 << 53, + VkFormatFeature2_StencilCopyOnComputeQueueKHR = 1 << 54, + VkFormatFeature2_StencilCopyOnTransferQueueKHR = 1 << 55, +} + +[CRepr] struct VkFormatProperties3 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormatFeatureFlags2 linearTilingFeatures = default; + public VkFormatFeatureFlags2 optimalTilingFeatures = default; + public VkFormatFeatureFlags2 bufferFeatures = default; +} + +// Promoted from VK_KHR_maintenance4 (extension 414) +[CRepr] struct VkPhysicalDeviceMaintenance4Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance4 = false; + + public this(void* pNext, VkBool32 maintenance4) : this() + { + this.pNext = pNext; + this.maintenance4 = maintenance4; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance4Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize maxBufferSize = default; +} + +[CRepr] struct VkDeviceBufferMemoryRequirements : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCreateInfo* pCreateInfo = null; + + public this(void* pNext, VkBufferCreateInfo* pCreateInfo) : this() + { + this.pNext = pNext; + this.pCreateInfo = pCreateInfo; + } +} + +[CRepr] struct VkDeviceImageMemoryRequirements : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCreateInfo* pCreateInfo = null; + public VkImageAspectFlagBits planeAspect = default; + + public this(void* pNext, VkImageCreateInfo* pCreateInfo, VkImageAspectFlagBits planeAspect = default) : this() + { + this.pNext = pNext; + this.pCreateInfo = pCreateInfo; + this.planeAspect = planeAspect; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceBufferMemoryRequirements(VkDevice device, VkDeviceBufferMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceImageMemoryRequirements(VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, VkDeviceImageMemoryRequirements* pInfo, out uint32 pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements = null); + +// Vulkan compute 1.3 API interface definitions. +// Promoted from VK_EXT_pipeline_creation_feedback (extension 193) +[AllowDuplicates] enum VkPipelineCreationFeedbackFlagBits : int32 +{ + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 1 << 0, + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 1 << 1, + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 1 << 2, + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + [NoShow] VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, + // pretty names + Valid = 1 << 0, + ApplicationPipelineCacheHit = 1 << 1, + BasePipelineAcceleration = 1 << 2, + ValidEXT = Valid, + ApplicationPipelineCacheHitEXT = ApplicationPipelineCacheHit, + BasePipelineAccelerationEXT = BasePipelineAcceleration, +} + +typealias VkPipelineCreationFeedbackFlags = VkPipelineCreationFeedbackFlagBits; + +[CRepr] struct VkPipelineCreationFeedbackCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreationFeedback* pPipelineCreationFeedback = null; // Output pipeline creation feedback. + public uint32 pipelineStageCreationFeedbackCount = 0; + public VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks = null; // One entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct + public Span pipelineStageCreationFeedbacks + { + get { return .(pPipelineStageCreationFeedbacks, (.)pipelineStageCreationFeedbackCount); } + set mut { pPipelineStageCreationFeedbacks = value.Ptr; pipelineStageCreationFeedbackCount = (.)value.Length; } + } + + public this(void* pNext, VkPipelineCreationFeedback* pPipelineCreationFeedback, Span pipelineStageCreationFeedbacks = default) : this() + { + this.pNext = pNext; + this.pPipelineCreationFeedback = pPipelineCreationFeedback; + this.pipelineStageCreationFeedbacks = pipelineStageCreationFeedbacks; + } +} + +[CRepr] struct VkPipelineCreationFeedback : this() +{ + public VkPipelineCreationFeedbackFlags flags = default; + public uint64 duration = 0; +} + +// Promoted from VK_KHR_shader_terminate_invocation (extension 216) +[CRepr] struct VkPhysicalDeviceShaderTerminateInvocationFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderTerminateInvocation = false; + + public this(void* pNext, VkBool32 shaderTerminateInvocation) : this() + { + this.pNext = pNext; + this.shaderTerminateInvocation = shaderTerminateInvocation; + } +} + +// Promoted from VK_EXT_shader_demote_to_helper_invocation (extension 277) +[CRepr] struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderDemoteToHelperInvocation = false; + + public this(void* pNext, VkBool32 shaderDemoteToHelperInvocation) : this() + { + this.pNext = pNext; + this.shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation; + } +} + +// Promoted from VK_KHR_shader_non_semantic_info (extension 294) +// Promoted from VK_EXT_pipeline_creation_cache_control (extension 298) +[CRepr] struct VkPhysicalDevicePipelineCreationCacheControlFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineCreationCacheControl = false; + + public this(void* pNext, VkBool32 pipelineCreationCacheControl) : this() + { + this.pNext = pNext; + this.pipelineCreationCacheControl = pipelineCreationCacheControl; + } +} + +[AllowDuplicates] enum VkPipelineCacheCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 1 << 0, + [NoShow] VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + [NoShow] VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR = 1 << 3, + // pretty names + ExternallySynchronized = 1 << 0, + ExternallySynchronizedEXT = ExternallySynchronized, + InternallySynchronizedMergeKHR = 1 << 3, +} + +// Promoted from VK_KHR_synchronization2 (extension 315) +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfo* pDependencyInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32 eventCount, VkEvent* pEvents, VkDependencyInfo* pDependencyInfos); + +// Promoted from VK_KHR_zero_initialize_workgroup_memory (extension 326) +[CRepr] struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderZeroInitializeWorkgroupMemory = false; + + public this(void* pNext, VkBool32 shaderZeroInitializeWorkgroupMemory) : this() + { + this.pNext = pNext; + this.shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory; + } +} + +// Promoted from VK_EXT_image_robustness (extension 336) +[CRepr] struct VkPhysicalDeviceImageRobustnessFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 robustImageAccess = false; + + public this(void* pNext, VkBool32 robustImageAccess) : this() + { + this.pNext = pNext; + this.robustImageAccess = robustImageAccess; + } +} + +// Promoted from VK_EXT_subgroup_size_control (STDPROMOTE/PROPLIMCHANGE) (extension 226) +[CRepr] struct VkPhysicalDeviceSubgroupSizeControlFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 subgroupSizeControl = false; + public VkBool32 computeFullSubgroups = false; + + public this(void* pNext, VkBool32 subgroupSizeControl, VkBool32 computeFullSubgroups) : this() + { + this.pNext = pNext; + this.subgroupSizeControl = subgroupSizeControl; + this.computeFullSubgroups = computeFullSubgroups; + } +} + +[CRepr] struct VkPhysicalDeviceSubgroupSizeControlProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 minSubgroupSize = 0; // The minimum subgroup size supported by this device + public uint32 maxSubgroupSize = 0; // The maximum subgroup size supported by this device + public uint32 maxComputeWorkgroupSubgroups = 0; // The maximum number of subgroups supported in a workgroup + public VkShaderStageFlags requiredSubgroupSizeStages = default; // The shader stages that support specifying a subgroup size +} + +[CRepr] struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 requiredSubgroupSize = 0; + + public this(void* pNext, uint32 requiredSubgroupSize) : this() + { + this.pNext = pNext; + this.requiredSubgroupSize = requiredSubgroupSize; + } +} + +// Promoted from VK_EXT_inline_uniform_block (STDPROMOTE/PROPLIMCHANGE) (extension 139) +[CRepr] struct VkPhysicalDeviceInlineUniformBlockFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 inlineUniformBlock = false; + public VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind = false; + + public this(void* pNext, VkBool32 inlineUniformBlock, VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind) : this() + { + this.pNext = pNext; + this.inlineUniformBlock = inlineUniformBlock; + this.descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind; + } +} + +[CRepr] struct VkPhysicalDeviceInlineUniformBlockProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxInlineUniformBlockSize = 0; + public uint32 maxPerStageDescriptorInlineUniformBlocks = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 0; + public uint32 maxDescriptorSetInlineUniformBlocks = 0; + public uint32 maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 0; +} + +[CRepr] struct VkWriteDescriptorSetInlineUniformBlock : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(void* pNext, Span data) : this() + { + this.pNext = pNext; + this.data = data; + } +} + +[CRepr] struct VkDescriptorPoolInlineUniformBlockCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxInlineUniformBlockBindings = 0; + + public this(void* pNext, uint32 maxInlineUniformBlockBindings) : this() + { + this.pNext = pNext; + this.maxInlineUniformBlockBindings = maxInlineUniformBlockBindings; + } +} + +// Promoted from VK_KHR_shader_integer_dot_product (extension 281) +[CRepr] struct VkPhysicalDeviceShaderIntegerDotProductFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderIntegerDotProduct = false; + + public this(void* pNext, VkBool32 shaderIntegerDotProduct) : this() + { + this.pNext = pNext; + this.shaderIntegerDotProduct = shaderIntegerDotProduct; + } +} + +[CRepr] struct VkPhysicalDeviceShaderIntegerDotProductProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 integerDotProduct8BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct8BitSignedAccelerated = false; + public VkBool32 integerDotProduct8BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedSignedAccelerated = false; + public VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct16BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct16BitSignedAccelerated = false; + public VkBool32 integerDotProduct16BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct32BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct32BitSignedAccelerated = false; + public VkBool32 integerDotProduct32BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProduct64BitUnsignedAccelerated = false; + public VkBool32 integerDotProduct64BitSignedAccelerated = false; + public VkBool32 integerDotProduct64BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = false; + public VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = false; +} + +// Promoted from VK_EXT_texel_buffer_alignment (extension 282) +[CRepr] struct VkPhysicalDeviceTexelBufferAlignmentProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize storageTexelBufferOffsetAlignmentBytes = default; + public VkBool32 storageTexelBufferOffsetSingleTexelAlignment = false; + public VkDeviceSize uniformTexelBufferOffsetAlignmentBytes = default; + public VkBool32 uniformTexelBufferOffsetSingleTexelAlignment = false; +} + +// Vulkan graphics 1.3 API interface definitions. +// Promoted from VK_KHR_copy_commands2 (extension 338) +[CRepr] struct VkBlitImageInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkImageBlit2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + public VkFilter filter = default; + + public this(void* pNext, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span regions, VkFilter filter) : this() + { + this.pNext = pNext; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + this.filter = filter; + } +} + +[CRepr] struct VkImageBlit2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_BLIT_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D[2] srcOffsets = .(); // Specified in pixels for both compressed and uncompressed images + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D[2] dstOffsets = .(); // Specified in pixels for both compressed and uncompressed images + + public this(void* pNext, VkImageSubresourceLayers srcSubresource, VkOffset3D[2] srcOffsets, VkImageSubresourceLayers dstSubresource, VkOffset3D[2] dstOffsets) : this() + { + this.pNext = pNext; + this.srcSubresource = srcSubresource; + this.srcOffsets = srcOffsets; + this.dstSubresource = dstSubresource; + this.dstOffsets = dstOffsets; + } +} + +[CRepr] struct VkResolveImageInfo2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkImageResolve2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkImageResolve2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageSubresourceLayers srcSubresource = default; + public VkOffset3D srcOffset = default; + public VkImageSubresourceLayers dstSubresource = default; + public VkOffset3D dstOffset = default; + public VkExtent3D extent = default; + + public this(void* pNext, VkImageSubresourceLayers srcSubresource, VkOffset3D srcOffset, VkImageSubresourceLayers dstSubresource, VkOffset3D dstOffset, VkExtent3D extent) : this() + { + this.pNext = pNext; + this.srcSubresource = srcSubresource; + this.srcOffset = srcOffset; + this.dstSubresource = dstSubresource; + this.dstOffset = dstOffset; + this.extent = extent; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBlitImage2(VkCommandBuffer commandBuffer, VkBlitImageInfo2* pBlitImageInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdResolveImage2(VkCommandBuffer commandBuffer, VkResolveImageInfo2* pResolveImageInfo); + +// Promoted from VK_KHR_dynamic_rendering (extension 45) +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginRendering(VkCommandBuffer commandBuffer, VkRenderingInfo* pRenderingInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndRendering(VkCommandBuffer commandBuffer); + +[CRepr] struct VkRenderingInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderingFlags flags = default; + public VkRect2D renderArea = default; + public uint32 layerCount = 0; + public uint32 viewMask = 0; + public uint32 colorAttachmentCount = 0; + public VkRenderingAttachmentInfo* pColorAttachments = null; + public Span colorAttachments + { + get { return .(pColorAttachments, (.)colorAttachmentCount); } + set mut { pColorAttachments = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkRenderingAttachmentInfo* pDepthAttachment = null; + public VkRenderingAttachmentInfo* pStencilAttachment = null; + + public this(void* pNext, VkRenderingFlags flags, VkRect2D renderArea, uint32 layerCount, uint32 viewMask, Span colorAttachments = default, VkRenderingAttachmentInfo* pDepthAttachment = null, VkRenderingAttachmentInfo* pStencilAttachment = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.renderArea = renderArea; + this.layerCount = layerCount; + this.viewMask = viewMask; + this.colorAttachments = colorAttachments; + this.pDepthAttachment = pDepthAttachment; + this.pStencilAttachment = pStencilAttachment; + } +} + +[CRepr] struct VkRenderingAttachmentInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView imageView = null; + public VkImageLayout imageLayout = default; + public VkResolveModeFlagBits resolveMode = default; + public VkImageView resolveImageView = null; + public VkImageLayout resolveImageLayout = default; + public VkAttachmentLoadOp loadOp = default; + public VkAttachmentStoreOp storeOp = default; + public VkClearValue clearValue = default; + + public this(void* pNext, VkImageView imageView, VkImageLayout imageLayout, VkResolveModeFlagBits resolveMode, VkImageView resolveImageView, VkImageLayout resolveImageLayout, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp, VkClearValue clearValue) : this() + { + this.pNext = pNext; + this.imageView = imageView; + this.imageLayout = imageLayout; + this.resolveMode = resolveMode; + this.resolveImageView = resolveImageView; + this.resolveImageLayout = resolveImageLayout; + this.loadOp = loadOp; + this.storeOp = storeOp; + this.clearValue = clearValue; + } +} + +[CRepr] struct VkPipelineRenderingCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 viewMask = 0; + public uint32 colorAttachmentCount = 0; + public VkFormat* pColorAttachmentFormats = null; + public Span colorAttachmentFormats + { + get { return .(pColorAttachmentFormats, (.)colorAttachmentCount); } + set mut { pColorAttachmentFormats = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkFormat depthAttachmentFormat = default; + public VkFormat stencilAttachmentFormat = default; + + public this(void* pNext, uint32 viewMask, Span colorAttachmentFormats, VkFormat depthAttachmentFormat, VkFormat stencilAttachmentFormat) : this() + { + this.pNext = pNext; + this.viewMask = viewMask; + this.colorAttachmentFormats = colorAttachmentFormats; + this.depthAttachmentFormat = depthAttachmentFormat; + this.stencilAttachmentFormat = stencilAttachmentFormat; + } +} + +[CRepr] struct VkPhysicalDeviceDynamicRenderingFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dynamicRendering = false; + + public this(void* pNext, VkBool32 dynamicRendering) : this() + { + this.pNext = pNext; + this.dynamicRendering = dynamicRendering; + } +} + +[CRepr] struct VkCommandBufferInheritanceRenderingInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderingFlags flags = default; + public uint32 viewMask = 0; + public uint32 colorAttachmentCount = 0; + public VkFormat* pColorAttachmentFormats = null; + public Span colorAttachmentFormats + { + get { return .(pColorAttachmentFormats, (.)colorAttachmentCount); } + set mut { pColorAttachmentFormats = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkFormat depthAttachmentFormat = default; + public VkFormat stencilAttachmentFormat = default; + public VkSampleCountFlagBits rasterizationSamples = default; + + public this(void* pNext, VkRenderingFlags flags, uint32 viewMask, Span colorAttachmentFormats, VkFormat depthAttachmentFormat, VkFormat stencilAttachmentFormat, VkSampleCountFlagBits rasterizationSamples = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.viewMask = viewMask; + this.colorAttachmentFormats = colorAttachmentFormats; + this.depthAttachmentFormat = depthAttachmentFormat; + this.stencilAttachmentFormat = stencilAttachmentFormat; + this.rasterizationSamples = rasterizationSamples; + } +} + +typealias VkRenderingFlags = VkRenderingFlagBits; + +[AllowDuplicates] enum VkRenderingFlagBits : int32 +{ + [NoShow] VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 1 << 0, + [NoShow] VK_RENDERING_SUSPENDING_BIT = 1 << 1, + [NoShow] VK_RENDERING_RESUMING_BIT = 1 << 2, + [NoShow] VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, + [NoShow] VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, + [NoShow] VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, + [NoShow] VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, + [NoShow] VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 1 << 3, + [NoShow] VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 1 << 4, // Promoted from extension 452 + [NoShow] VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 1 << 5, + [NoShow] VK_RENDERING_FRAGMENT_REGION_BIT_EXT = 1 << 6, + [NoShow] VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT = 1 << 7, + [NoShow] VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR = 1 << 8, + // pretty names + ContentsSecondaryCommandBuffers = 1 << 0, + Suspending = 1 << 1, + Resuming = 1 << 2, + ContentsSecondaryCommandBuffersKHR = ContentsSecondaryCommandBuffers, + SuspendingKHR = Suspending, + ResumingKHR = Resuming, + ContentsInlineEXT = ContentsInlineKHR, + EnableLegacyDitheringEXT = 1 << 3, + ContentsInlineKHR = 1 << 4, // Promoted from extension 452 + PerLayerFragmentDensityVALVE = 1 << 5, + FragmentRegionEXT = 1 << 6, + CustomResolveEXT = 1 << 7, + LocalReadConcurrentAccessControlKHR = 1 << 8, +} + +// Promoted from VK_EXT_extended_dynamic_state (Feature struct is not promoted) (extension 268) +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode = default); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32 viewportCount, VkViewport* pViewports); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32 scissorCount, VkRect2D* pScissors); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes = null, VkDeviceSize* pStrides = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +// Promoted from VK_EXT_extended_dynamic_state2 (Feature struct and optional state are not promoted) (extension 378) +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +// Vulkan 1.3 core API interface definitions +// Feature requirements +// Vulkan base 1.4 API interface definitions. +// API version macros +// Vulkan 1.4 version number +static { public const let VK_API_VERSION_1_4 = VK_MAKE_API_VERSION(0, 1, 4, 0); }// Patch version should always be set to 0 + +[CRepr] struct VkPhysicalDeviceVulkan14Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 globalPriorityQuery = false; + public VkBool32 shaderSubgroupRotate = false; + public VkBool32 shaderSubgroupRotateClustered = false; + public VkBool32 shaderFloatControls2 = false; + public VkBool32 shaderExpectAssume = false; + public VkBool32 rectangularLines = false; + public VkBool32 bresenhamLines = false; + public VkBool32 smoothLines = false; + public VkBool32 stippledRectangularLines = false; + public VkBool32 stippledBresenhamLines = false; + public VkBool32 stippledSmoothLines = false; + public VkBool32 vertexAttributeInstanceRateDivisor = false; + public VkBool32 vertexAttributeInstanceRateZeroDivisor = false; + public VkBool32 indexTypeUint8 = false; + public VkBool32 dynamicRenderingLocalRead = false; + public VkBool32 maintenance5 = false; + public VkBool32 maintenance6 = false; + public VkBool32 pipelineProtectedAccess = false; + public VkBool32 pipelineRobustness = false; + public VkBool32 hostImageCopy = false; + public VkBool32 pushDescriptor = false; + + public this(void* pNext, VkBool32 globalPriorityQuery, VkBool32 shaderSubgroupRotate, VkBool32 shaderSubgroupRotateClustered, VkBool32 shaderFloatControls2, VkBool32 shaderExpectAssume, VkBool32 rectangularLines, VkBool32 bresenhamLines, VkBool32 smoothLines, VkBool32 stippledRectangularLines, VkBool32 stippledBresenhamLines, VkBool32 stippledSmoothLines, VkBool32 vertexAttributeInstanceRateDivisor, VkBool32 vertexAttributeInstanceRateZeroDivisor, VkBool32 indexTypeUint8, VkBool32 dynamicRenderingLocalRead, VkBool32 maintenance5, VkBool32 maintenance6, VkBool32 pipelineProtectedAccess, VkBool32 pipelineRobustness, VkBool32 hostImageCopy, VkBool32 pushDescriptor) : this() + { + this.pNext = pNext; + this.globalPriorityQuery = globalPriorityQuery; + this.shaderSubgroupRotate = shaderSubgroupRotate; + this.shaderSubgroupRotateClustered = shaderSubgroupRotateClustered; + this.shaderFloatControls2 = shaderFloatControls2; + this.shaderExpectAssume = shaderExpectAssume; + this.rectangularLines = rectangularLines; + this.bresenhamLines = bresenhamLines; + this.smoothLines = smoothLines; + this.stippledRectangularLines = stippledRectangularLines; + this.stippledBresenhamLines = stippledBresenhamLines; + this.stippledSmoothLines = stippledSmoothLines; + this.vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor; + this.vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor; + this.indexTypeUint8 = indexTypeUint8; + this.dynamicRenderingLocalRead = dynamicRenderingLocalRead; + this.maintenance5 = maintenance5; + this.maintenance6 = maintenance6; + this.pipelineProtectedAccess = pipelineProtectedAccess; + this.pipelineRobustness = pipelineRobustness; + this.hostImageCopy = hostImageCopy; + this.pushDescriptor = pushDescriptor; + } +} + +[CRepr] struct VkPhysicalDeviceVulkan14Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 lineSubPixelPrecisionBits = 0; + public uint32 maxVertexAttribDivisor = 0; // max value of vertex attribute divisor + public VkBool32 supportsNonZeroFirstInstance = false; + public uint32 maxPushDescriptors = 0; + public VkBool32 dynamicRenderingLocalReadDepthStencilAttachments = false; + public VkBool32 dynamicRenderingLocalReadMultisampledAttachments = false; + public VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting = false; + public VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting = false; + public VkBool32 depthStencilSwizzleOneSupport = false; + public VkBool32 polygonModePointSize = false; + public VkBool32 nonStrictSinglePixelWideLinesUseParallelogram = false; + public VkBool32 nonStrictWideLinesUseParallelogram = false; + public VkBool32 blockTexelViewCompatibleMultipleLayers = false; + public uint32 maxCombinedImageSamplerDescriptorCount = 0; + public VkBool32 fragmentShadingRateClampCombinerInputs = false; + public VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = default; + public VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = default; + public VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = default; + public VkPipelineRobustnessImageBehavior defaultRobustnessImages = default; + public uint32 copySrcLayoutCount = 0; + public VkImageLayout* pCopySrcLayouts = null; + public Span copySrcLayouts + { + get { return .(pCopySrcLayouts, (.)copySrcLayoutCount); } + set mut { pCopySrcLayouts = value.Ptr; copySrcLayoutCount = (.)value.Length; } + } + public uint32 copyDstLayoutCount = 0; + public VkImageLayout* pCopyDstLayouts = null; + public Span copyDstLayouts + { + get { return .(pCopyDstLayouts, (.)copyDstLayoutCount); } + set mut { pCopyDstLayouts = value.Ptr; copyDstLayoutCount = (.)value.Length; } + } + public uint8[VK_UUID_SIZE] optimalTilingLayoutUUID = .(); + public VkBool32 identicalMemoryTypeRequirements = false; +} + +// Promoted from VK_KHR_global_priority (extension 189) +static { public const uint32 VK_MAX_GLOBAL_PRIORITY_SIZE = 16; } + +[CRepr] struct VkDeviceQueueGlobalPriorityCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueueGlobalPriority globalPriority = default; + + public this(void* pNext, VkQueueGlobalPriority globalPriority) : this() + { + this.pNext = pNext; + this.globalPriority = globalPriority; + } +} + +[AllowDuplicates] enum VkQueueGlobalPriority : int32 +{ + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_LOW = 128, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = VK_QUEUE_GLOBAL_PRIORITY_LOW, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + [NoShow] VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + // pretty names + Low = 128, + Medium = 256, + High = 512, + Realtime = 1024, + LowEXT = Low, + MediumEXT = Medium, + HighEXT = High, + RealtimeEXT = Realtime, + LowKHR = Low, + MediumKHR = Medium, + HighKHR = High, + RealtimeKHR = Realtime, +} + +[CRepr] struct VkPhysicalDeviceGlobalPriorityQueryFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 globalPriorityQuery = false; + + public this(void* pNext, VkBool32 globalPriorityQuery) : this() + { + this.pNext = pNext; + this.globalPriorityQuery = globalPriorityQuery; + } +} + +[CRepr] struct VkQueueFamilyGlobalPriorityProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 priorityCount = 0; + public VkQueueGlobalPriority[VK_MAX_GLOBAL_PRIORITY_SIZE] priorities = .(); + public Span riorities + { + get mut { return .(&priorities, (.)priorityCount); } + set mut { value.CopyTo(priorities); priorityCount = (.)value.Length; } + } +} + +// Promoted from VK_KHR_index_type_uint8 (extension 534) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceIndexTypeUint8Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 indexTypeUint8 = false; + + public this(void* pNext, VkBool32 indexTypeUint8) : this() + { + this.pNext = pNext; + this.indexTypeUint8 = indexTypeUint8; + } +} + +// Promoted from VK_KHR_map_memory2 (extension 272) 'Roadmap 2024' +[CRepr] struct VkMemoryMapInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryMapFlags flags = default; + public VkDeviceMemory memory = null; + public VkDeviceSize offset = default; + public VkDeviceSize size = default; + + public this(void* pNext, VkMemoryMapFlags flags, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.flags = flags; + this.memory = memory; + this.offset = offset; + this.size = size; + } +} + +[CRepr] struct VkMemoryUnmapInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryUnmapFlags flags = default; + public VkDeviceMemory memory = null; + + public this(void* pNext, VkMemoryUnmapFlags flags, VkDeviceMemory memory) : this() + { + this.pNext = pNext; + this.flags = flags; + this.memory = memory; + } +} + +[AllowDuplicates] enum VkMemoryUnmapFlagBits : int32 +{ + [NoShow] VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 1 << 0, + // pretty names + ReserveEXT = 1 << 0, +} + +typealias VkMemoryUnmapFlags = VkMemoryUnmapFlagBits; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkMapMemory2(VkDevice device, VkMemoryMapInfo* pMemoryMapInfo, out void* ppData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkUnmapMemory2(VkDevice device, VkMemoryUnmapInfo* pMemoryUnmapInfo); + +// Promoted from VK_KHR_maintenance5 (extension 471) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceMaintenance5Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance5 = false; + + public this(void* pNext, VkBool32 maintenance5) : this() + { + this.pNext = pNext; + this.maintenance5 = maintenance5; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance5Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting = false; + public VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting = false; + public VkBool32 depthStencilSwizzleOneSupport = false; + public VkBool32 polygonModePointSize = false; + public VkBool32 nonStrictSinglePixelWideLinesUseParallelogram = false; + public VkBool32 nonStrictWideLinesUseParallelogram = false; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceImageSubresourceLayout(VkDevice device, VkDeviceImageSubresourceInfo* pInfo, out VkSubresourceLayout2 pLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetImageSubresourceLayout2(VkDevice device, VkImage image, VkImageSubresource2* pSubresource, out VkSubresourceLayout2 pLayout); + +[CRepr] struct VkDeviceImageSubresourceInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCreateInfo* pCreateInfo = null; + public VkImageSubresource2* pSubresource = null; + + public this(void* pNext, VkImageCreateInfo* pCreateInfo, VkImageSubresource2* pSubresource) : this() + { + this.pNext = pNext; + this.pCreateInfo = pCreateInfo; + this.pSubresource = pSubresource; + } +} + +[CRepr] struct VkImageSubresource2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageSubresource imageSubresource = default; + + public this(void* pNext, VkImageSubresource imageSubresource) : this() + { + this.pNext = pNext; + this.imageSubresource = imageSubresource; + } +} + +[CRepr] struct VkSubresourceLayout2 : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSubresourceLayout subresourceLayout = default; +} + +typealias VkBufferUsageFlags2 = VkFlags64; + +[AllowDuplicates] enum VkBufferUsageFlagBits2 : int32 +{ + [NoShow] VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT = 1 << 0, + [NoShow] VK_BUFFER_USAGE_2_TRANSFER_DST_BIT = 1 << 1, + [NoShow] VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT = 1 << 2, + [NoShow] VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT = 1 << 3, + [NoShow] VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT = 1 << 4, + [NoShow] VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT = 1 << 5, + [NoShow] VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT = 1 << 6, + [NoShow] VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT = 1 << 7, + [NoShow] VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT = 1 << 8, + [NoShow] VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT = 1 << 17, + [NoShow] VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 1 << 25, + [NoShow] VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT, + [NoShow] VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT, + [NoShow] VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT, + [NoShow] VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 1 << 9, + [NoShow] VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR = 1 << 10, + [NoShow] VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, + [NoShow] VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 1 << 11, + [NoShow] VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 1 << 12, + [NoShow] VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 1 << 13, + [NoShow] VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 1 << 14, + [NoShow] VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 1 << 15, + [NoShow] VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 1 << 16, + [NoShow] VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, + [NoShow] VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 1 << 19, + [NoShow] VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 1 << 20, + [NoShow] VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 21, + [NoShow] VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 22, + [NoShow] VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 26, + [NoShow] VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 1 << 23, + [NoShow] VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 1 << 24, + [NoShow] VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 1 << 33, + [NoShow] VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 1 << 29, + [NoShow] VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 1 << 27, + [NoShow] VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 1 << 32, + [NoShow] VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 1 << 31, + // pretty names + VkBufferUsage2_TransferSrc = 1 << 0, + VkBufferUsage2_TransferDst = 1 << 1, + VkBufferUsage2_UniformTexelBuffer = 1 << 2, + VkBufferUsage2_StorageTexelBuffer = 1 << 3, + VkBufferUsage2_UniformBuffer = 1 << 4, + VkBufferUsage2_StorageBuffer = 1 << 5, + VkBufferUsage2_IndexBuffer = 1 << 6, + VkBufferUsage2_VertexBuffer = 1 << 7, + VkBufferUsage2_IndirectBuffer = 1 << 8, + VkBufferUsage2_ShaderDeviceAddress = 1 << 17, + VkBufferUsage2_ExecutionGraphScratchAMDX = 1 << 25, + VkBufferUsage2_TransferSrcKHR = VkBufferUsage2_TransferSrc, + VkBufferUsage2_TransferDstKHR = VkBufferUsage2_TransferDst, + VkBufferUsage2_UniformTexelBufferKHR = VkBufferUsage2_UniformTexelBuffer, + VkBufferUsage2_StorageTexelBufferKHR = VkBufferUsage2_StorageTexelBuffer, + VkBufferUsage2_UniformBufferKHR = VkBufferUsage2_UniformBuffer, + VkBufferUsage2_StorageBufferKHR = VkBufferUsage2_StorageBuffer, + VkBufferUsage2_IndexBufferKHR = VkBufferUsage2_IndexBuffer, + VkBufferUsage2_VertexBufferKHR = VkBufferUsage2_VertexBuffer, + VkBufferUsage2_IndirectBufferKHR = VkBufferUsage2_IndirectBuffer, + VkBufferUsage2_ConditionalRenderingEXT = 1 << 9, + VkBufferUsage2_ShaderBindingTableKHR = 1 << 10, + VkBufferUsage2_RayTracingNV = VkBufferUsage2_ShaderBindingTableKHR, + VkBufferUsage2_TransformFeedbackBufferEXT = 1 << 11, + VkBufferUsage2_TransformFeedbackCounterBufferEXT = 1 << 12, + VkBufferUsage2_VideoDecodeSrcKHR = 1 << 13, + VkBufferUsage2_VideoDecodeDstKHR = 1 << 14, + VkBufferUsage2_VideoEncodeDstKHR = 1 << 15, + VkBufferUsage2_VideoEncodeSrcKHR = 1 << 16, + VkBufferUsage2_ShaderDeviceAddressKHR = VkBufferUsage2_ShaderDeviceAddress, + VkBufferUsage2_AccelerationStructureBuildInputReadOnlyKHR = 1 << 19, + VkBufferUsage2_AccelerationStructureStorageKHR = 1 << 20, + VkBufferUsage2_SamplerDescriptorBufferEXT = 1 << 21, + VkBufferUsage2_ResourceDescriptorBufferEXT = 1 << 22, + VkBufferUsage2_PushDescriptorsDescriptorBufferEXT = 1 << 26, + VkBufferUsage2_MicromapBuildInputReadOnlyEXT = 1 << 23, + VkBufferUsage2_MicromapStorageEXT = 1 << 24, + VkBufferUsage2_CompressedDataDgf1AMDX = 1 << 33, + VkBufferUsage2_DataGraphForeignDescriptorARM = 1 << 29, + VkBufferUsage2_TileMemoryQCOM = 1 << 27, + VkBufferUsage2_MemoryDecompressionEXT = 1 << 32, + VkBufferUsage2_PreprocessBufferEXT = 1 << 31, +} + +[CRepr] struct VkBufferUsageFlags2CreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferUsageFlags2 usage = default; + + public this(void* pNext, VkBufferUsageFlags2 usage) : this() + { + this.pNext = pNext; + this.usage = usage; + } +} + +// Promoted from VK_KHR_maintenance6 (extension 546) 'additional functionality' +[CRepr] struct VkPhysicalDeviceMaintenance6Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance6 = false; + + public this(void* pNext, VkBool32 maintenance6) : this() + { + this.pNext = pNext; + this.maintenance6 = maintenance6; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance6Properties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 blockTexelViewCompatibleMultipleLayers = false; + public uint32 maxCombinedImageSamplerDescriptorCount = 0; + public VkBool32 fragmentShadingRateClampCombinerInputs = false; +} + +[CRepr] struct VkBindMemoryStatus : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkResult* pResult = null; + + public this(void* pNext, VkResult* pResult) : this() + { + this.pNext = pNext; + this.pResult = pResult; + } +} + +// Promoted (as optional feature) from VK_EXT_host_image_copy (extension 271) 'streaming transfers' +[CRepr] struct VkPhysicalDeviceHostImageCopyFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hostImageCopy = false; + + public this(void* pNext, VkBool32 hostImageCopy) : this() + { + this.pNext = pNext; + this.hostImageCopy = hostImageCopy; + } +} + +[CRepr] struct VkPhysicalDeviceHostImageCopyProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 copySrcLayoutCount = 0; + public VkImageLayout* pCopySrcLayouts = null; + public Span copySrcLayouts + { + get { return .(pCopySrcLayouts, (.)copySrcLayoutCount); } + set mut { pCopySrcLayouts = value.Ptr; copySrcLayoutCount = (.)value.Length; } + } + public uint32 copyDstLayoutCount = 0; + public VkImageLayout* pCopyDstLayouts = null; + public Span copyDstLayouts + { + get { return .(pCopyDstLayouts, (.)copyDstLayoutCount); } + set mut { pCopyDstLayouts = value.Ptr; copyDstLayoutCount = (.)value.Length; } + } + public uint8[VK_UUID_SIZE] optimalTilingLayoutUUID = .(); + public VkBool32 identicalMemoryTypeRequirements = false; + + public this(void* pNext, Span copySrcLayouts, Span copyDstLayouts, uint8[VK_UUID_SIZE] optimalTilingLayoutUUID, VkBool32 identicalMemoryTypeRequirements) : this() + { + this.pNext = pNext; + this.copySrcLayouts = copySrcLayouts; + this.copyDstLayouts = copyDstLayouts; + this.optimalTilingLayoutUUID = optimalTilingLayoutUUID; + this.identicalMemoryTypeRequirements = identicalMemoryTypeRequirements; + } +} + +[AllowDuplicates] enum VkHostImageCopyFlagBits : int32 +{ + [NoShow] VK_HOST_IMAGE_COPY_MEMCPY_BIT = 1 << 0, + [NoShow] VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + [NoShow] VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + [NoShow] VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + // pretty names + Memcpy = 1 << 0, + MemcpyEXT = Memcpy, +} + +typealias VkHostImageCopyFlags = VkHostImageCopyFlagBits; + +[CRepr] struct VkMemoryToImageCopy : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; + public VkStructureType sType = SType; + public void* pNext = null; + public void* pHostPointer = null; + public uint32 memoryRowLength = 0; // Specified in texels + public uint32 memoryImageHeight = 0; + public VkImageSubresourceLayers imageSubresource = default; + public VkOffset3D imageOffset = default; + public VkExtent3D imageExtent = default; + + public this(void* pNext, void* pHostPointer, uint32 memoryRowLength, uint32 memoryImageHeight, VkImageSubresourceLayers imageSubresource, VkOffset3D imageOffset, VkExtent3D imageExtent) : this() + { + this.pNext = pNext; + this.pHostPointer = pHostPointer; + this.memoryRowLength = memoryRowLength; + this.memoryImageHeight = memoryImageHeight; + this.imageSubresource = imageSubresource; + this.imageOffset = imageOffset; + this.imageExtent = imageExtent; + } +} + +[CRepr] struct VkImageToMemoryCopy : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; + public VkStructureType sType = SType; + public void* pNext = null; + public void* pHostPointer = null; + public uint32 memoryRowLength = 0; // Specified in texels + public uint32 memoryImageHeight = 0; + public VkImageSubresourceLayers imageSubresource = default; + public VkOffset3D imageOffset = default; + public VkExtent3D imageExtent = default; + + public this(void* pNext, void* pHostPointer, uint32 memoryRowLength, uint32 memoryImageHeight, VkImageSubresourceLayers imageSubresource, VkOffset3D imageOffset, VkExtent3D imageExtent) : this() + { + this.pNext = pNext; + this.pHostPointer = pHostPointer; + this.memoryRowLength = memoryRowLength; + this.memoryImageHeight = memoryImageHeight; + this.imageSubresource = imageSubresource; + this.imageOffset = imageOffset; + this.imageExtent = imageExtent; + } +} + +[CRepr] struct VkCopyMemoryToImageInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkHostImageCopyFlags flags = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkMemoryToImageCopy* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkHostImageCopyFlags flags, VkImage dstImage, VkImageLayout dstImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkCopyImageToMemoryInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkHostImageCopyFlags flags = default; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public uint32 regionCount = 0; + public VkImageToMemoryCopy* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkHostImageCopyFlags flags, VkImage srcImage, VkImageLayout srcImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.flags = flags; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkCopyImageToImageInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkHostImageCopyFlags flags = default; + public VkImage srcImage = null; + public VkImageLayout srcImageLayout = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public uint32 regionCount = 0; + public VkImageCopy2* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkHostImageCopyFlags flags, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, Span regions) : this() + { + this.pNext = pNext; + this.flags = flags; + this.srcImage = srcImage; + this.srcImageLayout = srcImageLayout; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.regions = regions; + } +} + +[CRepr] struct VkHostImageLayoutTransitionInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + public VkImageLayout oldLayout = default; + public VkImageLayout newLayout = default; + public VkImageSubresourceRange subresourceRange = default; + + public this(void* pNext, VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageSubresourceRange subresourceRange) : this() + { + this.pNext = pNext; + this.image = image; + this.oldLayout = oldLayout; + this.newLayout = newLayout; + this.subresourceRange = subresourceRange; + } +} + +[CRepr] struct VkSubresourceHostMemcpySize : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize size = default; // Specified in bytes +} + +[CRepr] struct VkHostImageCopyDevicePerformanceQuery : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 optimalDeviceAccess = false; // Specifies if device access is optimal + public VkBool32 identicalMemoryLayout = false; // Specifies if memory layout is identical +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyMemoryToImage(VkDevice device, VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyImageToMemory(VkDevice device, VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCopyImageToImage(VkDevice device, VkCopyImageToImageInfo* pCopyImageToImageInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkTransitionImageLayout(VkDevice device, uint32 transitionCount, VkHostImageLayoutTransitionInfo* pTransitions); + +// Vulkan compute 1.4 API interface definitions. +// Promoted from VK_KHR_shader_subgroup_rotate (extension 417) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceShaderSubgroupRotateFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderSubgroupRotate = false; + public VkBool32 shaderSubgroupRotateClustered = false; + + public this(void* pNext, VkBool32 shaderSubgroupRotate, VkBool32 shaderSubgroupRotateClustered) : this() + { + this.pNext = pNext; + this.shaderSubgroupRotate = shaderSubgroupRotate; + this.shaderSubgroupRotateClustered = shaderSubgroupRotateClustered; + } +} + +// Promoted from VK_KHR_shader_float_controls2 (extension 529) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceShaderFloatControls2Features : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderFloatControls2 = false; + + public this(void* pNext, VkBool32 shaderFloatControls2) : this() + { + this.pNext = pNext; + this.shaderFloatControls2 = shaderFloatControls2; + } +} + +// Promoted from VK_KHR_shader_expect_assume (extension 545) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceShaderExpectAssumeFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderExpectAssume = false; + + public this(void* pNext, VkBool32 shaderExpectAssume) : this() + { + this.pNext = pNext; + this.shaderExpectAssume = shaderExpectAssume; + } +} + +// Promoted from VK_KHR_maintenance5 (extension 471) 'Roadmap 2024' +typealias VkPipelineCreateFlags2 = VkFlags64; + +[AllowDuplicates] enum VkPipelineCreateFlagBits2 : int32 +{ + [NoShow] VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 1 << 0, + [NoShow] VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 1 << 1, + [NoShow] VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 1 << 2, + [NoShow] VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 1 << 3, + [NoShow] VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 1 << 4, + [NoShow] VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 1 << 8, + [NoShow] VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 1 << 9, + [NoShow] VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 1 << 27, + [NoShow] VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 1 << 30, + [NoShow] VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 1 << 32, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 1 << 33, + [NoShow] VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 1 << 34, + [NoShow] VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT, + [NoShow] VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT, + [NoShow] VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT, + [NoShow] VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + [NoShow] VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT, + [NoShow] VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 1 << 5, + [NoShow] VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 1 << 6, + [NoShow] VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 1 << 7, + [NoShow] VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + [NoShow] VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT, + [NoShow] VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 1 << 10, + [NoShow] VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 1 << 23, + [NoShow] VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 1 << 11, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 1 << 12, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 1 << 13, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 1 << 14, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 1 << 15, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 1 << 16, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 1 << 17, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 1 << 19, + [NoShow] VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 1 << 18, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 1 << 20, + [NoShow] VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1 << 21, + [NoShow] VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 1 << 22, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 1 << 24, + [NoShow] VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1 << 25, + [NoShow] VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1 << 26, + [NoShow] VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT, + [NoShow] VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT, + [NoShow] VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 1 << 28, + [NoShow] VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 1 << 29, + [NoShow] VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 1 << 37, + [NoShow] VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 1 << 31, + [NoShow] VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 1 << 38, + [NoShow] VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 1 << 40, + [NoShow] VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 1 << 43, + // pretty names + VkPipelineCreate2_DisableOptimization = 1 << 0, + VkPipelineCreate2_AllowDerivatives = 1 << 1, + VkPipelineCreate2_Derivative = 1 << 2, + VkPipelineCreate2_ViewIndexFromDeviceIndex = 1 << 3, + VkPipelineCreate2_DispatchBase = 1 << 4, + VkPipelineCreate2_FailOnPipelineCompileRequired = 1 << 8, + VkPipelineCreate2_EarlyReturnOnFailure = 1 << 9, + VkPipelineCreate2_NoProtectedAccess = 1 << 27, + VkPipelineCreate2_ProtectedAccessOnly = 1 << 30, + VkPipelineCreate2_ExecutionGraphAMDX = 1 << 32, + VkPipelineCreate2_RayTracingSkipBuiltInPrimitivesKHR = VkPipelineCreate2_RayTracingSkipTrianglesKHR, + VkPipelineCreate2_RayTracingAllowSpheresAndLinearSweptSpheresNV = 1 << 33, + VkPipelineCreate2_EnableLegacyDitheringEXT = 1 << 34, + VkPipelineCreate2_DisableOptimizationKHR = VkPipelineCreate2_DisableOptimization, + VkPipelineCreate2_AllowDerivativesKHR = VkPipelineCreate2_AllowDerivatives, + VkPipelineCreate2_DerivativeKHR = VkPipelineCreate2_Derivative, + VkPipelineCreate2_ViewIndexFromDeviceIndexKHR = VkPipelineCreate2_ViewIndexFromDeviceIndex, + VkPipelineCreate2_DispatchBaseKHR = VkPipelineCreate2_DispatchBase, + VkPipelineCreate2_DeferCompileNV = 1 << 5, + VkPipelineCreate2_CaptureStatisticsKHR = 1 << 6, + VkPipelineCreate2_CaptureInternalRepresentationsKHR = 1 << 7, + VkPipelineCreate2_FailOnPipelineCompileRequiredKHR = VkPipelineCreate2_FailOnPipelineCompileRequired, + VkPipelineCreate2_EarlyReturnOnFailureKHR = VkPipelineCreate2_EarlyReturnOnFailure, + VkPipelineCreate2_LinkTimeOptimizationEXT = 1 << 10, + VkPipelineCreate2_RetainLinkTimeOptimizationInfoEXT = 1 << 23, + VkPipelineCreate2_LibraryKHR = 1 << 11, + VkPipelineCreate2_RayTracingSkipTrianglesKHR = 1 << 12, + VkPipelineCreate2_RayTracingSkipAabbsKHR = 1 << 13, + VkPipelineCreate2_RayTracingNoNullAnyHitShadersKHR = 1 << 14, + VkPipelineCreate2_RayTracingNoNullClosestHitShadersKHR = 1 << 15, + VkPipelineCreate2_RayTracingNoNullMissShadersKHR = 1 << 16, + VkPipelineCreate2_RayTracingNoNullIntersectionShadersKHR = 1 << 17, + VkPipelineCreate2_RayTracingShaderGroupHandleCaptureReplayKHR = 1 << 19, + VkPipelineCreate2_IndirectBindableNV = 1 << 18, + VkPipelineCreate2_RayTracingAllowMotionNV = 1 << 20, + VkPipelineCreate2_RenderingFragmentShadingRateAttachmentKHR = 1 << 21, + VkPipelineCreate2_RenderingFragmentDensityMapAttachmentEXT = 1 << 22, + VkPipelineCreate2_RayTracingOpacityMicromapEXT = 1 << 24, + VkPipelineCreate2_ColorAttachmentFeedbackLoopEXT = 1 << 25, + VkPipelineCreate2_DepthStencilAttachmentFeedbackLoopEXT = 1 << 26, + VkPipelineCreate2_NoProtectedAccessEXT = VkPipelineCreate2_NoProtectedAccess, + VkPipelineCreate2_ProtectedAccessOnlyEXT = VkPipelineCreate2_ProtectedAccessOnly, + VkPipelineCreate2_RayTracingDisplacementMicromapNV = 1 << 28, + VkPipelineCreate2_DescriptorBufferEXT = 1 << 29, + VkPipelineCreate2_DisallowOpacityMicromapARM = 1 << 37, + VkPipelineCreate2_CaptureDataKHR = 1 << 31, + VkPipelineCreate2_IndirectBindableEXT = 1 << 38, + VkPipelineCreate2_PerLayerFragmentDensityVALVE = 1 << 40, + VkPipelineCreate2_64_BitIndexingEXT = 1 << 43, +} + +[CRepr] struct VkPipelineCreateFlags2CreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags2 flags = default; + + public this(void* pNext = null, VkPipelineCreateFlags2 flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +// Promoted as an interaction between VK_KHR_maintenance5 (extension 471) 'Roadmap 2024' and VK_EXT_pipeline_protected_access (extension 467) 'additional functionality' +// Promoted from VK_KHR_push_descriptor (extension 81) 'Roadmap 2024' +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32 set, uint32 descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites); + +[CRepr] struct VkPhysicalDevicePushDescriptorProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxPushDescriptors = 0; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32 set, void* pData); + +// Promoted from VK_KHR_maintenance6 (extension 546) 'additional functionality' +[CRepr] struct VkBindDescriptorSetsInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags stageFlags = default; + public VkPipelineLayout layout = null; + public uint32 firstSet = 0; + public uint32 descriptorSetCount = 0; + public VkDescriptorSet* pDescriptorSets = null; + public Span descriptorSets + { + get { return .(pDescriptorSets, (.)descriptorSetCount); } + set mut { pDescriptorSets = value.Ptr; descriptorSetCount = (.)value.Length; } + } + public uint32 dynamicOffsetCount = 0; + public uint32* pDynamicOffsets = null; + public Span dynamicOffsets + { + get { return .(pDynamicOffsets, (.)dynamicOffsetCount); } + set mut { pDynamicOffsets = value.Ptr; dynamicOffsetCount = (.)value.Length; } + } + + public this(void* pNext, VkShaderStageFlags stageFlags, VkPipelineLayout layout, uint32 firstSet, Span descriptorSets, Span dynamicOffsets = default) : this() + { + this.pNext = pNext; + this.stageFlags = stageFlags; + this.layout = layout; + this.firstSet = firstSet; + this.descriptorSets = descriptorSets; + this.dynamicOffsets = dynamicOffsets; + } +} + +[CRepr] struct VkPushConstantsInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineLayout layout = null; + public VkShaderStageFlags stageFlags = default; + public uint32 offset = 0; + public uint32 size = 0; + public void* pValues = null; + public Span values + { + get { return .(pValues, (.)size); } + set mut { pValues = value.Ptr; size = (.)value.Length; } + } + + public this(void* pNext, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32 offset, Span values) : this() + { + this.pNext = pNext; + this.layout = layout; + this.stageFlags = stageFlags; + this.offset = offset; + this.values = values; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushConstants2(VkCommandBuffer commandBuffer, VkPushConstantsInfo* pPushConstantsInfo); + +[CRepr] struct VkPushDescriptorSetInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags stageFlags = default; + public VkPipelineLayout layout = null; + public uint32 set = 0; + public uint32 descriptorWriteCount = 0; + public VkWriteDescriptorSet* pDescriptorWrites = null; + public Span descriptorWrites + { + get { return .(pDescriptorWrites, (.)descriptorWriteCount); } + set mut { pDescriptorWrites = value.Ptr; descriptorWriteCount = (.)value.Length; } + } + + public this(void* pNext, VkShaderStageFlags stageFlags, VkPipelineLayout layout, uint32 set, Span descriptorWrites) : this() + { + this.pNext = pNext; + this.stageFlags = stageFlags; + this.layout = layout; + this.set = set; + this.descriptorWrites = descriptorWrites; + } +} + +[CRepr] struct VkPushDescriptorSetWithTemplateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorUpdateTemplate descriptorUpdateTemplate = null; + public VkPipelineLayout layout = null; + public uint32 set = 0; + public void* pData = null; + + public this(void* pNext, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32 set, void* pData) : this() + { + this.pNext = pNext; + this.descriptorUpdateTemplate = descriptorUpdateTemplate; + this.layout = layout; + this.set = set; + this.pData = pData; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); + +// Promoted from VK_EXT_pipeline_protected_access (extension 467) 'additional functionality' +[CRepr] struct VkPhysicalDevicePipelineProtectedAccessFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineProtectedAccess = false; + + public this(void* pNext, VkBool32 pipelineProtectedAccess) : this() + { + this.pNext = pNext; + this.pipelineProtectedAccess = pipelineProtectedAccess; + } +} + +// Promoted from VK_EXT_pipeline_robustness (extension 69) 'additional functionality' +[CRepr] struct VkPhysicalDevicePipelineRobustnessFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineRobustness = false; + + public this(void* pNext, VkBool32 pipelineRobustness) : this() + { + this.pNext = pNext; + this.pipelineRobustness = pipelineRobustness; + } +} + +[CRepr] struct VkPhysicalDevicePipelineRobustnessProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = default; + public VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = default; + public VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = default; + public VkPipelineRobustnessImageBehavior defaultRobustnessImages = default; +} + +[CRepr] struct VkPipelineRobustnessCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRobustnessBufferBehavior storageBuffers = default; + public VkPipelineRobustnessBufferBehavior uniformBuffers = default; + public VkPipelineRobustnessBufferBehavior vertexInputs = default; + public VkPipelineRobustnessImageBehavior images = default; + + public this(void* pNext, VkPipelineRobustnessBufferBehavior storageBuffers, VkPipelineRobustnessBufferBehavior uniformBuffers, VkPipelineRobustnessBufferBehavior vertexInputs, VkPipelineRobustnessImageBehavior images) : this() + { + this.pNext = pNext; + this.storageBuffers = storageBuffers; + this.uniformBuffers = uniformBuffers; + this.vertexInputs = vertexInputs; + this.images = images; + } +} + +[AllowDuplicates] enum VkPipelineRobustnessBufferBehavior : int32 +{ + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT = 0, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED = 1, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS = 2, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 = 3, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, + [NoShow] VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, + // pretty names + DeviceDefault = 0, + Disabled = 1, + RobustBufferAccess = 2, + RobustBufferAccess2 = 3, + DeviceDefaultEXT = DeviceDefault, + DisabledEXT = Disabled, + RobustBufferAccessEXT = RobustBufferAccess, + RobustBufferAccess2EXT = RobustBufferAccess2, +} + +[AllowDuplicates] enum VkPipelineRobustnessImageBehavior : int32 +{ + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT = 0, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED = 1, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS = 2, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 = 3, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, + [NoShow] VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, + // pretty names + DeviceDefault = 0, + Disabled = 1, + RobustImageAccess = 2, + RobustImageAccess2 = 3, + DeviceDefaultEXT = DeviceDefault, + DisabledEXT = Disabled, + RobustImageAccessEXT = RobustImageAccess, + RobustImageAccess2EXT = RobustImageAccess2, +} + +// Vulkan graphics 1.4 API interface definitions. +// Promoted from VK_KHR_load_store_op_none (extension 527) 'Roadmap 2024' (VK_ATTACHMENT_STORE_OP_NONE is defined in Vulkan 1.3) +// Promoted from VK_KHR_line_rasterization (extension 535) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceLineRasterizationFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rectangularLines = false; + public VkBool32 bresenhamLines = false; + public VkBool32 smoothLines = false; + public VkBool32 stippledRectangularLines = false; + public VkBool32 stippledBresenhamLines = false; + public VkBool32 stippledSmoothLines = false; + + public this(void* pNext, VkBool32 rectangularLines, VkBool32 bresenhamLines, VkBool32 smoothLines, VkBool32 stippledRectangularLines, VkBool32 stippledBresenhamLines, VkBool32 stippledSmoothLines) : this() + { + this.pNext = pNext; + this.rectangularLines = rectangularLines; + this.bresenhamLines = bresenhamLines; + this.smoothLines = smoothLines; + this.stippledRectangularLines = stippledRectangularLines; + this.stippledBresenhamLines = stippledBresenhamLines; + this.stippledSmoothLines = stippledSmoothLines; + } +} + +[CRepr] struct VkPhysicalDeviceLineRasterizationProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 lineSubPixelPrecisionBits = 0; +} + +[CRepr] struct VkPipelineRasterizationLineStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public VkLineRasterizationMode lineRasterizationMode = default; + public VkBool32 stippledLineEnable = false; + public uint32 lineStippleFactor = 0; + public uint16 lineStipplePattern = 0; + + public this(void* pNext, VkLineRasterizationMode lineRasterizationMode, VkBool32 stippledLineEnable, uint32 lineStippleFactor, uint16 lineStipplePattern) : this() + { + this.pNext = pNext; + this.lineRasterizationMode = lineRasterizationMode; + this.stippledLineEnable = stippledLineEnable; + this.lineStippleFactor = lineStippleFactor; + this.lineStipplePattern = lineStipplePattern; + } +} + +[AllowDuplicates] enum VkLineRasterizationMode : int32 +{ + [NoShow] VK_LINE_RASTERIZATION_MODE_DEFAULT = 0, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1, + [NoShow] VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3, + [NoShow] VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + [NoShow] VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + [NoShow] VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = VK_LINE_RASTERIZATION_MODE_DEFAULT, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + [NoShow] VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + [NoShow] VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + // pretty names + Default = 0, + Rectangular = 1, + Bresenham = 2, + RectangularSmooth = 3, + DefaultEXT = Default, + RectangularEXT = Rectangular, + BresenhamEXT = Bresenham, + RectangularSmoothEXT = RectangularSmooth, + DefaultKHR = Default, + RectangularKHR = Rectangular, + BresenhamKHR = Bresenham, + RectangularSmoothKHR = RectangularSmooth, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32 lineStippleFactor, uint16 lineStipplePattern); + +// Promoted from VK_KHR_vertex_attribute_divisor (extension 526) 'Roadmap 2024' +[CRepr] struct VkPhysicalDeviceVertexAttributeDivisorProperties : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxVertexAttribDivisor = 0; // max value of vertex attribute divisor + public VkBool32 supportsNonZeroFirstInstance = false; +} + +[CRepr] struct VkVertexInputBindingDivisorDescription : this() +{ + public uint32 binding = 0; + public uint32 divisor = 0; + + public this(uint32 binding, uint32 divisor) : this() + { + this.binding = binding; + this.divisor = divisor; + } +} + +[CRepr] struct VkPipelineVertexInputDivisorStateCreateInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 vertexBindingDivisorCount = 0; + public VkVertexInputBindingDivisorDescription* pVertexBindingDivisors = null; + public Span vertexBindingDivisors + { + get { return .(pVertexBindingDivisors, (.)vertexBindingDivisorCount); } + set mut { pVertexBindingDivisors = value.Ptr; vertexBindingDivisorCount = (.)value.Length; } + } + + public this(void* pNext, Span vertexBindingDivisors) : this() + { + this.pNext = pNext; + this.vertexBindingDivisors = vertexBindingDivisors; + } +} + +[CRepr] struct VkPhysicalDeviceVertexAttributeDivisorFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 vertexAttributeInstanceRateDivisor = false; + public VkBool32 vertexAttributeInstanceRateZeroDivisor = false; + + public this(void* pNext, VkBool32 vertexAttributeInstanceRateDivisor, VkBool32 vertexAttributeInstanceRateZeroDivisor) : this() + { + this.pNext = pNext; + this.vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor; + this.vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor; + } +} + +// Promoted from VK_KHR_maintenance5 (extension 471) 'Roadmap 2024' +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetRenderingAreaGranularity(VkDevice device, VkRenderingAreaInfo* pRenderingAreaInfo, out VkExtent2D pGranularity); + +[CRepr] struct VkRenderingAreaInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 viewMask = 0; + public uint32 colorAttachmentCount = 0; + public VkFormat* pColorAttachmentFormats = null; + public Span colorAttachmentFormats + { + get { return .(pColorAttachmentFormats, (.)colorAttachmentCount); } + set mut { pColorAttachmentFormats = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkFormat depthAttachmentFormat = default; + public VkFormat stencilAttachmentFormat = default; + + public this(void* pNext, uint32 viewMask, Span colorAttachmentFormats, VkFormat depthAttachmentFormat, VkFormat stencilAttachmentFormat) : this() + { + this.pNext = pNext; + this.viewMask = viewMask; + this.colorAttachmentFormats = colorAttachmentFormats; + this.depthAttachmentFormat = depthAttachmentFormat; + this.stencilAttachmentFormat = stencilAttachmentFormat; + } +} + +// Promoted from VK_KHR_dynamic_rendering_local_read (extension 233) 'Roadmap 2024' +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, VkRenderingAttachmentLocationInfo* pLocationInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); + +[CRepr] struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dynamicRenderingLocalRead = false; + + public this(void* pNext, VkBool32 dynamicRenderingLocalRead) : this() + { + this.pNext = pNext; + this.dynamicRenderingLocalRead = dynamicRenderingLocalRead; + } +} + +[CRepr] struct VkRenderingAttachmentLocationInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 colorAttachmentCount = 0; + public uint32* pColorAttachmentLocations = null; + public Span colorAttachmentLocations + { + get { return .(pColorAttachmentLocations, (.)colorAttachmentCount); } + set mut { pColorAttachmentLocations = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + + public this(void* pNext = null, Span colorAttachmentLocations = default) : this() + { + this.pNext = pNext; + this.colorAttachmentLocations = colorAttachmentLocations; + } +} + +[CRepr] struct VkRenderingInputAttachmentIndexInfo : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 colorAttachmentCount = 0; + public uint32* pColorAttachmentInputIndices = null; + public Span colorAttachmentInputIndices + { + get { return .(pColorAttachmentInputIndices, (.)colorAttachmentCount); } + set mut { pColorAttachmentInputIndices = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public uint32* pDepthInputAttachmentIndex = null; + public uint32* pStencilInputAttachmentIndex = null; + + public this(void* pNext = null, Span colorAttachmentInputIndices = default, uint32* pDepthInputAttachmentIndex = null, uint32* pStencilInputAttachmentIndex = null) : this() + { + this.pNext = pNext; + this.colorAttachmentInputIndices = colorAttachmentInputIndices; + this.pDepthInputAttachmentIndex = pDepthInputAttachmentIndex; + this.pStencilInputAttachmentIndex = pStencilInputAttachmentIndex; + } +} + +// Vulkan 1.4 core API interface definitions +// Feature requirements +static { public const let VK_KHR_SURFACE_SPEC_VERSION = 25; } +static { public const let VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface"; } + +struct VkSurfaceKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SURFACE_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkSurfaceTransformFlagBitsKHR : int32 +{ + [NoShow] VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1 << 0, + [NoShow] VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 1 << 1, + [NoShow] VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 1 << 2, + [NoShow] VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 1 << 3, + [NoShow] VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 1 << 4, + [NoShow] VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 1 << 5, + [NoShow] VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 1 << 6, + [NoShow] VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 1 << 7, + [NoShow] VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 1 << 8, + // pretty names + IdentityKHR = 1 << 0, + Rotate90KHR = 1 << 1, + Rotate180KHR = 1 << 2, + Rotate270KHR = 1 << 3, + HorizontalMirrorKHR = 1 << 4, + HorizontalMirrorRotate90KHR = 1 << 5, + HorizontalMirrorRotate180KHR = 1 << 6, + HorizontalMirrorRotate270KHR = 1 << 7, + InheritKHR = 1 << 8, +} + +[AllowDuplicates] enum VkPresentModeKHR : int32 +{ + [NoShow] VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + [NoShow] VK_PRESENT_MODE_MAILBOX_KHR = 1, + [NoShow] VK_PRESENT_MODE_FIFO_KHR = 2, + [NoShow] VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + [NoShow] VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + [NoShow] VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + [NoShow] VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, + [NoShow] VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000, + // pretty names + ImmediateKHR = 0, + MailboxKHR = 1, + FifoKHR = 2, + FifoRelaxedKHR = 3, + SharedDemandRefreshKHR = 1000111000, + SharedContinuousRefreshKHR = 1000111001, + FifoLatestReadyEXT = FifoLatestReadyKHR, + FifoLatestReadyKHR = 1000361000, +} + +[AllowDuplicates] enum VkColorSpaceKHR : int32 +{ + [NoShow] VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + [NoShow] VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + [NoShow] VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + [NoShow] VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + [NoShow] VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + [NoShow] VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + [NoShow] VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + [NoShow] VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + [NoShow] VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + [NoShow] VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + [NoShow] VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + [NoShow] VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + [NoShow] VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + [NoShow] VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + [NoShow] VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + [NoShow] VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + [NoShow] VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + [NoShow] VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, + // pretty names + SrgbNonlinearKHR = 0, + VkColorspaceSrgbNonlinearKHR = SrgbNonlinearKHR, + DisplayP3_NonlinearEXT = 1000104001, + ExtendedSrgbLinearEXT = 1000104002, + DisplayP3_LinearEXT = 1000104003, + DciP3_NonlinearEXT = 1000104004, + Bt709_LinearEXT = 1000104005, + Bt709_NonlinearEXT = 1000104006, + Bt2020_LinearEXT = 1000104007, + Hdr10_St2084EXT = 1000104008, + DolbyvisionEXT = 1000104009, + Hdr10_HlgEXT = 1000104010, + AdobergbLinearEXT = 1000104011, + AdobergbNonlinearEXT = 1000104012, + PassThroughEXT = 1000104013, + ExtendedSrgbNonlinearEXT = 1000104014, + DciP3_LinearEXT = DisplayP3_LinearEXT, + DisplayNativeAMD = 1000213000, +} + +[AllowDuplicates] enum VkCompositeAlphaFlagBitsKHR : int32 +{ + [NoShow] VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1 << 0, + [NoShow] VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 1 << 1, + [NoShow] VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 1 << 2, + [NoShow] VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 1 << 3, + // pretty names + OpaqueKHR = 1 << 0, + PreMultipliedKHR = 1 << 1, + PostMultipliedKHR = 1 << 2, + InheritKHR = 1 << 3, +} + +typealias VkCompositeAlphaFlagsKHR = VkCompositeAlphaFlagBitsKHR; + +[CRepr] struct VkSurfaceCapabilitiesKHR : this() +{ + public uint32 minImageCount = 0; // Supported minimum number of images for the surface + public uint32 maxImageCount = 0; // Supported maximum number of images for the surface, 0 for unlimited + public VkExtent2D currentExtent = default; // Current image width and height for the surface, (0, 0) if undefined + public VkExtent2D minImageExtent = default; // Supported minimum image width and height for the surface + public VkExtent2D maxImageExtent = default; // Supported maximum image width and height for the surface + public uint32 maxImageArrayLayers = 0; // Supported maximum number of image layers for the surface + public VkSurfaceTransformFlagsKHR supportedTransforms = default; // 1 or more bits representing the transforms supported + public VkSurfaceTransformFlagBitsKHR currentTransform = default; // The surface's current transform relative to the device's natural orientation + public VkCompositeAlphaFlagsKHR supportedCompositeAlpha = default; // 1 or more bits representing the alpha compositing modes supported + public VkImageUsageFlags supportedUsageFlags = default; // Supported image usage flags for the surface +} + +[CRepr] struct VkSurfaceFormatKHR : this() +{ + public VkFormat format = default; // Supported pair of rendering format + public VkColorSpaceKHR colorSpace = default; // and color space for the surface +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, VkSurfaceKHR surface, out VkBool32 pSupported); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out VkSurfaceCapabilitiesKHR pSurfaceCapabilities); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pPresentModeCount, VkPresentModeKHR* pPresentModes = null); + +static { public const let VK_KHR_SWAPCHAIN_SPEC_VERSION = 70; } +static { public const let VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain"; } + +[AllowDuplicates] enum VkSwapchainCreateFlagBitsKHR : int32 +{ + [NoShow] VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 1 << 0, // Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT + [NoShow] VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 1 << 1, // Swapchain is protected + [NoShow] VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 1 << 2, + [NoShow] VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 1 << 9, + [NoShow] VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, + [NoShow] VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 1 << 6, // Allow use of VK_KHR_present_id2 with this swapchain + [NoShow] VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 1 << 7, // Allow use of VK_KHR_present_wait2 with this swapchain + [NoShow] VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 1 << 3, + // pretty names + SplitInstanceBindRegionsKHR = 1 << 0, // Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT + ProtectedKHR = 1 << 1, // Swapchain is protected + MutableFormatKHR = 1 << 2, + PresentTimingEXT = 1 << 9, + DeferredMemoryAllocationEXT = DeferredMemoryAllocationKHR, + PresentId2KHR = 1 << 6, // Allow use of VK_KHR_present_id2 with this swapchain + PresentWait2KHR = 1 << 7, // Allow use of VK_KHR_present_wait2 with this swapchain + DeferredMemoryAllocationKHR = 1 << 3, +} + +typealias VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagBitsKHR; + +[CRepr] struct VkSwapchainCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainCreateFlagsKHR flags = default; + public VkSurfaceKHR surface = null; // The swapchain's target surface + public uint32 minImageCount = 0; // Minimum number of presentation images the application needs + public VkFormat imageFormat = default; // Format of the presentation images + public VkColorSpaceKHR imageColorSpace = default; // Colorspace of the presentation images + public VkExtent2D imageExtent = default; // Dimensions of the presentation images + public uint32 imageArrayLayers = 0; // Determines the number of views for multiview/stereo presentation + public VkImageUsageFlags imageUsage = default; // Bits indicating how the presentation images will be used + public VkSharingMode imageSharingMode = default; // Sharing mode used for the presentation images + public uint32 queueFamilyIndexCount = 0; // Number of queue families having access to the images in case of concurrent sharing mode + public uint32* pQueueFamilyIndices = null; // Array of queue family indices having access to the images in case of concurrent sharing mode + public Span queueFamilyIndices + { + get { return .(pQueueFamilyIndices, (.)queueFamilyIndexCount); } + set mut { pQueueFamilyIndices = value.Ptr; queueFamilyIndexCount = (.)value.Length; } + } + public VkSurfaceTransformFlagBitsKHR preTransform = default; // The transform, relative to the device's natural orientation, applied to the image content prior to presentation + public VkCompositeAlphaFlagBitsKHR compositeAlpha = default; // The alpha blending mode used when compositing this surface with other surfaces in the window system + public VkPresentModeKHR presentMode = default; // Which presentation mode to use for presents on this swap chain + public VkBool32 clipped = false; // Specifies whether presentable images may be affected by window clip regions + public VkSwapchainKHR oldSwapchain = null; // Existing swap chain to replace, if any + + public this(void* pNext, VkSwapchainCreateFlagsKHR flags, VkSurfaceKHR surface, uint32 minImageCount, VkFormat imageFormat, VkColorSpaceKHR imageColorSpace, VkExtent2D imageExtent, uint32 imageArrayLayers, VkImageUsageFlags imageUsage, VkSharingMode imageSharingMode, Span queueFamilyIndices, VkSurfaceTransformFlagBitsKHR preTransform, VkCompositeAlphaFlagBitsKHR compositeAlpha, VkPresentModeKHR presentMode, VkBool32 clipped, VkSwapchainKHR oldSwapchain = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.surface = surface; + this.minImageCount = minImageCount; + this.imageFormat = imageFormat; + this.imageColorSpace = imageColorSpace; + this.imageExtent = imageExtent; + this.imageArrayLayers = imageArrayLayers; + this.imageUsage = imageUsage; + this.imageSharingMode = imageSharingMode; + this.queueFamilyIndices = queueFamilyIndices; + this.preTransform = preTransform; + this.compositeAlpha = compositeAlpha; + this.presentMode = presentMode; + this.clipped = clipped; + this.oldSwapchain = oldSwapchain; + } +} + +struct VkSwapchainKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SWAPCHAIN_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkPresentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreCount = 0; // Number of semaphores to wait for before presenting + public VkSemaphore* pWaitSemaphores = null; // Semaphores to wait for before presenting + public Span waitSemaphores + { + get { return .(pWaitSemaphores, (.)waitSemaphoreCount); } + set mut { pWaitSemaphores = value.Ptr; waitSemaphoreCount = (.)value.Length; } + } + public uint32 swapchainCount = 0; // Number of swapchains to present in this call + public VkSwapchainKHR* pSwapchains = null; // Swapchains to present an image from + public uint32* pImageIndices = null; // Indices of which presentable images to present + public VkResult* pResults = null; // Optional (i.e. if non-NULL) VkResult for each swapchain + + public this(void* pNext, Span waitSemaphores, uint32 swapchainCount, VkSwapchainKHR* pSwapchains, uint32* pImageIndices, VkResult* pResults = null) : this() + { + this.pNext = pNext; + this.waitSemaphores = waitSemaphores; + this.swapchainCount = swapchainCount; + this.pSwapchains = pSwapchains; + this.pImageIndices = pImageIndices; + this.pResults = pResults; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSwapchainKHR(VkDevice device, VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSwapchainKHR pSwapchain); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, out uint32 pSwapchainImageCount, VkImage* pSwapchainImages = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64 timeout, VkSemaphore semaphore, VkFence fence, out uint32 pImageIndex); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo); + +[CRepr] struct VkImageSwapchainCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainKHR swapchain = null; + + public this(void* pNext = null, VkSwapchainKHR swapchain = null) : this() + { + this.pNext = pNext; + this.swapchain = swapchain; + } +} + +[CRepr] struct VkBindImageMemorySwapchainInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainKHR swapchain = null; + public uint32 imageIndex = 0; + + public this(void* pNext, VkSwapchainKHR swapchain, uint32 imageIndex) : this() + { + this.pNext = pNext; + this.swapchain = swapchain; + this.imageIndex = imageIndex; + } +} + +[CRepr] struct VkAcquireNextImageInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainKHR swapchain = null; + public uint64 timeout = 0; + public VkSemaphore semaphore = null; + public VkFence fence = null; + public uint32 deviceMask = 0; + + public this(void* pNext, VkSwapchainKHR swapchain, uint64 timeout, VkSemaphore semaphore, VkFence fence, uint32 deviceMask) : this() + { + this.pNext = pNext; + this.swapchain = swapchain; + this.timeout = timeout; + this.semaphore = semaphore; + this.fence = fence; + this.deviceMask = deviceMask; + } +} + +[AllowDuplicates] enum VkDeviceGroupPresentModeFlagBitsKHR : int32 +{ + [NoShow] VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 1 << 0, // Present from local memory + [NoShow] VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 1 << 1, // Present from remote memory + [NoShow] VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 1 << 2, // Present sum of local and/or remote memory + [NoShow] VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 1 << 3, // Each physical device presents from local memory + // pretty names + LocalKHR = 1 << 0, // Present from local memory + RemoteKHR = 1 << 1, // Present from remote memory + SumKHR = 1 << 2, // Present sum of local and/or remote memory + LocalMultiDeviceKHR = 1 << 3, // Each physical device presents from local memory +} + +typealias VkDeviceGroupPresentModeFlagsKHR = VkDeviceGroupPresentModeFlagBitsKHR; + +[CRepr] struct VkDeviceGroupPresentCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32[VK_MAX_DEVICE_GROUP_SIZE] presentMask = .(); + public VkDeviceGroupPresentModeFlagsKHR modes = default; +} + +[CRepr] struct VkDeviceGroupPresentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; + public uint32* pDeviceMasks = null; + public Span deviceMasks + { + get { return .(pDeviceMasks, (.)swapchainCount); } + set mut { pDeviceMasks = value.Ptr; swapchainCount = (.)value.Length; } + } + public VkDeviceGroupPresentModeFlagBitsKHR mode = default; + + public this(void* pNext, Span deviceMasks, VkDeviceGroupPresentModeFlagBitsKHR mode) : this() + { + this.pNext = pNext; + this.deviceMasks = deviceMasks; + this.mode = mode; + } +} + +[CRepr] struct VkDeviceGroupSwapchainCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceGroupPresentModeFlagsKHR modes = default; + + public this(void* pNext, VkDeviceGroupPresentModeFlagsKHR modes) : this() + { + this.pNext = pNext; + this.modes = modes; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, out VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, out VkDeviceGroupPresentModeFlagsKHR pModes); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint32 pRectCount, VkRect2D* pRects = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireNextImage2KHR(VkDevice device, VkAcquireNextImageInfoKHR* pAcquireInfo, out uint32 pImageIndex); + +static { public const let VK_KHR_DISPLAY_SPEC_VERSION = 23; } +static { public const let VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display"; } + +struct VkDisplayKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DISPLAY_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkDisplayModeCreateFlagsKHR = VkFlags; + +[CRepr] struct VkDisplayModeCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayModeCreateFlagsKHR flags = default; + public VkDisplayModeParametersKHR parameters = default; // The parameters this mode uses. + + public this(void* pNext, VkDisplayModeCreateFlagsKHR flags, VkDisplayModeParametersKHR parameters) : this() + { + this.pNext = pNext; + this.flags = flags; + this.parameters = parameters; + } +} + +struct VkDisplayModeKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DISPLAY_MODE_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkDisplayModeParametersKHR : this() +{ + public VkExtent2D visibleRegion = default; // Visible scanout region. + public uint32 refreshRate = 0; // Number of times per second the display is updated. + + public this(VkExtent2D visibleRegion, uint32 refreshRate) : this() + { + this.visibleRegion = visibleRegion; + this.refreshRate = refreshRate; + } +} + +[CRepr] struct VkDisplayModePropertiesKHR : this() +{ + public VkDisplayModeKHR displayMode = null; // Handle of this display mode. + public VkDisplayModeParametersKHR parameters = default; // The parameters this mode uses. +} + +[AllowDuplicates] enum VkDisplayPlaneAlphaFlagBitsKHR : int32 +{ + [NoShow] VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1 << 0, + [NoShow] VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 1 << 1, + [NoShow] VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 1 << 2, + [NoShow] VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 1 << 3, + // pretty names + OpaqueKHR = 1 << 0, + GlobalKHR = 1 << 1, + PerPixelKHR = 1 << 2, + PerPixelPremultipliedKHR = 1 << 3, +} + +typealias VkDisplayPlaneAlphaFlagsKHR = VkDisplayPlaneAlphaFlagBitsKHR; + +[CRepr] struct VkDisplayPlaneCapabilitiesKHR : this() +{ + public VkDisplayPlaneAlphaFlagsKHR supportedAlpha = default; // Types of alpha blending supported, if any. + public VkOffset2D minSrcPosition = default; // Does the plane have any position and extent restrictions? + public VkOffset2D maxSrcPosition = default; + public VkExtent2D minSrcExtent = default; + public VkExtent2D maxSrcExtent = default; + public VkOffset2D minDstPosition = default; + public VkOffset2D maxDstPosition = default; + public VkExtent2D minDstExtent = default; + public VkExtent2D maxDstExtent = default; +} + +[CRepr] struct VkDisplayPlanePropertiesKHR : this() +{ + public VkDisplayKHR currentDisplay = null; // Display the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. + public uint32 currentStackIndex = 0; // Current z-order of the plane. +} + +[CRepr] struct VkDisplayPropertiesKHR : this() +{ + public VkDisplayKHR display = null; // Handle of the display object + public char8* displayName = null; // Name of the display + public VkExtent2D physicalDimensions = default; // In millimeters? + public VkExtent2D physicalResolution = default; // Max resolution for CRT? + public VkSurfaceTransformFlagsKHR supportedTransforms = default; // one or more bits from VkSurfaceTransformFlagsKHR + public VkBool32 planeReorderPossible = false; // VK_TRUE if the overlay plane's z-order can be changed on this display. + public VkBool32 persistentContent = false; // VK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. +} + +typealias VkDisplaySurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkDisplaySurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplaySurfaceCreateFlagsKHR flags = default; + public VkDisplayModeKHR displayMode = null; // The mode to use when displaying this surface + public uint32 planeIndex = 0; // The plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. + public uint32 planeStackIndex = 0; // The z-order of the plane. + public VkSurfaceTransformFlagBitsKHR transform = default; // Transform to apply to the images as part of the scanout operation + public float globalAlpha = 0; // Global alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + public VkDisplayPlaneAlphaFlagBitsKHR alphaMode = default; // The type of alpha blending to use. Must be one of the bits from VkDisplayPlaneCapabilitiesKHR::supportedAlpha for this display plane + public VkExtent2D imageExtent = default; // size of the images to use with this surface + + public this(void* pNext, VkDisplaySurfaceCreateFlagsKHR flags, VkDisplayModeKHR displayMode, uint32 planeIndex, uint32 planeStackIndex, VkSurfaceTransformFlagBitsKHR transform, float globalAlpha, VkDisplayPlaneAlphaFlagBitsKHR alphaMode, VkExtent2D imageExtent) : this() + { + this.pNext = pNext; + this.flags = flags; + this.displayMode = displayMode; + this.planeIndex = planeIndex; + this.planeStackIndex = planeStackIndex; + this.transform = transform; + this.globalAlpha = globalAlpha; + this.alphaMode = alphaMode; + this.imageExtent = imageExtent; + } +} + +typealias VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagBitsKHR; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPropertiesKHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32 planeIndex, out uint32 pDisplayCount, VkDisplayKHR* pDisplays = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, out uint32 pPropertyCount, VkDisplayModePropertiesKHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDisplayModeKHR pMode); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32 planeIndex, out VkDisplayPlaneCapabilitiesKHR pCapabilities); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 10; } +static { public const let VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain"; } + +[CRepr] struct VkDisplayPresentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRect2D srcRect = default; // Rectangle within the presentable image to read pixel data from when presenting to the display. + public VkRect2D dstRect = default; // Rectangle within the current display mode's visible region to display srcRectangle in. + public VkBool32 persistent = false; // For smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. + + public this(void* pNext, VkRect2D srcRect, VkRect2D dstRect, VkBool32 persistent) : this() + { + this.pNext = pNext; + this.srcRect = srcRect; + this.dstRect = dstRect; + this.persistent = persistent; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSharedSwapchainsKHR(VkDevice device, uint32 swapchainCount, VkSwapchainCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkSwapchainKHR pSwapchains); + +static { public const let VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; } +static { public const let VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; } + +typealias VkXlibSurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkXlibSurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkXlibSurfaceCreateFlagsKHR flags = default; + public Display* dpy = null; + public Window window = default; + + public this(void* pNext, VkXlibSurfaceCreateFlagsKHR flags, Display* dpy, Window window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dpy = dpy; + this.window = window; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateXlibSurfaceKHR(VkInstance instance, VkXlibSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out Display dpy, VisualID visualID); + +static { public const let VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; } +static { public const let VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; } + +typealias VkXcbSurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkXcbSurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkXcbSurfaceCreateFlagsKHR flags = default; + public xcb_connection_t* connection = null; + public xcb_window_t window = default; + + public this(void* pNext, VkXcbSurfaceCreateFlagsKHR flags, xcb_connection_t* connection, xcb_window_t window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.connection = connection; + this.window = window; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateXcbSurfaceKHR(VkInstance instance, VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out xcb_connection_t connection, xcb_visualid_t visual_id); + +static { public const let VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6; } +static { public const let VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; } + +typealias VkWaylandSurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkWaylandSurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkWaylandSurfaceCreateFlagsKHR flags = default; + public wl_display* display = null; + public wl_surface* surface = null; + + public this(void* pNext, VkWaylandSurfaceCreateFlagsKHR flags, wl_display* display, wl_surface* surface) : this() + { + this.pNext = pNext; + this.flags = flags; + this.display = display; + this.surface = surface; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateWaylandSurfaceKHR(VkInstance instance, VkWaylandSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out wl_display display); + +static { public const let VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; } +static { public const let VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; } + +struct ANativeWindow; +typealias VkAndroidSurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkAndroidSurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAndroidSurfaceCreateFlagsKHR flags = default; + public ANativeWindow* window = null; + + public this(void* pNext, VkAndroidSurfaceCreateFlagsKHR flags, ANativeWindow* window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.window = window; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateAndroidSurfaceKHR(VkInstance instance, VkAndroidSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6; } +static { public const let VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; } + +typealias VkWin32SurfaceCreateFlagsKHR = VkFlags; + +[CRepr] struct VkWin32SurfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkWin32SurfaceCreateFlagsKHR flags = default; + public HINSTANCE hinstance = default; + public HWND hwnd = default; + + public this(void* pNext, VkWin32SurfaceCreateFlagsKHR flags, HINSTANCE hinstance, HWND hwnd) : this() + { + this.pNext = pNext; + this.flags = flags; + this.hinstance = hinstance; + this.hwnd = hwnd; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateWin32SurfaceKHR(VkInstance instance, VkWin32SurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex); + +static { public const let VK_EXT_DEBUG_REPORT_SPEC_VERSION = 10; } +static { public const let VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report"; } + +struct VkDebugReportCallbackEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkDebugReportCallbackEXT( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64 object, + c_size location, + int32 messageCode, + char8* pLayerPrefix, + char8* pMessage, + void* pUserData); + +[AllowDuplicates] enum VkDebugReportFlagBitsEXT : int32 +{ + [NoShow] VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1 << 0, + [NoShow] VK_DEBUG_REPORT_WARNING_BIT_EXT = 1 << 1, + [NoShow] VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 1 << 2, + [NoShow] VK_DEBUG_REPORT_ERROR_BIT_EXT = 1 << 3, + [NoShow] VK_DEBUG_REPORT_DEBUG_BIT_EXT = 1 << 4, + // pretty names + InformationEXT = 1 << 0, + WarningEXT = 1 << 1, + PerformanceWarningEXT = 1 << 2, + ErrorEXT = 1 << 3, + DebugEXT = 1 << 4, +} + +typealias VkDebugReportFlagsEXT = VkDebugReportFlagBitsEXT; + +[AllowDuplicates] enum VkDebugReportObjectTypeEXT : int32 +{ + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT = 1000307000, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT = 1000307001, + [NoShow] VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, + // pretty names + UnknownEXT = 0, + InstanceEXT = 1, + PhysicalDeviceEXT = 2, + DeviceEXT = 3, + QueueEXT = 4, + SemaphoreEXT = 5, + CommandBufferEXT = 6, + FenceEXT = 7, + DeviceMemoryEXT = 8, + BufferEXT = 9, + ImageEXT = 10, + EventEXT = 11, + QueryPoolEXT = 12, + BufferViewEXT = 13, + ImageViewEXT = 14, + ShaderModuleEXT = 15, + PipelineCacheEXT = 16, + PipelineLayoutEXT = 17, + RenderPassEXT = 18, + PipelineEXT = 19, + DescriptorSetLayoutEXT = 20, + SamplerEXT = 21, + DescriptorPoolEXT = 22, + DescriptorSetEXT = 23, + FramebufferEXT = 24, + CommandPoolEXT = 25, + SurfaceKhrEXT = 26, + SwapchainKhrEXT = 27, + DebugReportCallbackExtEXT = 28, + DebugReportEXT = DebugReportCallbackExtEXT, + DisplayKhrEXT = 29, + DisplayModeKhrEXT = 30, + ValidationCacheExtEXT = 33, + ValidationCacheEXT = ValidationCacheExtEXT, + SamplerYcbcrConversionEXT = 1000156000, + DescriptorUpdateTemplateEXT = 1000085000, + CuModuleNvxEXT = 1000029000, + CuFunctionNvxEXT = 1000029001, + DescriptorUpdateTemplateKhrEXT = DescriptorUpdateTemplateEXT, + AccelerationStructureKhrEXT = 1000150000, + SamplerYcbcrConversionKhrEXT = SamplerYcbcrConversionEXT, + AccelerationStructureNvEXT = 1000165000, + CudaModuleNvEXT = 1000307000, + CudaFunctionNvEXT = 1000307001, + BufferCollectionFuchsiaEXT = 1000366000, +} + +[CRepr] struct VkDebugReportCallbackCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDebugReportFlagsEXT flags = default; // Indicates which events call this callback + public PFN_vkDebugReportCallbackEXT pfnCallback = default; // Function pointer of a callback function + public void* pUserData = null; // Data provided to callback function + + public this(void* pNext, VkDebugReportFlagsEXT flags, PFN_vkDebugReportCallbackEXT pfnCallback, void* pUserData = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pfnCallback = pfnCallback; + this.pUserData = pUserData; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDebugReportCallbackEXT pCallback); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64 object, c_size location, int32 messageCode, char8* pLayerPrefix, char8* pMessage); + +static { public const let VK_NV_GLSL_SHADER_SPEC_VERSION = 1; } +static { public const let VK_NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader"; } +static { public const let VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME = "VK_EXT_depth_range_unrestricted"; } +static { public const let VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 3; } +static { public const let VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = "VK_KHR_sampler_mirror_clamp_to_edge"; } +static { public const let VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1; } +static { public const let VK_IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic"; } +static { public const let VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1; } +static { public const let VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"; } + +[AllowDuplicates] enum VkRasterizationOrderAMD : int32 +{ + [NoShow] VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + [NoShow] VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + // pretty names + StrictAMD = 0, + RelaxedAMD = 1, +} + +[CRepr] struct VkPipelineRasterizationStateRasterizationOrderAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRasterizationOrderAMD rasterizationOrder = default; // Rasterization order to use for the pipeline + + public this(void* pNext, VkRasterizationOrderAMD rasterizationOrder) : this() + { + this.pNext = pNext; + this.rasterizationOrder = rasterizationOrder; + } +} + +static { public const let VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME = "VK_AMD_shader_trinary_minmax"; } +static { public const let VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME = "VK_AMD_shader_explicit_vertex_parameter"; } +static { public const let VK_EXT_DEBUG_MARKER_SPEC_VERSION = 4; } +static { public const let VK_EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker"; } + +[CRepr] struct VkDebugMarkerObjectNameInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDebugReportObjectTypeEXT objectType = default; // The type of the object + public uint64 object = 0; // The handle of the object, cast to uint64_t + public char8* pObjectName = null; // Name to apply to the object + + public this(void* pNext, VkDebugReportObjectTypeEXT objectType, uint64 object, char8* pObjectName) : this() + { + this.pNext = pNext; + this.objectType = objectType; + this.object = object; + this.pObjectName = pObjectName; + } +} + +[CRepr] struct VkDebugMarkerObjectTagInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDebugReportObjectTypeEXT objectType = default; // The type of the object + public uint64 object = 0; // The handle of the object, cast to uint64_t + public uint64 tagName = 0; // The name of the tag to set on the object + public c_size tagSize = 0; // The length in bytes of the tag data + public void* pTag = null; // Tag data to attach to the object + public Span tag + { + get { return .(pTag, (.)tagSize); } + set mut { pTag = value.Ptr; tagSize = (.)value.Length; } + } + + public this(void* pNext, VkDebugReportObjectTypeEXT objectType, uint64 object, uint64 tagName, Span tag) : this() + { + this.pNext = pNext; + this.objectType = objectType; + this.object = object; + this.tagName = tagName; + this.tag = tag; + } +} + +[CRepr] struct VkDebugMarkerMarkerInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public char8* pMarkerName = null; // Name of the debug marker + public float[4] color = .(); // Optional color for debug marker + + public this(void* pNext, char8* pMarkerName, float[4] color) : this() + { + this.pNext = pNext; + this.pMarkerName = pMarkerName; + this.color = color; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkDebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkDebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +static { public const let VK_KHR_VIDEO_QUEUE_SPEC_VERSION = 8; } +static { public const let VK_KHR_VIDEO_QUEUE_EXTENSION_NAME = "VK_KHR_video_queue"; } + +struct VkVideoSessionKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_VIDEO_SESSION_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +struct VkVideoSessionParametersKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkVideoCodecOperationFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, + [NoShow] VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 1 << 16, + [NoShow] VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 1 << 17, + [NoShow] VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR = 1 << 18, + [NoShow] VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR = 1 << 3, + // pretty names + NoneKHR = 0, + EncodeH264KHR = 1 << 16, + EncodeH265KHR = 1 << 17, + DecodeH264KHR = 1 << 0, + DecodeH265KHR = 1 << 1, + DecodeAv1KHR = 1 << 2, + EncodeAv1KHR = 1 << 18, + DecodeVp9KHR = 1 << 3, +} + +typealias VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagBitsKHR; + +[AllowDuplicates] enum VkVideoChromaSubsamplingFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, + [NoShow] VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 1 << 3, + // pretty names + InvalidKHR = 0, + MonochromeKHR = 1 << 0, + _420KHR = 1 << 1, + _422KHR = 1 << 2, + _444KHR = 1 << 3, +} + +typealias VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagBitsKHR; + +[AllowDuplicates] enum VkVideoComponentBitDepthFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + [NoShow] VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 1 << 4, + // pretty names + InvalidKHR = 0, + _8KHR = 1 << 0, + _10KHR = 1 << 2, + _12KHR = 1 << 4, +} + +typealias VkVideoComponentBitDepthFlagsKHR = VkVideoComponentBitDepthFlagBitsKHR; + +[AllowDuplicates] enum VkVideoCapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 1 << 1, + // pretty names + ProtectedContentKHR = 1 << 0, + SeparateReferenceImagesKHR = 1 << 1, +} + +typealias VkVideoCapabilityFlagsKHR = VkVideoCapabilityFlagBitsKHR; + +[AllowDuplicates] enum VkVideoSessionCreateFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR = 1 << 5, + // pretty names + ProtectedContentKHR = 1 << 0, + AllowEncodeParameterOptimizationsKHR = 1 << 1, + InlineQueriesKHR = 1 << 2, + AllowEncodeQuantizationDeltaMapKHR = 1 << 3, + AllowEncodeEmphasisMapKHR = 1 << 4, + InlineSessionParametersKHR = 1 << 5, +} + +typealias VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagBitsKHR; +typealias VkVideoSessionParametersCreateFlagsKHR = VkVideoSessionParametersCreateFlagBitsKHR; +typealias VkVideoBeginCodingFlagsKHR = VkFlags; +typealias VkVideoEndCodingFlagsKHR = VkFlags; + +[AllowDuplicates] enum VkVideoCodingControlFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 1 << 2, + // pretty names + ResetKHR = 1 << 0, + EncodeRateControlKHR = 1 << 1, + EncodeQualityLevelKHR = 1 << 2, +} + +typealias VkVideoCodingControlFlagsKHR = VkVideoCodingControlFlagBitsKHR; + +[CRepr] struct VkQueueFamilyQueryResultStatusPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 queryResultStatusSupport = false; +} + +[AllowDuplicates] enum VkQueryResultStatusKHR : int32 +{ + [NoShow] VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + [NoShow] VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + [NoShow] VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + [NoShow] VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000, + // pretty names + ErrorKHR = -1, + NotReadyKHR = 0, + CompleteKHR = 1, + InsufficientBitstreamBufferRangeKHR = -1000299000, +} + +[CRepr] struct VkQueueFamilyVideoPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoCodecOperationFlagsKHR videoCodecOperations = default; +} + +[CRepr] struct VkVideoProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoCodecOperationFlagBitsKHR videoCodecOperation = default; + public VkVideoChromaSubsamplingFlagsKHR chromaSubsampling = default; + public VkVideoComponentBitDepthFlagsKHR lumaBitDepth = default; + public VkVideoComponentBitDepthFlagsKHR chromaBitDepth = default; + + public this(void* pNext, VkVideoCodecOperationFlagBitsKHR videoCodecOperation, VkVideoChromaSubsamplingFlagsKHR chromaSubsampling, VkVideoComponentBitDepthFlagsKHR lumaBitDepth, VkVideoComponentBitDepthFlagsKHR chromaBitDepth = default) : this() + { + this.pNext = pNext; + this.videoCodecOperation = videoCodecOperation; + this.chromaSubsampling = chromaSubsampling; + this.lumaBitDepth = lumaBitDepth; + this.chromaBitDepth = chromaBitDepth; + } +} + +[CRepr] struct VkVideoProfileListInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 profileCount = 0; + public VkVideoProfileInfoKHR* pProfiles = null; + public Span profiles + { + get { return .(pProfiles, (.)profileCount); } + set mut { pProfiles = value.Ptr; profileCount = (.)value.Length; } + } + + public this(void* pNext = null, Span profiles = default) : this() + { + this.pNext = pNext; + this.profiles = profiles; + } +} + +[CRepr] struct VkVideoCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoCapabilityFlagsKHR flags = default; + public VkDeviceSize minBitstreamBufferOffsetAlignment = default; + public VkDeviceSize minBitstreamBufferSizeAlignment = default; + public VkExtent2D pictureAccessGranularity = default; + public VkExtent2D minCodedExtent = default; + public VkExtent2D maxCodedExtent = default; + public uint32 maxDpbSlots = 0; + public uint32 maxActiveReferencePictures = 0; + public VkExtensionProperties stdHeaderVersion = default; +} + +[CRepr] struct VkPhysicalDeviceVideoFormatInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageUsageFlags imageUsage = default; + + public this(void* pNext, VkImageUsageFlags imageUsage) : this() + { + this.pNext = pNext; + this.imageUsage = imageUsage; + } +} + +[CRepr] struct VkVideoFormatPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public VkComponentMapping componentMapping = default; + public VkImageCreateFlags imageCreateFlags = default; + public VkImageType imageType = default; + public VkImageTiling imageTiling = default; + public VkImageUsageFlags imageUsageFlags = default; +} + +[CRepr] struct VkVideoPictureResourceInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOffset2D codedOffset = default; // The offset to be used for the picture resource, currently only used in field mode + public VkExtent2D codedExtent = default; // The extent to be used for the picture resource + public uint32 baseArrayLayer = 0; // The first array layer to be accessed for the Decode or Encode Operations + public VkImageView imageViewBinding = null; // The ImageView binding of the resource + + public this(void* pNext, VkOffset2D codedOffset, VkExtent2D codedExtent, uint32 baseArrayLayer, VkImageView imageViewBinding) : this() + { + this.pNext = pNext; + this.codedOffset = codedOffset; + this.codedExtent = codedExtent; + this.baseArrayLayer = baseArrayLayer; + this.imageViewBinding = imageViewBinding; + } +} + +[CRepr] struct VkVideoReferenceSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 slotIndex = 0; // The reference slot index + public VkVideoPictureResourceInfoKHR* pPictureResource = null; // The reference picture resource + + public this(void* pNext, int32 slotIndex, VkVideoPictureResourceInfoKHR* pPictureResource = null) : this() + { + this.pNext = pNext; + this.slotIndex = slotIndex; + this.pPictureResource = pPictureResource; + } +} + +[CRepr] struct VkVideoSessionMemoryRequirementsKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryBindIndex = 0; + public VkMemoryRequirements memoryRequirements = default; +} + +[CRepr] struct VkBindVideoSessionMemoryInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryBindIndex = 0; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + public VkDeviceSize memorySize = default; + + public this(void* pNext, uint32 memoryBindIndex, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkDeviceSize memorySize) : this() + { + this.pNext = pNext; + this.memoryBindIndex = memoryBindIndex; + this.memory = memory; + this.memoryOffset = memoryOffset; + this.memorySize = memorySize; + } +} + +[CRepr] struct VkVideoSessionCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 queueFamilyIndex = 0; + public VkVideoSessionCreateFlagsKHR flags = default; + public VkVideoProfileInfoKHR* pVideoProfile = null; + public VkFormat pictureFormat = default; + public VkExtent2D maxCodedExtent = default; + public VkFormat referencePictureFormat = default; + public uint32 maxDpbSlots = 0; + public uint32 maxActiveReferencePictures = 0; + public VkExtensionProperties* pStdHeaderVersion = null; + + public this(void* pNext, uint32 queueFamilyIndex, VkVideoSessionCreateFlagsKHR flags, VkVideoProfileInfoKHR* pVideoProfile, VkFormat pictureFormat, VkExtent2D maxCodedExtent, VkFormat referencePictureFormat, uint32 maxDpbSlots, uint32 maxActiveReferencePictures, VkExtensionProperties* pStdHeaderVersion) : this() + { + this.pNext = pNext; + this.queueFamilyIndex = queueFamilyIndex; + this.flags = flags; + this.pVideoProfile = pVideoProfile; + this.pictureFormat = pictureFormat; + this.maxCodedExtent = maxCodedExtent; + this.referencePictureFormat = referencePictureFormat; + this.maxDpbSlots = maxDpbSlots; + this.maxActiveReferencePictures = maxActiveReferencePictures; + this.pStdHeaderVersion = pStdHeaderVersion; + } +} + +[CRepr] struct VkVideoSessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoSessionParametersCreateFlagsKHR flags = default; + public VkVideoSessionParametersKHR videoSessionParametersTemplate = null; + public VkVideoSessionKHR videoSession = null; + + public this(void* pNext, VkVideoSessionParametersCreateFlagsKHR flags, VkVideoSessionParametersKHR videoSessionParametersTemplate, VkVideoSessionKHR videoSession) : this() + { + this.pNext = pNext; + this.flags = flags; + this.videoSessionParametersTemplate = videoSessionParametersTemplate; + this.videoSession = videoSession; + } +} + +[CRepr] struct VkVideoSessionParametersUpdateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 updateSequenceCount = 0; + + public this(void* pNext, uint32 updateSequenceCount) : this() + { + this.pNext = pNext; + this.updateSequenceCount = updateSequenceCount; + } +} + +[CRepr] struct VkVideoBeginCodingInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoBeginCodingFlagsKHR flags = default; + public VkVideoSessionKHR videoSession = null; + public VkVideoSessionParametersKHR videoSessionParameters = null; + public uint32 referenceSlotCount = 0; + public VkVideoReferenceSlotInfoKHR* pReferenceSlots = null; + public Span referenceSlots + { + get { return .(pReferenceSlots, (.)referenceSlotCount); } + set mut { pReferenceSlots = value.Ptr; referenceSlotCount = (.)value.Length; } + } + + public this(void* pNext, VkVideoBeginCodingFlagsKHR flags, VkVideoSessionKHR videoSession, VkVideoSessionParametersKHR videoSessionParameters = null, Span referenceSlots = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.videoSession = videoSession; + this.videoSessionParameters = videoSessionParameters; + this.referenceSlots = referenceSlots; + } +} + +[CRepr] struct VkVideoEndCodingInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEndCodingFlagsKHR flags = default; + + public this(void* pNext = null, VkVideoEndCodingFlagsKHR flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CRepr] struct VkVideoCodingControlInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoCodingControlFlagsKHR flags = default; + + public this(void* pNext, VkVideoCodingControlFlagsKHR flags) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkVideoProfileInfoKHR* pVideoProfile, out VkVideoCapabilitiesKHR pCapabilities); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, out uint32 pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateVideoSessionKHR(VkDevice device, VkVideoSessionCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkVideoSessionKHR pVideoSession); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, out uint32 pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32 bindSessionMemoryInfoCount, VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkVideoSessionParametersKHR pVideoSessionParameters); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, VkVideoBeginCodingInfoKHR* pBeginInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, VkVideoEndCodingInfoKHR* pEndCodingInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, VkVideoCodingControlInfoKHR* pCodingControlInfo); + +static { public const let VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION = 8; } +static { public const let VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME = "VK_KHR_video_decode_queue"; } + +[AllowDuplicates] enum VkVideoDecodeCapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 1 << 1, + // pretty names + DpbAndOutputCoincideKHR = 1 << 0, + DpbAndOutputDistinctKHR = 1 << 1, +} + +typealias VkVideoDecodeCapabilityFlagsKHR = VkVideoDecodeCapabilityFlagBitsKHR; + +[CRepr] struct VkVideoDecodeCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoDecodeCapabilityFlagsKHR flags = default; +} + +[AllowDuplicates] enum VkVideoDecodeUsageFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, + [NoShow] VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 1 << 2, + // pretty names + DefaultKHR = 0, + TranscodingKHR = 1 << 0, + OfflineKHR = 1 << 1, + StreamingKHR = 1 << 2, +} + +typealias VkVideoDecodeUsageFlagsKHR = VkVideoDecodeUsageFlagBitsKHR; + +[CRepr] struct VkVideoDecodeUsageInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoDecodeUsageFlagsKHR videoUsageHints = default; + + public this(void* pNext = null, VkVideoDecodeUsageFlagsKHR videoUsageHints = default) : this() + { + this.pNext = pNext; + this.videoUsageHints = videoUsageHints; + } +} + +typealias VkVideoDecodeFlagsKHR = VkFlags; + +[CRepr] struct VkVideoDecodeInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoDecodeFlagsKHR flags = default; + public VkBuffer srcBuffer = null; + public VkDeviceSize srcBufferOffset = default; + public VkDeviceSize srcBufferRange = default; + public VkVideoPictureResourceInfoKHR dstPictureResource = default; + public VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot = null; + public uint32 referenceSlotCount = 0; + public VkVideoReferenceSlotInfoKHR* pReferenceSlots = null; + public Span referenceSlots + { + get { return .(pReferenceSlots, (.)referenceSlotCount); } + set mut { pReferenceSlots = value.Ptr; referenceSlotCount = (.)value.Length; } + } + + public this(void* pNext, VkVideoDecodeFlagsKHR flags, VkBuffer srcBuffer, VkDeviceSize srcBufferOffset, VkDeviceSize srcBufferRange, VkVideoPictureResourceInfoKHR dstPictureResource, VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot = null, Span referenceSlots = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.srcBuffer = srcBuffer; + this.srcBufferOffset = srcBufferOffset; + this.srcBufferRange = srcBufferRange; + this.dstPictureResource = dstPictureResource; + this.pSetupReferenceSlot = pSetupReferenceSlot; + this.referenceSlots = referenceSlots; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, VkVideoDecodeInfoKHR* pDecodeInfo); + +static { public const let VK_AMD_GCN_SHADER_SPEC_VERSION = 1; } +static { public const let VK_AMD_GCN_SHADER_EXTENSION_NAME = "VK_AMD_gcn_shader"; } +static { public const let VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1; } +static { public const let VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_NV_dedicated_allocation"; } + +[CRepr] struct VkDedicatedAllocationImageCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dedicatedAllocation = false; // Whether this image uses a dedicated allocation + + public this(void* pNext, VkBool32 dedicatedAllocation) : this() + { + this.pNext = pNext; + this.dedicatedAllocation = dedicatedAllocation; + } +} + +[CRepr] struct VkDedicatedAllocationBufferCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dedicatedAllocation = false; // Whether this buffer uses a dedicated allocation + + public this(void* pNext, VkBool32 dedicatedAllocation) : this() + { + this.pNext = pNext; + this.dedicatedAllocation = dedicatedAllocation; + } +} + +[CRepr] struct VkDedicatedAllocationMemoryAllocateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; // Image that this allocation will be bound to + public VkBuffer buffer = null; // Buffer that this allocation will be bound to + + public this(void* pNext = null, VkImage image = null, VkBuffer buffer = null) : this() + { + this.pNext = pNext; + this.image = image; + this.buffer = buffer; + } +} + +static { public const let VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION = 1; } +static { public const let VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME = "VK_EXT_transform_feedback"; } + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32 firstBinding, uint32 bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32 firstCounterBuffer, uint32 counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32 firstCounterBuffer, uint32 counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, VkQueryControlFlags flags, uint32 index); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32 query, uint32 index); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32 instanceCount, uint32 firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32 counterOffset, uint32 vertexStride); + +[CRepr] struct VkPhysicalDeviceTransformFeedbackFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 transformFeedback = false; + public VkBool32 geometryStreams = false; + + public this(void* pNext, VkBool32 transformFeedback, VkBool32 geometryStreams) : this() + { + this.pNext = pNext; + this.transformFeedback = transformFeedback; + this.geometryStreams = geometryStreams; + } +} + +[CRepr] struct VkPhysicalDeviceTransformFeedbackPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxTransformFeedbackStreams = 0; + public uint32 maxTransformFeedbackBuffers = 0; + public VkDeviceSize maxTransformFeedbackBufferSize = default; + public uint32 maxTransformFeedbackStreamDataSize = 0; + public uint32 maxTransformFeedbackBufferDataSize = 0; + public uint32 maxTransformFeedbackBufferDataStride = 0; + public VkBool32 transformFeedbackQueries = false; + public VkBool32 transformFeedbackStreamsLinesTriangles = false; + public VkBool32 transformFeedbackRasterizationStreamSelect = false; + public VkBool32 transformFeedbackDraw = false; +} + +[CRepr] struct VkPipelineRasterizationStateStreamCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRasterizationStateStreamCreateFlagsEXT flags = default; + public uint32 rasterizationStream = 0; + + public this(void* pNext, VkPipelineRasterizationStateStreamCreateFlagsEXT flags, uint32 rasterizationStream) : this() + { + this.pNext = pNext; + this.flags = flags; + this.rasterizationStream = rasterizationStream; + } +} + +typealias VkPipelineRasterizationStateStreamCreateFlagsEXT = VkFlags; + +static { public const let VK_NVX_BINARY_IMPORT_SPEC_VERSION = 2; } +static { public const let VK_NVX_BINARY_IMPORT_EXTENSION_NAME = "VK_NVX_binary_import"; } + +struct VkCuModuleNVX : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_CU_MODULE_NVX; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +struct VkCuFunctionNVX : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_CU_FUNCTION_NVX; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkCuModuleCreateInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(void* pNext = null, Span data = default) : this() + { + this.pNext = pNext; + this.data = data; + } +} + +[CRepr] struct VkCuModuleTexturingModeCreateInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 use64bitTexturing = false; + + public this(void* pNext, VkBool32 use64bitTexturing) : this() + { + this.pNext = pNext; + this.use64bitTexturing = use64bitTexturing; + } +} + +[CRepr] struct VkCuFunctionCreateInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCuModuleNVX module = null; + public char8* pName = null; + + public this(void* pNext, VkCuModuleNVX module, char8* pName) : this() + { + this.pNext = pNext; + this.module = module; + this.pName = pName; + } +} + +[CRepr] struct VkCuLaunchInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCuFunctionNVX @function = null; + public uint32 gridDimX = 0; + public uint32 gridDimY = 0; + public uint32 gridDimZ = 0; + public uint32 blockDimX = 0; + public uint32 blockDimY = 0; + public uint32 blockDimZ = 0; + public uint32 sharedMemBytes = 0; + public c_size paramCount = 0; + public void** pParams = null; + public Span @params + { + get { return .(pParams, (.)paramCount); } + set mut { pParams = value.Ptr; paramCount = (.)value.Length; } + } + public c_size extraCount = 0; + public void** pExtras = null; + public Span extras + { + get { return .(pExtras, (.)extraCount); } + set mut { pExtras = value.Ptr; extraCount = (.)value.Length; } + } + + public this(void* pNext, VkCuFunctionNVX @function, uint32 gridDimX, uint32 gridDimY, uint32 gridDimZ, uint32 blockDimX, uint32 blockDimY, uint32 blockDimZ, uint32 sharedMemBytes, Span @params = default, Span extras = default) : this() + { + this.pNext = pNext; + this.function = @function; + this.gridDimX = gridDimX; + this.gridDimY = gridDimY; + this.gridDimZ = gridDimZ; + this.blockDimX = blockDimX; + this.blockDimY = blockDimY; + this.blockDimZ = blockDimZ; + this.sharedMemBytes = sharedMemBytes; + this.params = @params; + this.extras = extras; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateCuModuleNVX(VkDevice device, VkCuModuleCreateInfoNVX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCuModuleNVX pModule); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateCuFunctionNVX(VkDevice device, VkCuFunctionCreateInfoNVX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCuFunctionNVX pFunction); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX @function, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, VkCuLaunchInfoNVX* pLaunchInfo); + +static { public const let VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION = 3; } +static { public const let VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME = "VK_NVX_image_view_handle"; } + +[CRepr] struct VkImageViewHandleInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView imageView = null; + public VkDescriptorType descriptorType = default; + public VkSampler sampler = null; + + public this(void* pNext, VkImageView imageView, VkDescriptorType descriptorType, VkSampler sampler = null) : this() + { + this.pNext = pNext; + this.imageView = imageView; + this.descriptorType = descriptorType; + this.sampler = sampler; + } +} + +[CRepr] struct VkImageViewAddressPropertiesNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddress deviceAddress = default; + public VkDeviceSize size = default; +} + +[CallingConvention(VKAPI_PTR)] function uint32 PFN_vkGetImageViewHandleNVX(VkDevice device, VkImageViewHandleInfoNVX* pInfo); +[CallingConvention(VKAPI_PTR)] function uint64 PFN_vkGetImageViewHandle64NVX(VkDevice device, VkImageViewHandleInfoNVX* pInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, out VkImageViewAddressPropertiesNVX pProperties); + +static { public const let VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 2; } +static { public const let VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_AMD_draw_indirect_count"; } + +typealias PFN_vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCount; +typealias PFN_vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCount; + +static { public const let VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1; } +static { public const let VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME = "VK_AMD_negative_viewport_height"; } +static { public const let VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 2; } +static { public const let VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME = "VK_AMD_gpu_shader_half_float"; } +static { public const let VK_AMD_SHADER_BALLOT_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_BALLOT_EXTENSION_NAME = "VK_AMD_shader_ballot"; } +static { public const let VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION = 14; } +static { public const let VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME = "VK_KHR_video_encode_h264"; } + +[AllowDuplicates] enum VkVideoEncodeH264CapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 1 << 5, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 1 << 6, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 1 << 7, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 1 << 8, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 1 << 10, + [NoShow] VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 1 << 9, + // pretty names + HrdComplianceKHR = 1 << 0, + PredictionWeightTableGeneratedKHR = 1 << 1, + RowUnalignedSliceKHR = 1 << 2, + DifferentSliceTypeKHR = 1 << 3, + BFrameInL0_ListKHR = 1 << 4, + BFrameInL1_ListKHR = 1 << 5, + PerPictureTypeMinMaxQpKHR = 1 << 6, + PerSliceConstantQpKHR = 1 << 7, + GeneratePrefixNaluKHR = 1 << 8, + BPictureIntraRefreshKHR = 1 << 10, + MbQpDiffWraparoundKHR = 1 << 9, +} + +typealias VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeH264StdFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR = 1 << 5, + [NoShow] VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 1 << 6, + [NoShow] VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR = 1 << 7, + [NoShow] VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR = 1 << 8, + [NoShow] VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR = 1 << 9, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR = 1 << 10, + [NoShow] VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR = 1 << 11, + [NoShow] VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR = 1 << 12, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR = 1 << 13, + [NoShow] VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 1 << 14, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR = 1 << 15, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR = 1 << 16, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR = 1 << 17, + [NoShow] VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR = 1 << 19, + [NoShow] VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 1 << 20, + // pretty names + SeparateColorPlaneFlagSetKHR = 1 << 0, + QpprimeYZeroTransformBypassFlagSetKHR = 1 << 1, + ScalingMatrixPresentFlagSetKHR = 1 << 2, + ChromaQpIndexOffsetKHR = 1 << 3, + SecondChromaQpIndexOffsetKHR = 1 << 4, + PicInitQpMinus26KHR = 1 << 5, + WeightedPredFlagSetKHR = 1 << 6, + WeightedBipredIdcExplicitKHR = 1 << 7, + WeightedBipredIdcImplicitKHR = 1 << 8, + Transform8x8_ModeFlagSetKHR = 1 << 9, + DirectSpatialMvPredFlagUnsetKHR = 1 << 10, + EntropyCodingModeFlagUnsetKHR = 1 << 11, + EntropyCodingModeFlagSetKHR = 1 << 12, + Direct8x8_InferenceFlagUnsetKHR = 1 << 13, + ConstrainedIntraPredFlagSetKHR = 1 << 14, + DeblockingFilterDisabledKHR = 1 << 15, + DeblockingFilterEnabledKHR = 1 << 16, + DeblockingFilterPartialKHR = 1 << 17, + SliceQpDeltaKHR = 1 << 19, + DifferentSliceQpDeltaKHR = 1 << 20, +} + +typealias VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagBitsKHR; + +[CRepr] struct VkVideoEncodeH264CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH264CapabilityFlagsKHR flags = default; + public StdVideoH264LevelIdc maxLevelIdc = default; + public uint32 maxSliceCount = 0; + public uint32 maxPPictureL0ReferenceCount = 0; + public uint32 maxBPictureL0ReferenceCount = 0; + public uint32 maxL1ReferenceCount = 0; + public uint32 maxTemporalLayerCount = 0; + public VkBool32 expectDyadicTemporalLayerPattern = false; + public int32 minQp = 0; + public int32 maxQp = 0; + public VkBool32 prefersGopRemainingFrames = false; + public VkBool32 requiresGopRemainingFrames = false; + public VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags = default; +} + +[CRepr] struct VkVideoEncodeH264QualityLevelPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags = default; + public uint32 preferredGopFrameCount = 0; + public uint32 preferredIdrPeriod = 0; + public uint32 preferredConsecutiveBFrameCount = 0; + public uint32 preferredTemporalLayerCount = 0; + public VkVideoEncodeH264QpKHR preferredConstantQp = default; + public uint32 preferredMaxL0ReferenceCount = 0; + public uint32 preferredMaxL1ReferenceCount = 0; + public VkBool32 preferredStdEntropyCodingModeFlag = false; +} + +[CRepr] struct VkVideoEncodeH264SessionCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMaxLevelIdc = false; + public StdVideoH264LevelIdc maxLevelIdc = default; + + public this(void* pNext, VkBool32 useMaxLevelIdc, StdVideoH264LevelIdc maxLevelIdc) : this() + { + this.pNext = pNext; + this.useMaxLevelIdc = useMaxLevelIdc; + this.maxLevelIdc = maxLevelIdc; + } +} + +[CRepr] struct VkVideoEncodeH264SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxStdSPSCount = 0; + public uint32 maxStdPPSCount = 0; + public VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo = null; + + public this(void* pNext, uint32 maxStdSPSCount, uint32 maxStdPPSCount, VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo = null) : this() + { + this.pNext = pNext; + this.maxStdSPSCount = maxStdSPSCount; + this.maxStdPPSCount = maxStdPPSCount; + this.pParametersAddInfo = pParametersAddInfo; + } +} + +[CRepr] struct VkVideoEncodeH264SessionParametersAddInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stdSPSCount = 0; + public StdVideoH264SequenceParameterSet* pStdSPSs = null; + public Span stdSPSs + { + get { return .(pStdSPSs, (.)stdSPSCount); } + set mut { pStdSPSs = value.Ptr; stdSPSCount = (.)value.Length; } + } + public uint32 stdPPSCount = 0; + public StdVideoH264PictureParameterSet* pStdPPSs = null; // List of Picture Parameters associated with the spsStd, above + public Span stdPPSs + { + get { return .(pStdPPSs, (.)stdPPSCount); } + set mut { pStdPPSs = value.Ptr; stdPPSCount = (.)value.Length; } + } + + public this(void* pNext = null, Span stdSPSs = default, Span stdPPSs = default) : this() + { + this.pNext = pNext; + this.stdSPSs = stdSPSs; + this.stdPPSs = stdPPSs; + } +} + +[CRepr] struct VkVideoEncodeH264SessionParametersGetInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 writeStdSPS = false; + public VkBool32 writeStdPPS = false; + public uint32 stdSPSId = 0; + public uint32 stdPPSId = 0; + + public this(void* pNext, VkBool32 writeStdSPS, VkBool32 writeStdPPS, uint32 stdSPSId, uint32 stdPPSId) : this() + { + this.pNext = pNext; + this.writeStdSPS = writeStdSPS; + this.writeStdPPS = writeStdPPS; + this.stdSPSId = stdSPSId; + this.stdPPSId = stdPPSId; + } +} + +[CRepr] struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hasStdSPSOverrides = false; + public VkBool32 hasStdPPSOverrides = false; +} + +[CRepr] struct VkVideoEncodeH264PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 naluSliceEntryCount = 0; + public VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries = null; + public Span naluSliceEntries + { + get { return .(pNaluSliceEntries, (.)naluSliceEntryCount); } + set mut { pNaluSliceEntries = value.Ptr; naluSliceEntryCount = (.)value.Length; } + } + public StdVideoEncodeH264PictureInfo* pStdPictureInfo = null; + public VkBool32 generatePrefixNalu = false; + + public this(void* pNext, Span naluSliceEntries, StdVideoEncodeH264PictureInfo* pStdPictureInfo, VkBool32 generatePrefixNalu) : this() + { + this.pNext = pNext; + this.naluSliceEntries = naluSliceEntries; + this.pStdPictureInfo = pStdPictureInfo; + this.generatePrefixNalu = generatePrefixNalu; + } +} + +[CRepr] struct VkVideoEncodeH264DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +[CRepr] struct VkVideoEncodeH264NaluSliceInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 constantQp = 0; + public StdVideoEncodeH264SliceHeader* pStdSliceHeader = null; + + public this(void* pNext, int32 constantQp, StdVideoEncodeH264SliceHeader* pStdSliceHeader) : this() + { + this.pNext = pNext; + this.constantQp = constantQp; + this.pStdSliceHeader = pStdSliceHeader; + } +} + +[CRepr] struct VkVideoEncodeH264ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH264ProfileIdc stdProfileIdc = default; + + public this(void* pNext, StdVideoH264ProfileIdc stdProfileIdc) : this() + { + this.pNext = pNext; + this.stdProfileIdc = stdProfileIdc; + } +} + +[CRepr] struct VkVideoEncodeH264RateControlInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH264RateControlFlagsKHR flags = default; + public uint32 gopFrameCount = 0; + public uint32 idrPeriod = 0; + public uint32 consecutiveBFrameCount = 0; + public uint32 temporalLayerCount = 0; + + public this(void* pNext, VkVideoEncodeH264RateControlFlagsKHR flags, uint32 gopFrameCount, uint32 idrPeriod, uint32 consecutiveBFrameCount, uint32 temporalLayerCount) : this() + { + this.pNext = pNext; + this.flags = flags; + this.gopFrameCount = gopFrameCount; + this.idrPeriod = idrPeriod; + this.consecutiveBFrameCount = consecutiveBFrameCount; + this.temporalLayerCount = temporalLayerCount; + } +} + +[AllowDuplicates] enum VkVideoEncodeH264RateControlFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 1 << 4, + // pretty names + AttemptHrdComplianceKHR = 1 << 0, + RegularGopKHR = 1 << 1, + ReferencePatternFlatKHR = 1 << 2, + ReferencePatternDyadicKHR = 1 << 3, + TemporalLayerPatternDyadicKHR = 1 << 4, +} + +typealias VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagBitsKHR; + +[CRepr] struct VkVideoEncodeH264RateControlLayerInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMinQp = false; + public VkVideoEncodeH264QpKHR minQp = default; + public VkBool32 useMaxQp = false; + public VkVideoEncodeH264QpKHR maxQp = default; + public VkBool32 useMaxFrameSize = false; + public VkVideoEncodeH264FrameSizeKHR maxFrameSize = default; + + public this(void* pNext, VkBool32 useMinQp, VkVideoEncodeH264QpKHR minQp, VkBool32 useMaxQp, VkVideoEncodeH264QpKHR maxQp, VkBool32 useMaxFrameSize, VkVideoEncodeH264FrameSizeKHR maxFrameSize) : this() + { + this.pNext = pNext; + this.useMinQp = useMinQp; + this.minQp = minQp; + this.useMaxQp = useMaxQp; + this.maxQp = maxQp; + this.useMaxFrameSize = useMaxFrameSize; + this.maxFrameSize = maxFrameSize; + } +} + +[CRepr] struct VkVideoEncodeH264QpKHR : this() +{ + public int32 qpI = 0; + public int32 qpP = 0; + public int32 qpB = 0; + + public this(int32 qpI, int32 qpP, int32 qpB) : this() + { + this.qpI = qpI; + this.qpP = qpP; + this.qpB = qpB; + } +} + +[CRepr] struct VkVideoEncodeH264FrameSizeKHR : this() +{ + public uint32 frameISize = 0; + public uint32 framePSize = 0; + public uint32 frameBSize = 0; + + public this(uint32 frameISize, uint32 framePSize, uint32 frameBSize) : this() + { + this.frameISize = frameISize; + this.framePSize = framePSize; + this.frameBSize = frameBSize; + } +} + +[CRepr] struct VkVideoEncodeH264GopRemainingFrameInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useGopRemainingFrames = false; + public uint32 gopRemainingI = 0; + public uint32 gopRemainingP = 0; + public uint32 gopRemainingB = 0; + + public this(void* pNext, VkBool32 useGopRemainingFrames, uint32 gopRemainingI, uint32 gopRemainingP, uint32 gopRemainingB) : this() + { + this.pNext = pNext; + this.useGopRemainingFrames = useGopRemainingFrames; + this.gopRemainingI = gopRemainingI; + this.gopRemainingP = gopRemainingP; + this.gopRemainingB = gopRemainingB; + } +} + +static { public const let VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION = 14; } +static { public const let VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME = "VK_KHR_video_encode_h265"; } + +[AllowDuplicates] enum VkVideoEncodeH265CapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 1 << 5, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 1 << 6, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 1 << 7, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 1 << 8, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 1 << 9, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 1 << 11, + [NoShow] VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR = 1 << 10, + // pretty names + HrdComplianceKHR = 1 << 0, + PredictionWeightTableGeneratedKHR = 1 << 1, + RowUnalignedSliceSegmentKHR = 1 << 2, + DifferentSliceSegmentTypeKHR = 1 << 3, + BFrameInL0_ListKHR = 1 << 4, + BFrameInL1_ListKHR = 1 << 5, + PerPictureTypeMinMaxQpKHR = 1 << 6, + PerSliceSegmentConstantQpKHR = 1 << 7, + MultipleTilesPerSliceSegmentKHR = 1 << 8, + MultipleSliceSegmentsPerTileKHR = 1 << 9, + BPictureIntraRefreshKHR = 1 << 11, + CuQpDiffWraparoundKHR = 1 << 10, +} + +typealias VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeH265StdFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR = 1 << 5, + [NoShow] VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 1 << 6, + [NoShow] VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR = 1 << 7, + [NoShow] VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR = 1 << 8, + [NoShow] VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR = 1 << 9, + [NoShow] VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR = 1 << 10, + [NoShow] VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR = 1 << 11, + [NoShow] VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR = 1 << 12, + [NoShow] VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR = 1 << 13, + [NoShow] VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 1 << 14, + [NoShow] VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR = 1 << 15, + [NoShow] VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR = 1 << 16, + [NoShow] VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR = 1 << 17, + [NoShow] VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR = 1 << 18, + [NoShow] VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR = 1 << 19, + [NoShow] VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 1 << 20, + // pretty names + SeparateColorPlaneFlagSetKHR = 1 << 0, + SampleAdaptiveOffsetEnabledFlagSetKHR = 1 << 1, + ScalingListDataPresentFlagSetKHR = 1 << 2, + PcmEnabledFlagSetKHR = 1 << 3, + SpsTemporalMvpEnabledFlagSetKHR = 1 << 4, + InitQpMinus26KHR = 1 << 5, + WeightedPredFlagSetKHR = 1 << 6, + WeightedBipredFlagSetKHR = 1 << 7, + Log2_ParallelMergeLevelMinus2KHR = 1 << 8, + SignDataHidingEnabledFlagSetKHR = 1 << 9, + TransformSkipEnabledFlagSetKHR = 1 << 10, + TransformSkipEnabledFlagUnsetKHR = 1 << 11, + PpsSliceChromaQpOffsetsPresentFlagSetKHR = 1 << 12, + TransquantBypassEnabledFlagSetKHR = 1 << 13, + ConstrainedIntraPredFlagSetKHR = 1 << 14, + EntropyCodingSyncEnabledFlagSetKHR = 1 << 15, + DeblockingFilterOverrideEnabledFlagSetKHR = 1 << 16, + DependentSliceSegmentsEnabledFlagSetKHR = 1 << 17, + DependentSliceSegmentFlagSetKHR = 1 << 18, + SliceQpDeltaKHR = 1 << 19, + DifferentSliceQpDeltaKHR = 1 << 20, +} + +typealias VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeH265CtbSizeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR = 1 << 2, + // pretty names + _16KHR = 1 << 0, + _32KHR = 1 << 1, + _64KHR = 1 << 2, +} + +typealias VkVideoEncodeH265CtbSizeFlagsKHR = VkVideoEncodeH265CtbSizeFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR = 1 << 3, + // pretty names + _4KHR = 1 << 0, + _8KHR = 1 << 1, + _16KHR = 1 << 2, + _32KHR = 1 << 3, +} + +typealias VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; + +[CRepr] struct VkVideoEncodeH265CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH265CapabilityFlagsKHR flags = default; + public StdVideoH265LevelIdc maxLevelIdc = default; + public uint32 maxSliceSegmentCount = 0; + public VkExtent2D maxTiles = default; + public VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes = default; + public VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes = default; + public uint32 maxPPictureL0ReferenceCount = 0; + public uint32 maxBPictureL0ReferenceCount = 0; + public uint32 maxL1ReferenceCount = 0; + public uint32 maxSubLayerCount = 0; + public VkBool32 expectDyadicTemporalSubLayerPattern = false; + public int32 minQp = 0; + public int32 maxQp = 0; + public VkBool32 prefersGopRemainingFrames = false; + public VkBool32 requiresGopRemainingFrames = false; + public VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags = default; +} + +[CRepr] struct VkVideoEncodeH265SessionCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMaxLevelIdc = false; + public StdVideoH265LevelIdc maxLevelIdc = default; + + public this(void* pNext, VkBool32 useMaxLevelIdc, StdVideoH265LevelIdc maxLevelIdc) : this() + { + this.pNext = pNext; + this.useMaxLevelIdc = useMaxLevelIdc; + this.maxLevelIdc = maxLevelIdc; + } +} + +[CRepr] struct VkVideoEncodeH265QualityLevelPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags = default; + public uint32 preferredGopFrameCount = 0; + public uint32 preferredIdrPeriod = 0; + public uint32 preferredConsecutiveBFrameCount = 0; + public uint32 preferredSubLayerCount = 0; + public VkVideoEncodeH265QpKHR preferredConstantQp = default; + public uint32 preferredMaxL0ReferenceCount = 0; + public uint32 preferredMaxL1ReferenceCount = 0; +} + +[CRepr] struct VkVideoEncodeH265SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxStdVPSCount = 0; + public uint32 maxStdSPSCount = 0; + public uint32 maxStdPPSCount = 0; + public VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo = null; + + public this(void* pNext, uint32 maxStdVPSCount, uint32 maxStdSPSCount, uint32 maxStdPPSCount, VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo = null) : this() + { + this.pNext = pNext; + this.maxStdVPSCount = maxStdVPSCount; + this.maxStdSPSCount = maxStdSPSCount; + this.maxStdPPSCount = maxStdPPSCount; + this.pParametersAddInfo = pParametersAddInfo; + } +} + +[CRepr] struct VkVideoEncodeH265SessionParametersAddInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stdVPSCount = 0; + public StdVideoH265VideoParameterSet* pStdVPSs = null; + public Span stdVPSs + { + get { return .(pStdVPSs, (.)stdVPSCount); } + set mut { pStdVPSs = value.Ptr; stdVPSCount = (.)value.Length; } + } + public uint32 stdSPSCount = 0; + public StdVideoH265SequenceParameterSet* pStdSPSs = null; + public Span stdSPSs + { + get { return .(pStdSPSs, (.)stdSPSCount); } + set mut { pStdSPSs = value.Ptr; stdSPSCount = (.)value.Length; } + } + public uint32 stdPPSCount = 0; + public StdVideoH265PictureParameterSet* pStdPPSs = null; // List of Picture Parameters associated with the spsStd, above + public Span stdPPSs + { + get { return .(pStdPPSs, (.)stdPPSCount); } + set mut { pStdPPSs = value.Ptr; stdPPSCount = (.)value.Length; } + } + + public this(void* pNext = null, Span stdVPSs = default, Span stdSPSs = default, Span stdPPSs = default) : this() + { + this.pNext = pNext; + this.stdVPSs = stdVPSs; + this.stdSPSs = stdSPSs; + this.stdPPSs = stdPPSs; + } +} + +[CRepr] struct VkVideoEncodeH265SessionParametersGetInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 writeStdVPS = false; + public VkBool32 writeStdSPS = false; + public VkBool32 writeStdPPS = false; + public uint32 stdVPSId = 0; + public uint32 stdSPSId = 0; + public uint32 stdPPSId = 0; + + public this(void* pNext, VkBool32 writeStdVPS, VkBool32 writeStdSPS, VkBool32 writeStdPPS, uint32 stdVPSId, uint32 stdSPSId, uint32 stdPPSId) : this() + { + this.pNext = pNext; + this.writeStdVPS = writeStdVPS; + this.writeStdSPS = writeStdSPS; + this.writeStdPPS = writeStdPPS; + this.stdVPSId = stdVPSId; + this.stdSPSId = stdSPSId; + this.stdPPSId = stdPPSId; + } +} + +[CRepr] struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hasStdVPSOverrides = false; + public VkBool32 hasStdSPSOverrides = false; + public VkBool32 hasStdPPSOverrides = false; +} + +[CRepr] struct VkVideoEncodeH265PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 naluSliceSegmentEntryCount = 0; + public VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries = null; + public Span naluSliceSegmentEntries + { + get { return .(pNaluSliceSegmentEntries, (.)naluSliceSegmentEntryCount); } + set mut { pNaluSliceSegmentEntries = value.Ptr; naluSliceSegmentEntryCount = (.)value.Length; } + } + public StdVideoEncodeH265PictureInfo* pStdPictureInfo = null; + + public this(void* pNext, Span naluSliceSegmentEntries, StdVideoEncodeH265PictureInfo* pStdPictureInfo) : this() + { + this.pNext = pNext; + this.naluSliceSegmentEntries = naluSliceSegmentEntries; + this.pStdPictureInfo = pStdPictureInfo; + } +} + +[CRepr] struct VkVideoEncodeH265DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +[CRepr] struct VkVideoEncodeH265NaluSliceSegmentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 constantQp = 0; + public StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader = null; + + public this(void* pNext, int32 constantQp, StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader) : this() + { + this.pNext = pNext; + this.constantQp = constantQp; + this.pStdSliceSegmentHeader = pStdSliceSegmentHeader; + } +} + +[CRepr] struct VkVideoEncodeH265ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH265ProfileIdc stdProfileIdc = default; + + public this(void* pNext, StdVideoH265ProfileIdc stdProfileIdc) : this() + { + this.pNext = pNext; + this.stdProfileIdc = stdProfileIdc; + } +} + +[CRepr] struct VkVideoEncodeH265RateControlInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH265RateControlFlagsKHR flags = default; + public uint32 gopFrameCount = 0; + public uint32 idrPeriod = 0; + public uint32 consecutiveBFrameCount = 0; + public uint32 subLayerCount = 0; + + public this(void* pNext, VkVideoEncodeH265RateControlFlagsKHR flags, uint32 gopFrameCount, uint32 idrPeriod, uint32 consecutiveBFrameCount, uint32 subLayerCount) : this() + { + this.pNext = pNext; + this.flags = flags; + this.gopFrameCount = gopFrameCount; + this.idrPeriod = idrPeriod; + this.consecutiveBFrameCount = consecutiveBFrameCount; + this.subLayerCount = subLayerCount; + } +} + +[AllowDuplicates] enum VkVideoEncodeH265RateControlFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR = 1 << 4, + // pretty names + AttemptHrdComplianceKHR = 1 << 0, + RegularGopKHR = 1 << 1, + ReferencePatternFlatKHR = 1 << 2, + ReferencePatternDyadicKHR = 1 << 3, + TemporalSubLayerPatternDyadicKHR = 1 << 4, +} + +typealias VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagBitsKHR; + +[CRepr] struct VkVideoEncodeH265RateControlLayerInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMinQp = false; + public VkVideoEncodeH265QpKHR minQp = default; + public VkBool32 useMaxQp = false; + public VkVideoEncodeH265QpKHR maxQp = default; + public VkBool32 useMaxFrameSize = false; + public VkVideoEncodeH265FrameSizeKHR maxFrameSize = default; + + public this(void* pNext, VkBool32 useMinQp, VkVideoEncodeH265QpKHR minQp, VkBool32 useMaxQp, VkVideoEncodeH265QpKHR maxQp, VkBool32 useMaxFrameSize, VkVideoEncodeH265FrameSizeKHR maxFrameSize) : this() + { + this.pNext = pNext; + this.useMinQp = useMinQp; + this.minQp = minQp; + this.useMaxQp = useMaxQp; + this.maxQp = maxQp; + this.useMaxFrameSize = useMaxFrameSize; + this.maxFrameSize = maxFrameSize; + } +} + +[CRepr] struct VkVideoEncodeH265QpKHR : this() +{ + public int32 qpI = 0; + public int32 qpP = 0; + public int32 qpB = 0; + + public this(int32 qpI, int32 qpP, int32 qpB) : this() + { + this.qpI = qpI; + this.qpP = qpP; + this.qpB = qpB; + } +} + +[CRepr] struct VkVideoEncodeH265FrameSizeKHR : this() +{ + public uint32 frameISize = 0; + public uint32 framePSize = 0; + public uint32 frameBSize = 0; + + public this(uint32 frameISize, uint32 framePSize, uint32 frameBSize) : this() + { + this.frameISize = frameISize; + this.framePSize = framePSize; + this.frameBSize = frameBSize; + } +} + +[CRepr] struct VkVideoEncodeH265GopRemainingFrameInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useGopRemainingFrames = false; + public uint32 gopRemainingI = 0; + public uint32 gopRemainingP = 0; + public uint32 gopRemainingB = 0; + + public this(void* pNext, VkBool32 useGopRemainingFrames, uint32 gopRemainingI, uint32 gopRemainingP, uint32 gopRemainingB) : this() + { + this.pNext = pNext; + this.useGopRemainingFrames = useGopRemainingFrames; + this.gopRemainingI = gopRemainingI; + this.gopRemainingP = gopRemainingP; + this.gopRemainingB = gopRemainingB; + } +} + +static { public const let VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION = 9; } +static { public const let VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME = "VK_KHR_video_decode_h264"; } + +[AllowDuplicates] enum VkVideoDecodeH264PictureLayoutFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, + [NoShow] VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 1 << 1, + // pretty names + ProgressiveKHR = 0, + InterlacedInterleavedLinesKHR = 1 << 0, + InterlacedSeparatePlanesKHR = 1 << 1, +} + +typealias VkVideoDecodeH264PictureLayoutFlagsKHR = VkVideoDecodeH264PictureLayoutFlagBitsKHR; + +[CRepr] struct VkVideoDecodeH264ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH264ProfileIdc stdProfileIdc = default; + public VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = default; + + public this(void* pNext, StdVideoH264ProfileIdc stdProfileIdc, VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = default) : this() + { + this.pNext = pNext; + this.stdProfileIdc = stdProfileIdc; + this.pictureLayout = pictureLayout; + } +} + +[CRepr] struct VkVideoDecodeH264CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH264LevelIdc maxLevelIdc = default; + public VkOffset2D fieldOffsetGranularity = default; +} + +[CRepr] struct VkVideoDecodeH264SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxStdSPSCount = 0; + public uint32 maxStdPPSCount = 0; + public VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo = null; + + public this(void* pNext, uint32 maxStdSPSCount, uint32 maxStdPPSCount, VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo = null) : this() + { + this.pNext = pNext; + this.maxStdSPSCount = maxStdSPSCount; + this.maxStdPPSCount = maxStdPPSCount; + this.pParametersAddInfo = pParametersAddInfo; + } +} + +[CRepr] struct VkVideoDecodeH264SessionParametersAddInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stdSPSCount = 0; + public StdVideoH264SequenceParameterSet* pStdSPSs = null; + public Span stdSPSs + { + get { return .(pStdSPSs, (.)stdSPSCount); } + set mut { pStdSPSs = value.Ptr; stdSPSCount = (.)value.Length; } + } + public uint32 stdPPSCount = 0; + public StdVideoH264PictureParameterSet* pStdPPSs = null; // List of Picture Parameters associated with the spsStd, above + public Span stdPPSs + { + get { return .(pStdPPSs, (.)stdPPSCount); } + set mut { pStdPPSs = value.Ptr; stdPPSCount = (.)value.Length; } + } + + public this(void* pNext = null, Span stdSPSs = default, Span stdPPSs = default) : this() + { + this.pNext = pNext; + this.stdSPSs = stdSPSs; + this.stdPPSs = stdPPSs; + } +} + +[CRepr] struct VkVideoDecodeH264PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeH264PictureInfo* pStdPictureInfo = null; + public uint32 sliceCount = 0; + public uint32* pSliceOffsets = null; + public Span sliceOffsets + { + get { return .(pSliceOffsets, (.)sliceCount); } + set mut { pSliceOffsets = value.Ptr; sliceCount = (.)value.Length; } + } + + public this(void* pNext, StdVideoDecodeH264PictureInfo* pStdPictureInfo, Span sliceOffsets) : this() + { + this.pNext = pNext; + this.pStdPictureInfo = pStdPictureInfo; + this.sliceOffsets = sliceOffsets; + } +} + +[CRepr] struct VkVideoDecodeH264DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +static { public const let VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION = 1; } +static { public const let VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME = "VK_AMD_texture_gather_bias_lod"; } + +[CRepr] struct VkTextureLODGatherFormatPropertiesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 supportsTextureGatherLODBiasAMD = false; +} + +static { public const let VK_AMD_SHADER_INFO_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_INFO_EXTENSION_NAME = "VK_AMD_shader_info"; } + +[AllowDuplicates] enum VkShaderInfoTypeAMD : int32 +{ + [NoShow] VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + [NoShow] VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + [NoShow] VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + // pretty names + StatisticsAMD = 0, + BinaryAMD = 1, + DisassemblyAMD = 2, +} + +[CRepr] struct VkShaderResourceUsageAMD : this() +{ + public uint32 numUsedVgprs = 0; + public uint32 numUsedSgprs = 0; + public uint32 ldsSizePerLocalWorkGroup = 0; + public c_size ldsUsageSizeInBytes = 0; + public c_size scratchMemUsageInBytes = 0; +} + +[CRepr] struct VkShaderStatisticsInfoAMD : this() +{ + public VkShaderStageFlags shaderStageMask = default; + public VkShaderResourceUsageAMD resourceUsage = default; + public uint32 numPhysicalVgprs = 0; + public uint32 numPhysicalSgprs = 0; + public uint32 numAvailableVgprs = 0; + public uint32 numAvailableSgprs = 0; + public uint32[3] computeWorkGroupSize = .(); +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out c_size pInfoSize, void* pInfo = null); + +static { public const let VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION = 1; } +static { public const let VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME = "VK_KHR_dynamic_rendering"; } + +typealias PFN_vkCmdBeginRenderingKHR = PFN_vkCmdBeginRendering; +typealias PFN_vkCmdEndRenderingKHR = PFN_vkCmdEndRendering; + +typealias VkRenderingInfoKHR = VkRenderingInfo; +typealias VkRenderingAttachmentInfoKHR = VkRenderingAttachmentInfo; +typealias VkPipelineRenderingCreateInfoKHR = VkPipelineRenderingCreateInfo; +typealias VkPhysicalDeviceDynamicRenderingFeaturesKHR = VkPhysicalDeviceDynamicRenderingFeatures; +typealias VkCommandBufferInheritanceRenderingInfoKHR = VkCommandBufferInheritanceRenderingInfo; +typealias VkRenderingFlagsKHR = VkRenderingFlags; +typealias VkRenderingFlagBitsKHR = VkRenderingFlagBits; + +static { public const let VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME = "VK_AMD_shader_image_load_store_lod"; } +static { public const let VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME = "VK_GGP_stream_descriptor_surface"; } + +typealias VkStreamDescriptorSurfaceCreateFlagsGGP = VkFlags; + +[CRepr] struct VkStreamDescriptorSurfaceCreateInfoGGP : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; + public VkStructureType sType = SType; + public void* pNext = null; + public VkStreamDescriptorSurfaceCreateFlagsGGP flags = default; + public GgpStreamDescriptor streamDescriptor = default; + + public this(void* pNext, VkStreamDescriptorSurfaceCreateFlagsGGP flags, GgpStreamDescriptor streamDescriptor) : this() + { + this.pNext = pNext; + this.flags = flags; + this.streamDescriptor = streamDescriptor; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION = 2; } +static { public const let VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME = "VK_NV_corner_sampled_image"; } + +[CRepr] struct VkPhysicalDeviceCornerSampledImageFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cornerSampledImage = false; + + public this(void* pNext, VkBool32 cornerSampledImage) : this() + { + this.pNext = pNext; + this.cornerSampledImage = cornerSampledImage; + } +} + +static { public const let VK_KHR_MULTIVIEW_SPEC_VERSION = 1; } +static { public const let VK_KHR_MULTIVIEW_EXTENSION_NAME = "VK_KHR_multiview"; } + +typealias VkRenderPassMultiviewCreateInfoKHR = VkRenderPassMultiviewCreateInfo; +typealias VkPhysicalDeviceMultiviewFeaturesKHR = VkPhysicalDeviceMultiviewFeatures; +typealias VkPhysicalDeviceMultiviewPropertiesKHR = VkPhysicalDeviceMultiviewProperties; + +static { public const let VK_IMG_FORMAT_PVRTC_SPEC_VERSION = 1; } +static { public const let VK_IMG_FORMAT_PVRTC_EXTENSION_NAME = "VK_IMG_format_pvrtc"; } +static { public const let VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_NV_external_memory_capabilities"; } + +typealias VkExternalMemoryHandleTypeFlagsNV = VkExternalMemoryHandleTypeFlagBitsNV; + +[AllowDuplicates] enum VkExternalMemoryHandleTypeFlagBitsNV : int32 +{ + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1 << 0, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 1 << 1, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 1 << 2, + [NoShow] VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 1 << 3, + // pretty names + OpaqueWin32NV = 1 << 0, + OpaqueWin32_KmtNV = 1 << 1, + D3d11_ImageNV = 1 << 2, + D3d11_ImageKmtNV = 1 << 3, +} + +typealias VkExternalMemoryFeatureFlagsNV = VkExternalMemoryFeatureFlagBitsNV; + +[AllowDuplicates] enum VkExternalMemoryFeatureFlagBitsNV : int32 +{ + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1 << 0, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 1 << 1, + [NoShow] VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 1 << 2, + // pretty names + DedicatedOnlyNV = 1 << 0, + ExportableNV = 1 << 1, + ImportableNV = 1 << 2, +} + +[CRepr] struct VkExternalImageFormatPropertiesNV : this() +{ + public VkImageFormatProperties imageFormatProperties = default; + public VkExternalMemoryFeatureFlagsNV externalMemoryFeatures = default; + public VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes = default; + public VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, out VkExternalImageFormatPropertiesNV pExternalImageFormatProperties); + +static { public const let VK_NV_EXTERNAL_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_NV_external_memory"; } + +[CRepr] struct VkExternalMemoryImageCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagsNV handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagsNV handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +[CRepr] struct VkExportMemoryAllocateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagsNV handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagsNV handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +static { public const let VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; } + +[CRepr] struct VkImportMemoryWin32HandleInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagsNV handleType = default; + public HANDLE handle = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagsNV handleType = default, HANDLE handle = default) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.handle = handle; + } +} + +[CRepr] struct VkExportMemoryWin32HandleInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public SECURITY_ATTRIBUTES* pAttributes = null; + public DWORD dwAccess = default; + + public this(void* pNext = null, SECURITY_ATTRIBUTES* pAttributes = null, DWORD dwAccess = default) : this() + { + this.pNext = pNext; + this.pAttributes = pAttributes; + this.dwAccess = dwAccess; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, out HANDLE pHandle); + +static { public const let VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 2; } +static { public const let VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; } + +[CRepr] struct VkWin32KeyedMutexAcquireReleaseInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 acquireCount = 0; + public VkDeviceMemory* pAcquireSyncs = null; + public uint64* pAcquireKeys = null; + public uint32* pAcquireTimeoutMilliseconds = null; + public uint32 releaseCount = 0; + public VkDeviceMemory* pReleaseSyncs = null; + public uint64* pReleaseKeys = null; + + public this(void* pNext, uint32 acquireCount, VkDeviceMemory* pAcquireSyncs, uint64* pAcquireKeys, uint32* pAcquireTimeoutMilliseconds, uint32 releaseCount, VkDeviceMemory* pReleaseSyncs, uint64* pReleaseKeys) : this() + { + this.pNext = pNext; + this.acquireCount = acquireCount; + this.pAcquireSyncs = pAcquireSyncs; + this.pAcquireKeys = pAcquireKeys; + this.pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds; + this.releaseCount = releaseCount; + this.pReleaseSyncs = pReleaseSyncs; + this.pReleaseKeys = pReleaseKeys; + } +} + +static { public const let VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION = 2; } +static { public const let VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME = "VK_KHR_get_physical_device_properties2"; } + +typealias VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2; +typealias VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2; +typealias VkFormatProperties2KHR = VkFormatProperties2; +typealias VkImageFormatProperties2KHR = VkImageFormatProperties2; +typealias VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2; +typealias VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2; +typealias VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2; +typealias VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2; +typealias VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2; + +typealias PFN_vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2; +typealias PFN_vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2; +typealias PFN_vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2; +typealias PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2; +typealias PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2; +typealias PFN_vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2; +typealias PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2; + +static { public const let VK_KHR_DEVICE_GROUP_SPEC_VERSION = 4; } +static { public const let VK_KHR_DEVICE_GROUP_EXTENSION_NAME = "VK_KHR_device_group"; } + +typealias VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlags; +typealias VkPeerMemoryFeatureFlagBitsKHR = VkPeerMemoryFeatureFlagBits; +typealias VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlags; +typealias VkMemoryAllocateFlagBitsKHR = VkMemoryAllocateFlagBits; +typealias VkMemoryAllocateFlagsInfoKHR = VkMemoryAllocateFlagsInfo; +typealias VkDeviceGroupRenderPassBeginInfoKHR = VkDeviceGroupRenderPassBeginInfo; +typealias VkDeviceGroupCommandBufferBeginInfoKHR = VkDeviceGroupCommandBufferBeginInfo; +typealias VkDeviceGroupSubmitInfoKHR = VkDeviceGroupSubmitInfo; +typealias VkDeviceGroupBindSparseInfoKHR = VkDeviceGroupBindSparseInfo; + +typealias PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeatures; +typealias PFN_vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMask; +typealias PFN_vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBase; + +typealias VkBindBufferMemoryDeviceGroupInfoKHR = VkBindBufferMemoryDeviceGroupInfo; +typealias VkBindImageMemoryDeviceGroupInfoKHR = VkBindImageMemoryDeviceGroupInfo; + +static { public const let VK_EXT_VALIDATION_FLAGS_SPEC_VERSION = 3; } +static { public const let VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME = "VK_EXT_validation_flags"; } + +[CRepr] struct VkValidationFlagsEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; + public VkStructureType sType = SType; // Must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT + public void* pNext = null; + public uint32 disabledValidationCheckCount = 0; // Number of validation checks to disable + public VkValidationCheckEXT* pDisabledValidationChecks = null; // Validation checks to disable + public Span disabledValidationChecks + { + get { return .(pDisabledValidationChecks, (.)disabledValidationCheckCount); } + set mut { pDisabledValidationChecks = value.Ptr; disabledValidationCheckCount = (.)value.Length; } + } + + public this(void* pNext, Span disabledValidationChecks) : this() + { + this.pNext = pNext; + this.disabledValidationChecks = disabledValidationChecks; + } +} + +[AllowDuplicates] enum VkValidationCheckEXT : int32 +{ + [NoShow] VK_VALIDATION_CHECK_ALL_EXT = 0, + [NoShow] VK_VALIDATION_CHECK_SHADERS_EXT = 1, + // pretty names + AllEXT = 0, + ShadersEXT = 1, +} + +static { public const let VK_NN_VI_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; } + +typealias VkViSurfaceCreateFlagsNN = VkFlags; + +[CRepr] struct VkViSurfaceCreateInfoNN : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; + public VkStructureType sType = SType; + public void* pNext = null; + public VkViSurfaceCreateFlagsNN flags = default; + public void* window = null; + + public this(void* pNext, VkViSurfaceCreateFlagsNN flags, void* window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.window = window; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateViSurfaceNN(VkInstance instance, VkViSurfaceCreateInfoNN* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME = "VK_KHR_shader_draw_parameters"; } +static { public const let VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME = "VK_EXT_shader_subgroup_ballot"; } +static { public const let VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME = "VK_EXT_shader_subgroup_vote"; } +static { public const let VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION = 1; } +static { public const let VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME = "VK_EXT_texture_compression_astc_hdr"; } + +typealias VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + +static { public const let VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION = 1; } +static { public const let VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME = "VK_EXT_astc_decode_mode"; } + +[CRepr] struct VkImageViewASTCDecodeModeEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat decodeMode = default; + + public this(void* pNext, VkFormat decodeMode) : this() + { + this.pNext = pNext; + this.decodeMode = decodeMode; + } +} + +[CRepr] struct VkPhysicalDeviceASTCDecodeFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 decodeModeSharedExponent = false; + + public this(void* pNext, VkBool32 decodeModeSharedExponent) : this() + { + this.pNext = pNext; + this.decodeModeSharedExponent = decodeModeSharedExponent; + } +} + +static { public const let VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION = 1; } +static { public const let VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME = "VK_EXT_pipeline_robustness"; } + +typealias VkPhysicalDevicePipelineRobustnessFeaturesEXT = VkPhysicalDevicePipelineRobustnessFeatures; +typealias VkPhysicalDevicePipelineRobustnessPropertiesEXT = VkPhysicalDevicePipelineRobustnessProperties; +typealias VkPipelineRobustnessCreateInfoEXT = VkPipelineRobustnessCreateInfo; +typealias VkPipelineRobustnessBufferBehaviorEXT = VkPipelineRobustnessBufferBehavior; +typealias VkPipelineRobustnessImageBehaviorEXT = VkPipelineRobustnessImageBehavior; + +static { public const let VK_KHR_MAINTENANCE_1_SPEC_VERSION = 2; } +static { public const let VK_KHR_MAINTENANCE_1_EXTENSION_NAME = "VK_KHR_maintenance1"; } +static { public const let VK_KHR_MAINTENANCE1_SPEC_VERSION = VK_KHR_MAINTENANCE_1_SPEC_VERSION; } +static { public const let VK_KHR_MAINTENANCE1_EXTENSION_NAME = VK_KHR_MAINTENANCE_1_EXTENSION_NAME; } + +typealias VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlags; + +typealias PFN_vkTrimCommandPoolKHR = PFN_vkTrimCommandPool; + +static { public const let VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION = 1; } +static { public const let VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME = "VK_KHR_device_group_creation"; } +static { public const let VK_MAX_DEVICE_GROUP_SIZE_KHR = VK_MAX_DEVICE_GROUP_SIZE; } + +typealias VkPhysicalDeviceGroupPropertiesKHR = VkPhysicalDeviceGroupProperties; +typealias VkDeviceGroupDeviceCreateInfoKHR = VkDeviceGroupDeviceCreateInfo; + +typealias PFN_vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroups; + +static { public const let VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_memory_capabilities"; } +static { public const let VK_LUID_SIZE_KHR = VK_LUID_SIZE; } + +typealias VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlags; +typealias VkExternalMemoryHandleTypeFlagBitsKHR = VkExternalMemoryHandleTypeFlagBits; +typealias VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlags; +typealias VkExternalMemoryFeatureFlagBitsKHR = VkExternalMemoryFeatureFlagBits; +typealias VkExternalMemoryPropertiesKHR = VkExternalMemoryProperties; +typealias VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfo; +typealias VkExternalImageFormatPropertiesKHR = VkExternalImageFormatProperties; +typealias VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfo; +typealias VkExternalBufferPropertiesKHR = VkExternalBufferProperties; +typealias VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDProperties; + +typealias PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferProperties; + +static { public const let VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_KHR_external_memory"; } +static { public const let VK_QUEUE_FAMILY_EXTERNAL_KHR = VK_QUEUE_FAMILY_EXTERNAL; } + +typealias VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfo; +typealias VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfo; +typealias VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfo; + +static { public const let VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHR_external_memory_win32"; } + +[CRepr] struct VkImportMemoryWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + public HANDLE handle = default; + public LPCWSTR name = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagBits handleType = default, HANDLE handle = default, LPCWSTR name = default) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.handle = handle; + this.name = name; + } +} + +[CRepr] struct VkExportMemoryWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public SECURITY_ATTRIBUTES* pAttributes = null; + public DWORD dwAccess = default; + public LPCWSTR name = default; + + public this(void* pNext, SECURITY_ATTRIBUTES* pAttributes, DWORD dwAccess, LPCWSTR name) : this() + { + this.pNext = pNext; + this.pAttributes = pAttributes; + this.dwAccess = dwAccess; + this.name = name; + } +} + +[CRepr] struct VkMemoryWin32HandlePropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkMemoryGetWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.memory = memory; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryWin32HandleKHR(VkDevice device, VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, out VkMemoryWin32HandlePropertiesKHR pMemoryWin32HandleProperties); + +static { public const let VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME = "VK_KHR_external_memory_fd"; } + +[CRepr] struct VkImportMemoryFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + public c_int fd = default; + + public this(void* pNext, VkExternalMemoryHandleTypeFlagBits handleType, c_int fd) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.fd = fd; + } +} + +[CRepr] struct VkMemoryFdPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkMemoryGetFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.memory = memory; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryFdKHR(VkDevice device, VkMemoryGetFdInfoKHR* pGetFdInfo, out c_int pFd); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, c_int fd, out VkMemoryFdPropertiesKHR pMemoryFdProperties); + +static { public const let VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; } +static { public const let VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHR_win32_keyed_mutex"; } + +[CRepr] struct VkWin32KeyedMutexAcquireReleaseInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 acquireCount = 0; + public VkDeviceMemory* pAcquireSyncs = null; + public uint64* pAcquireKeys = null; + public uint32* pAcquireTimeouts = null; + public uint32 releaseCount = 0; + public VkDeviceMemory* pReleaseSyncs = null; + public uint64* pReleaseKeys = null; + + public this(void* pNext, uint32 acquireCount, VkDeviceMemory* pAcquireSyncs, uint64* pAcquireKeys, uint32* pAcquireTimeouts, uint32 releaseCount, VkDeviceMemory* pReleaseSyncs, uint64* pReleaseKeys) : this() + { + this.pNext = pNext; + this.acquireCount = acquireCount; + this.pAcquireSyncs = pAcquireSyncs; + this.pAcquireKeys = pAcquireKeys; + this.pAcquireTimeouts = pAcquireTimeouts; + this.releaseCount = releaseCount; + this.pReleaseSyncs = pReleaseSyncs; + this.pReleaseKeys = pReleaseKeys; + } +} + +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_semaphore_capabilities"; } + +typealias VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlags; +typealias VkExternalSemaphoreHandleTypeFlagBitsKHR = VkExternalSemaphoreHandleTypeFlagBits; +typealias VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlags; +typealias VkExternalSemaphoreFeatureFlagBitsKHR = VkExternalSemaphoreFeatureFlagBits; +typealias VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfo; +typealias VkExternalSemaphorePropertiesKHR = VkExternalSemaphoreProperties; + +typealias PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties; + +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_KHR_external_semaphore"; } + +typealias VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlags; +typealias VkSemaphoreImportFlagBitsKHR = VkSemaphoreImportFlagBits; +typealias VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfo; + +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHR_external_semaphore_win32"; } + +[CRepr] struct VkImportSemaphoreWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkSemaphoreImportFlags flags = default; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + public HANDLE handle = default; + public LPCWSTR name = default; + + public this(void* pNext, VkSemaphore semaphore, VkSemaphoreImportFlags flags, VkExternalSemaphoreHandleTypeFlagBits handleType, HANDLE handle = default, LPCWSTR name = default) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.flags = flags; + this.handleType = handleType; + this.handle = handle; + this.name = name; + } +} + +[CRepr] struct VkExportSemaphoreWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public SECURITY_ATTRIBUTES* pAttributes = null; + public DWORD dwAccess = default; + public LPCWSTR name = default; + + public this(void* pNext, SECURITY_ATTRIBUTES* pAttributes, DWORD dwAccess, LPCWSTR name) : this() + { + this.pNext = pNext; + this.pAttributes = pAttributes; + this.dwAccess = dwAccess; + this.name = name; + } +} + +[CRepr] struct VkD3D12FenceSubmitInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 waitSemaphoreValuesCount = 0; + public uint64* pWaitSemaphoreValues = null; + public Span waitSemaphoreValues + { + get { return .(pWaitSemaphoreValues, (.)waitSemaphoreValuesCount); } + set mut { pWaitSemaphoreValues = value.Ptr; waitSemaphoreValuesCount = (.)value.Length; } + } + public uint32 signalSemaphoreValuesCount = 0; + public uint64* pSignalSemaphoreValues = null; + public Span signalSemaphoreValues + { + get { return .(pSignalSemaphoreValues, (.)signalSemaphoreValuesCount); } + set mut { pSignalSemaphoreValues = value.Ptr; signalSemaphoreValuesCount = (.)value.Length; } + } + + public this(void* pNext = null, Span waitSemaphoreValues = default, Span signalSemaphoreValues = default) : this() + { + this.pNext = pNext; + this.waitSemaphoreValues = waitSemaphoreValues; + this.signalSemaphoreValues = signalSemaphoreValues; + } +} + +[CRepr] struct VkSemaphoreGetWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkImportSemaphoreWin32HandleKHR(VkDevice device, VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSemaphoreWin32HandleKHR(VkDevice device, VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle); + +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = "VK_KHR_external_semaphore_fd"; } + +[CRepr] struct VkImportSemaphoreFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkSemaphoreImportFlags flags = default; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + public c_int fd = default; + + public this(void* pNext, VkSemaphore semaphore, VkSemaphoreImportFlags flags, VkExternalSemaphoreHandleTypeFlagBits handleType, c_int fd) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.flags = flags; + this.handleType = handleType; + this.fd = fd; + } +} + +[CRepr] struct VkSemaphoreGetFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkImportSemaphoreFdKHR(VkDevice device, VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSemaphoreFdKHR(VkDevice device, VkSemaphoreGetFdInfoKHR* pGetFdInfo, out c_int pFd); + +static { public const let VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION = 2; } +static { public const let VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME = "VK_KHR_push_descriptor"; } + +typealias PFN_vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSet; + +typealias VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorProperties; + +typealias PFN_vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplate; + +static { public const let VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION = 2; } +static { public const let VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME = "VK_EXT_conditional_rendering"; } + +typealias VkConditionalRenderingFlagsEXT = VkConditionalRenderingFlagBitsEXT; + +[AllowDuplicates] enum VkConditionalRenderingFlagBitsEXT : int32 +{ + [NoShow] VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1 << 0, + // pretty names + InvertedEXT = 1 << 0, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer); + +[CRepr] struct VkConditionalRenderingBeginInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + public VkDeviceSize offset = default; + public VkConditionalRenderingFlagsEXT flags = default; + + public this(void* pNext, VkBuffer buffer, VkDeviceSize offset, VkConditionalRenderingFlagsEXT flags = default) : this() + { + this.pNext = pNext; + this.buffer = buffer; + this.offset = offset; + this.flags = flags; + } +} + +[CRepr] struct VkPhysicalDeviceConditionalRenderingFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 conditionalRendering = false; + public VkBool32 inheritedConditionalRendering = false; + + public this(void* pNext, VkBool32 conditionalRendering, VkBool32 inheritedConditionalRendering) : this() + { + this.pNext = pNext; + this.conditionalRendering = conditionalRendering; + this.inheritedConditionalRendering = inheritedConditionalRendering; + } +} + +[CRepr] struct VkCommandBufferInheritanceConditionalRenderingInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 conditionalRenderingEnable = false; // Whether this secondary command buffer may be executed during an active conditional rendering + + public this(void* pNext, VkBool32 conditionalRenderingEnable) : this() + { + this.pNext = pNext; + this.conditionalRenderingEnable = conditionalRenderingEnable; + } +} + +static { public const let VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME = "VK_KHR_shader_float16_int8"; } + +typealias VkPhysicalDeviceShaderFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features; +typealias VkPhysicalDeviceFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features; + +static { public const let VK_KHR_16BIT_STORAGE_SPEC_VERSION = 1; } +static { public const let VK_KHR_16BIT_STORAGE_EXTENSION_NAME = "VK_KHR_16bit_storage"; } + +typealias VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeatures; + +static { public const let VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION = 2; } +static { public const let VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME = "VK_KHR_incremental_present"; } + +[CRepr] struct VkPresentRegionsKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public VkPresentRegionKHR* pRegions = null; // The regions that have changed + public Span regions + { + get { return .(pRegions, (.)swapchainCount); } + set mut { pRegions = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span regions = default) : this() + { + this.pNext = pNext; + this.regions = regions; + } +} + +[CRepr] struct VkPresentRegionKHR : this() +{ + public uint32 rectangleCount = 0; // Number of rectangles in pRectangles + public VkRectLayerKHR* pRectangles = null; // Array of rectangles that have changed in a swapchain's image(s) + public Span rectangles + { + get { return .(pRectangles, (.)rectangleCount); } + set mut { pRectangles = value.Ptr; rectangleCount = (.)value.Length; } + } + + public this(Span rectangles = default) : this() + { + this.rectangles = rectangles; + } +} + +[CRepr] struct VkRectLayerKHR : this() +{ + public VkOffset2D offset = default; // upper-left corner of a rectangle that has not changed, in pixels of a presentation images + public VkExtent2D extent = default; // Dimensions of a rectangle that has not changed, in pixels of a presentation images + public uint32 layer = 0; // Layer of a swapchain's image(s), for stereoscopic-3D images + + public this(VkOffset2D offset, VkExtent2D extent, uint32 layer) : this() + { + this.offset = offset; + this.extent = extent; + this.layer = layer; + } +} + +static { public const let VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION = 1; } +static { public const let VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME = "VK_KHR_descriptor_update_template"; } + +typealias PFN_vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplate; +typealias PFN_vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplate; +typealias PFN_vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplate; + +typealias VkDescriptorUpdateTemplateKHR = VkDescriptorUpdateTemplate; +typealias VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlags; +typealias VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateType; +typealias VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntry; +typealias VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfo; + +static { public const let VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION = 1; } +static { public const let VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME = "VK_NV_clip_space_w_scaling"; } + +[CRepr] struct VkViewportWScalingNV : this() +{ + public float xcoeff = 0; + public float ycoeff = 0; + + public this(float xcoeff, float ycoeff) : this() + { + this.xcoeff = xcoeff; + this.ycoeff = ycoeff; + } +} + +[CRepr] struct VkPipelineViewportWScalingStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 viewportWScalingEnable = false; + public uint32 viewportCount = 0; + public VkViewportWScalingNV* pViewportWScalings = null; + public Span viewportWScalings + { + get { return .(pViewportWScalings, (.)viewportCount); } + set mut { pViewportWScalings = value.Ptr; viewportCount = (.)value.Length; } + } + + public this(void* pNext, VkBool32 viewportWScalingEnable, Span viewportWScalings = default) : this() + { + this.pNext = pNext; + this.viewportWScalingEnable = viewportWScalingEnable; + this.viewportWScalings = viewportWScalings; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewportWScalingNV* pViewportWScalings); + +static { public const let VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION = 1; } +static { public const let VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME = "VK_EXT_direct_mode_display"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +static { public const let VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; } +static { public const let VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, out Display dpy, VkDisplayKHR display); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, out Display dpy, RROutput rrOutput, out VkDisplayKHR pDisplay); + +static { public const let VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION = 1; } +static { public const let VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME = "VK_EXT_display_surface_counter"; } + +typealias VkSurfaceCounterFlagsEXT = VkSurfaceCounterFlagBitsEXT; + +[AllowDuplicates] enum VkSurfaceCounterFlagBitsEXT : int32 +{ + [NoShow] VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 1 << 0, + [NoShow] VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, + // pretty names + VblankEXT = 1 << 0, +} + +[CRepr] struct VkSurfaceCapabilities2EXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 minImageCount = 0; // Supported minimum number of images for the surface + public uint32 maxImageCount = 0; // Supported maximum number of images for the surface, 0 for unlimited + public VkExtent2D currentExtent = default; // Current image width and height for the surface, (0, 0) if undefined + public VkExtent2D minImageExtent = default; // Supported minimum image width and height for the surface + public VkExtent2D maxImageExtent = default; // Supported maximum image width and height for the surface + public uint32 maxImageArrayLayers = 0; // Supported maximum number of image layers for the surface + public VkSurfaceTransformFlagsKHR supportedTransforms = default; // 1 or more bits representing the transforms supported + public VkSurfaceTransformFlagBitsKHR currentTransform = default; // The surface's current transform relative to the device's natural orientation + public VkCompositeAlphaFlagsKHR supportedCompositeAlpha = default; // 1 or more bits representing the alpha compositing modes supported + public VkImageUsageFlags supportedUsageFlags = default; // Supported image usage flags for the surface + public VkSurfaceCounterFlagsEXT supportedSurfaceCounters = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out VkSurfaceCapabilities2EXT pSurfaceCapabilities); + +static { public const let VK_EXT_DISPLAY_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME = "VK_EXT_display_control"; } + +[AllowDuplicates] enum VkDisplayPowerStateEXT : int32 +{ + [NoShow] VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + [NoShow] VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + [NoShow] VK_DISPLAY_POWER_STATE_ON_EXT = 2, + // pretty names + OffEXT = 0, + SuspendEXT = 1, + OnEXT = 2, +} + +[AllowDuplicates] enum VkDeviceEventTypeEXT : int32 +{ + [NoShow] VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + // pretty names + DisplayHotplugEXT = 0, +} + +[AllowDuplicates] enum VkDisplayEventTypeEXT : int32 +{ + [NoShow] VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + // pretty names + FirstPixelOutEXT = 0, +} + +[CRepr] struct VkDisplayPowerInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayPowerStateEXT powerState = default; + + public this(void* pNext, VkDisplayPowerStateEXT powerState) : this() + { + this.pNext = pNext; + this.powerState = powerState; + } +} + +[CRepr] struct VkDeviceEventInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceEventTypeEXT deviceEvent = default; + + public this(void* pNext, VkDeviceEventTypeEXT deviceEvent) : this() + { + this.pNext = pNext; + this.deviceEvent = deviceEvent; + } +} + +[CRepr] struct VkDisplayEventInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayEventTypeEXT displayEvent = default; + + public this(void* pNext, VkDisplayEventTypeEXT displayEvent) : this() + { + this.pNext = pNext; + this.displayEvent = displayEvent; + } +} + +[CRepr] struct VkSwapchainCounterCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceCounterFlagsEXT surfaceCounters = default; + + public this(void* pNext = null, VkSurfaceCounterFlagsEXT surfaceCounters = default) : this() + { + this.pNext = pNext; + this.surfaceCounters = surfaceCounters; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, VkDisplayPowerInfoEXT* pDisplayPowerInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkRegisterDeviceEventEXT(VkDevice device, VkDeviceEventInfoEXT* pDeviceEventInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, VkDisplayEventInfoEXT* pDisplayEventInfo, VkAllocationCallbacks* pAllocator, out VkFence pFence); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, out uint64 pCounterValue); + +static { public const let VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION = 1; } +static { public const let VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME = "VK_GOOGLE_display_timing"; } + +[CRepr] struct VkRefreshCycleDurationGOOGLE : this() +{ + public uint64 refreshDuration = 0; // Number of nanoseconds from the start of one refresh cycle to the next +} + +[CRepr] struct VkPastPresentationTimingGOOGLE : this() +{ + public uint32 presentID = 0; // Application-provided identifier, previously given to vkQueuePresentKHR + public uint64 desiredPresentTime = 0; // Earliest time an image should have been presented, previously given to vkQueuePresentKHR + public uint64 actualPresentTime = 0; // Time the image was actually displayed + public uint64 earliestPresentTime = 0; // Earliest time the image could have been displayed + public uint64 presentMargin = 0; // How early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime +} + +[CRepr] struct VkPresentTimesInfoGOOGLE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public VkPresentTimeGOOGLE* pTimes = null; // The earliest times to present images + public Span times + { + get { return .(pTimes, (.)swapchainCount); } + set mut { pTimes = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span times = default) : this() + { + this.pNext = pNext; + this.times = times; + } +} + +[CRepr] struct VkPresentTimeGOOGLE : this() +{ + public uint32 presentID = 0; // Application-provided identifier + public uint64 desiredPresentTime = 0; // Earliest time an image should be presented + + public this(uint32 presentID, uint64 desiredPresentTime) : this() + { + this.presentID = presentID; + this.desiredPresentTime = desiredPresentTime; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, out VkRefreshCycleDurationGOOGLE pDisplayTimingProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, out uint32 pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings = null); + +static { public const let VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION = 1; } +static { public const let VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME = "VK_NV_sample_mask_override_coverage"; } +static { public const let VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION = 1; } +static { public const let VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME = "VK_NV_geometry_shader_passthrough"; } +static { public const let VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION = 1; } +static { public const let VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME = "VK_NV_viewport_array2"; } +static { public const let VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION; } +static { public const let VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME; } +static { public const let VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION = 1; } +static { public const let VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME = "VK_NVX_multiview_per_view_attributes"; } + +[CRepr] struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 perViewPositionAllComponents = false; +} + +[CRepr] struct VkMultiviewPerViewAttributesInfoNVX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 perViewAttributes = false; + public VkBool32 perViewAttributesPositionXOnly = false; + + public this(void* pNext, VkBool32 perViewAttributes, VkBool32 perViewAttributesPositionXOnly) : this() + { + this.pNext = pNext; + this.perViewAttributes = perViewAttributes; + this.perViewAttributesPositionXOnly = perViewAttributesPositionXOnly; + } +} + +static { public const let VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION = 1; } +static { public const let VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME = "VK_NV_viewport_swizzle"; } + +[CRepr] struct VkViewportSwizzleNV : this() +{ + public VkViewportCoordinateSwizzleNV x = default; + public VkViewportCoordinateSwizzleNV y = default; + public VkViewportCoordinateSwizzleNV z = default; + public VkViewportCoordinateSwizzleNV w = default; + + public this(VkViewportCoordinateSwizzleNV x, VkViewportCoordinateSwizzleNV y, VkViewportCoordinateSwizzleNV z, VkViewportCoordinateSwizzleNV w) : this() + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } +} + +[AllowDuplicates] enum VkViewportCoordinateSwizzleNV : int32 +{ + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + [NoShow] VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + // pretty names + PositiveXNV = 0, + NegativeXNV = 1, + PositiveYNV = 2, + NegativeYNV = 3, + PositiveZNV = 4, + NegativeZNV = 5, + PositiveWNV = 6, + NegativeWNV = 7, +} + +[CRepr] struct VkPipelineViewportSwizzleStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineViewportSwizzleStateCreateFlagsNV flags = default; + public uint32 viewportCount = 0; + public VkViewportSwizzleNV* pViewportSwizzles = null; + public Span viewportSwizzles + { + get { return .(pViewportSwizzles, (.)viewportCount); } + set mut { pViewportSwizzles = value.Ptr; viewportCount = (.)value.Length; } + } + + public this(void* pNext, VkPipelineViewportSwizzleStateCreateFlagsNV flags, Span viewportSwizzles) : this() + { + this.pNext = pNext; + this.flags = flags; + this.viewportSwizzles = viewportSwizzles; + } +} + +typealias VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags; + +static { public const let VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION = 2; } +static { public const let VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME = "VK_EXT_discard_rectangles"; } + +[CRepr] struct VkPhysicalDeviceDiscardRectanglePropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxDiscardRectangles = 0; // max number of active discard rectangles +} + +[CRepr] struct VkPipelineDiscardRectangleStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineDiscardRectangleStateCreateFlagsEXT flags = default; + public VkDiscardRectangleModeEXT discardRectangleMode = default; + public uint32 discardRectangleCount = 0; + public VkRect2D* pDiscardRectangles = null; + public Span discardRectangles + { + get { return .(pDiscardRectangles, (.)discardRectangleCount); } + set mut { pDiscardRectangles = value.Ptr; discardRectangleCount = (.)value.Length; } + } + + public this(void* pNext, VkPipelineDiscardRectangleStateCreateFlagsEXT flags, VkDiscardRectangleModeEXT discardRectangleMode, Span discardRectangles = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.discardRectangleMode = discardRectangleMode; + this.discardRectangles = discardRectangles; + } +} + +typealias VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags; + +[AllowDuplicates] enum VkDiscardRectangleModeEXT : int32 +{ + [NoShow] VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + [NoShow] VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + // pretty names + InclusiveEXT = 0, + ExclusiveEXT = 1, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32 firstDiscardRectangle, uint32 discardRectangleCount, VkRect2D* pDiscardRectangles); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); + +static { public const let VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION = 1; } +static { public const let VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME = "VK_EXT_conservative_rasterization"; } + +[CRepr] struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public float primitiveOverestimationSize = 0; // The size in pixels the primitive is enlarged at each edge during conservative rasterization + public float maxExtraPrimitiveOverestimationSize = 0; // The maximum additional overestimation the client can specify in the pipeline state + public float extraPrimitiveOverestimationSizeGranularity = 0; // The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize + public VkBool32 primitiveUnderestimation = false; // true if the implementation supports conservative rasterization underestimation mode + public VkBool32 conservativePointAndLineRasterization = false; // true if conservative rasterization also applies to points and lines + public VkBool32 degenerateTrianglesRasterized = false; // true if degenerate triangles (those with zero area after snap) are rasterized + public VkBool32 degenerateLinesRasterized = false; // true if degenerate lines (those with zero length after snap) are rasterized + public VkBool32 fullyCoveredFragmentShaderInputVariable = false; // true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable + public VkBool32 conservativeRasterizationPostDepthCoverage = false; // true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask +} + +[CRepr] struct VkPipelineRasterizationConservativeStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRasterizationConservativeStateCreateFlagsEXT flags = default; // Reserved + public VkConservativeRasterizationModeEXT conservativeRasterizationMode = default; // Conservative rasterization mode + public float extraPrimitiveOverestimationSize = 0; // Extra overestimation to add to the primitive + + public this(void* pNext, VkPipelineRasterizationConservativeStateCreateFlagsEXT flags, VkConservativeRasterizationModeEXT conservativeRasterizationMode, float extraPrimitiveOverestimationSize) : this() + { + this.pNext = pNext; + this.flags = flags; + this.conservativeRasterizationMode = conservativeRasterizationMode; + this.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize; + } +} + +typealias VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkFlags; + +[AllowDuplicates] enum VkConservativeRasterizationModeEXT : int32 +{ + [NoShow] VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + [NoShow] VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + [NoShow] VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + // pretty names + DisabledEXT = 0, + OverestimateEXT = 1, + UnderestimateEXT = 2, +} + +static { public const let VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME = "VK_EXT_depth_clip_enable"; } + +[CRepr] struct VkPhysicalDeviceDepthClipEnableFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 depthClipEnable = false; + + public this(void* pNext, VkBool32 depthClipEnable) : this() + { + this.pNext = pNext; + this.depthClipEnable = depthClipEnable; + } +} + +[CRepr] struct VkPipelineRasterizationDepthClipStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags = default; // Reserved + public VkBool32 depthClipEnable = false; + + public this(void* pNext, VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags, VkBool32 depthClipEnable) : this() + { + this.pNext = pNext; + this.flags = flags; + this.depthClipEnable = depthClipEnable; + } +} + +typealias VkPipelineRasterizationDepthClipStateCreateFlagsEXT = VkFlags; + +static { public const let VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION = 5; } +static { public const let VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME = "VK_EXT_swapchain_colorspace"; } +static { public const let VK_EXT_HDR_METADATA_SPEC_VERSION = 3; } +static { public const let VK_EXT_HDR_METADATA_EXTENSION_NAME = "VK_EXT_hdr_metadata"; } + +[CRepr] struct VkHdrMetadataEXT : this() +{ + + public const VkStructureType SType = .VK_STRUCTURE_TYPE_HDR_METADATA_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + + public VkXYColorEXT displayPrimaryRed = default; // Display primary's Red + public VkXYColorEXT displayPrimaryGreen = default; // Display primary's Green + public VkXYColorEXT displayPrimaryBlue = default; // Display primary's Blue + public VkXYColorEXT whitePoint = default; // Display primary's Blue + public float maxLuminance = 0; // Display maximum luminance + public float minLuminance = 0; // Display minimum luminance + + public float maxContentLightLevel = 0; // Content maximum luminance + public float maxFrameAverageLightLevel = 0; + + public this(void* pNext, VkXYColorEXT displayPrimaryRed, VkXYColorEXT displayPrimaryGreen, VkXYColorEXT displayPrimaryBlue, VkXYColorEXT whitePoint, float maxLuminance, float minLuminance, float maxContentLightLevel, float maxFrameAverageLightLevel) : this() + { + this.pNext = pNext; + this.displayPrimaryRed = displayPrimaryRed; + this.displayPrimaryGreen = displayPrimaryGreen; + this.displayPrimaryBlue = displayPrimaryBlue; + this.whitePoint = whitePoint; + this.maxLuminance = maxLuminance; + this.minLuminance = minLuminance; + this.maxContentLightLevel = maxContentLightLevel; + this.maxFrameAverageLightLevel = maxFrameAverageLightLevel; + } +} + +// Chromaticity coordinate +[CRepr] struct VkXYColorEXT : this() +{ + public float x = 0; + public float y = 0; + + public this(float x, float y) : this() + { + this.x = x; + this.y = y; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkSetHdrMetadataEXT(VkDevice device, uint32 swapchainCount, VkSwapchainKHR* pSwapchains, VkHdrMetadataEXT* pMetadata); + +static { public const let VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION = 1; } +static { public const let VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME = "VK_KHR_imageless_framebuffer"; } + +typealias VkPhysicalDeviceImagelessFramebufferFeaturesKHR = VkPhysicalDeviceImagelessFramebufferFeatures; +typealias VkFramebufferAttachmentsCreateInfoKHR = VkFramebufferAttachmentsCreateInfo; +typealias VkFramebufferAttachmentImageInfoKHR = VkFramebufferAttachmentImageInfo; +typealias VkRenderPassAttachmentBeginInfoKHR = VkRenderPassAttachmentBeginInfo; + +static { public const let VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME = "VK_KHR_create_renderpass2"; } + +typealias PFN_vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2; +typealias PFN_vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2; +typealias PFN_vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2; +typealias PFN_vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2; + +typealias VkRenderPassCreateInfo2KHR = VkRenderPassCreateInfo2; +typealias VkAttachmentDescription2KHR = VkAttachmentDescription2; +typealias VkAttachmentReference2KHR = VkAttachmentReference2; +typealias VkSubpassDescription2KHR = VkSubpassDescription2; +typealias VkSubpassDependency2KHR = VkSubpassDependency2; +typealias VkSubpassBeginInfoKHR = VkSubpassBeginInfo; +typealias VkSubpassEndInfoKHR = VkSubpassEndInfo; + +static { public const let VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION = 1; } +static { public const let VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME = "VK_IMG_relaxed_line_rasterization"; } + +[CRepr] struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 relaxedLineRasterization = false; + + public this(void* pNext, VkBool32 relaxedLineRasterization) : this() + { + this.pNext = pNext; + this.relaxedLineRasterization = relaxedLineRasterization; + } +} + +static { public const let VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME = "VK_KHR_shared_presentable_image"; } + +[CRepr] struct VkSharedPresentSurfaceCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageUsageFlags sharedPresentSupportedUsageFlags = default; // Supported image usage flags if swapchain created using a shared present mode +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain); + +static { public const let VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_fence_capabilities"; } + +typealias VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlags; +typealias VkExternalFenceHandleTypeFlagBitsKHR = VkExternalFenceHandleTypeFlagBits; +typealias VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlags; +typealias VkExternalFenceFeatureFlagBitsKHR = VkExternalFenceFeatureFlagBits; +typealias VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfo; +typealias VkExternalFencePropertiesKHR = VkExternalFenceProperties; + +typealias PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFenceProperties; + +static { public const let VK_KHR_EXTERNAL_FENCE_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME = "VK_KHR_external_fence"; } + +typealias VkFenceImportFlagsKHR = VkFenceImportFlags; +typealias VkFenceImportFlagBitsKHR = VkFenceImportFlagBits; +typealias VkExportFenceCreateInfoKHR = VkExportFenceCreateInfo; + +static { public const let VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = "VK_KHR_external_fence_win32"; } + +[CRepr] struct VkImportFenceWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFence fence = null; + public VkFenceImportFlags flags = default; + public VkExternalFenceHandleTypeFlagBits handleType = default; + public HANDLE handle = default; + public LPCWSTR name = default; + + public this(void* pNext, VkFence fence, VkFenceImportFlags flags, VkExternalFenceHandleTypeFlagBits handleType, HANDLE handle = default, LPCWSTR name = default) : this() + { + this.pNext = pNext; + this.fence = fence; + this.flags = flags; + this.handleType = handleType; + this.handle = handle; + this.name = name; + } +} + +[CRepr] struct VkExportFenceWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public SECURITY_ATTRIBUTES* pAttributes = null; + public DWORD dwAccess = default; + public LPCWSTR name = default; + + public this(void* pNext, SECURITY_ATTRIBUTES* pAttributes, DWORD dwAccess, LPCWSTR name) : this() + { + this.pNext = pNext; + this.pAttributes = pAttributes; + this.dwAccess = dwAccess; + this.name = name; + } +} + +[CRepr] struct VkFenceGetWin32HandleInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFence fence = null; + public VkExternalFenceHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkFence fence, VkExternalFenceHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.fence = fence; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkImportFenceWin32HandleKHR(VkDevice device, VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetFenceWin32HandleKHR(VkDevice device, VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, out HANDLE pHandle); + +static { public const let VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION = 1; } +static { public const let VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME = "VK_KHR_external_fence_fd"; } + +[CRepr] struct VkImportFenceFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFence fence = null; + public VkFenceImportFlags flags = default; + public VkExternalFenceHandleTypeFlagBits handleType = default; + public c_int fd = default; + + public this(void* pNext, VkFence fence, VkFenceImportFlags flags, VkExternalFenceHandleTypeFlagBits handleType, c_int fd) : this() + { + this.pNext = pNext; + this.fence = fence; + this.flags = flags; + this.handleType = handleType; + this.fd = fd; + } +} + +[CRepr] struct VkFenceGetFdInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFence fence = null; + public VkExternalFenceHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkFence fence, VkExternalFenceHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.fence = fence; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkImportFenceFdKHR(VkDevice device, VkImportFenceFdInfoKHR* pImportFenceFdInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetFenceFdKHR(VkDevice device, VkFenceGetFdInfoKHR* pGetFdInfo, out c_int pFd); + +static { public const let VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION = 1; } +static { public const let VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_KHR_performance_query"; } + +[CRepr] struct VkPhysicalDevicePerformanceQueryFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 performanceCounterQueryPools = false; // performance counters supported in query pools + public VkBool32 performanceCounterMultipleQueryPools = false; // performance counters from multiple query pools can be accessed in the same primary command buffer + + public this(void* pNext, VkBool32 performanceCounterQueryPools, VkBool32 performanceCounterMultipleQueryPools) : this() + { + this.pNext = pNext; + this.performanceCounterQueryPools = performanceCounterQueryPools; + this.performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools; + } +} + +[CRepr] struct VkPhysicalDevicePerformanceQueryPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 allowCommandBufferQueryCopies = false; // Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults +} + +[CRepr] struct VkPerformanceCounterKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPerformanceCounterUnitKHR unit = default; + public VkPerformanceCounterScopeKHR @scope = default; + public VkPerformanceCounterStorageKHR storage = default; + public uint8[VK_UUID_SIZE] uuid = .(); +} + +[CRepr] struct VkPerformanceCounterDescriptionKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPerformanceCounterDescriptionFlagsKHR flags = default; + public char8[VK_MAX_DESCRIPTION_SIZE] name = .(); + public char8[VK_MAX_DESCRIPTION_SIZE] category = .(); + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); +} + +typealias VkPerformanceCounterDescriptionFlagsKHR = VkPerformanceCounterDescriptionFlagBitsKHR; + +[AllowDuplicates] enum VkPerformanceCounterDescriptionFlagBitsKHR : int32 +{ + [NoShow] VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 1 << 0, + [NoShow] VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, + [NoShow] VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 1 << 1, + [NoShow] VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, + // pretty names + PerformanceImpactingKHR = 1 << 0, + ConcurrentlyImpactedKHR = 1 << 1, +} + +[CRepr] struct VkQueryPoolPerformanceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 queueFamilyIndex = 0; + public uint32 counterIndexCount = 0; + public uint32* pCounterIndices = null; + public Span counterIndices + { + get { return .(pCounterIndices, (.)counterIndexCount); } + set mut { pCounterIndices = value.Ptr; counterIndexCount = (.)value.Length; } + } + + public this(void* pNext, uint32 queueFamilyIndex, Span counterIndices) : this() + { + this.pNext = pNext; + this.queueFamilyIndex = queueFamilyIndex; + this.counterIndices = counterIndices; + } +} + +[AllowDuplicates] enum VkPerformanceCounterScopeKHR : int32 +{ + [NoShow] VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + [NoShow] VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + [NoShow] VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + [NoShow] VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + [NoShow] VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + [NoShow] VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + // pretty names + CommandBufferKHR = 0, + RenderPassKHR = 1, + CommandKHR = 2, + VkQueryScopeCommandBufferKHR = CommandBufferKHR, + VkQueryScopeRenderPassKHR = RenderPassKHR, + VkQueryScopeCommandKHR = CommandKHR, +} + +[AllowDuplicates] enum VkPerformanceCounterStorageKHR : int32 +{ + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + [NoShow] VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + // pretty names + Int32KHR = 0, + Int64KHR = 1, + Uint32KHR = 2, + Uint64KHR = 3, + Float32KHR = 4, + Float64KHR = 5, +} + +[AllowDuplicates] enum VkPerformanceCounterUnitKHR : int32 +{ + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + [NoShow] VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + // pretty names + GenericKHR = 0, + PercentageKHR = 1, + NanosecondsKHR = 2, + BytesKHR = 3, + BytesPerSecondKHR = 4, + KelvinKHR = 5, + WattsKHR = 6, + VoltsKHR = 7, + AmpsKHR = 8, + HertzKHR = 9, + CyclesKHR = 10, +} + +// Union of all the possible return types a counter result could return +[CRepr, Union] struct VkPerformanceCounterResultKHR : this() +{ + public int32 int32 = 0; + public int64 int64 = 0; + public uint32 uint32 = 0; + public uint64 uint64 = 0; + public float float32 = 0; + public double float64 = 0; + + public this(int32 int32, int64 int64, uint32 uint32, uint64 uint64, float float32, double float64) : this() + { + this.int32 = int32; + this.int64 = int64; + this.uint32 = uint32; + this.uint64 = uint64; + this.float32 = float32; + this.float64 = float64; + } +} + +[CRepr] struct VkAcquireProfilingLockInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAcquireProfilingLockFlagsKHR flags = default; // Acquire profiling lock flags + public uint64 timeout = 0; + + public this(void* pNext, VkAcquireProfilingLockFlagsKHR flags, uint64 timeout) : this() + { + this.pNext = pNext; + this.flags = flags; + this.timeout = timeout; + } +} + +typealias VkAcquireProfilingLockFlagsKHR = VkAcquireProfilingLockFlagBitsKHR; + +[AllowDuplicates] enum VkAcquireProfilingLockFlagBitsKHR : int32 +{ + // pretty names +} + +[CRepr] struct VkPerformanceQuerySubmitInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 counterPassIndex = 0; // Index for which counter pass to submit + + public this(void* pNext, uint32 counterPassIndex) : this() + { + this.pNext = pNext; + this.counterPassIndex = counterPassIndex; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pCounterCount, VkPerformanceCounterKHR* pCounters = null, VkPerformanceCounterDescriptionKHR* pCounterDescriptions = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, out uint32 pNumPasses); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireProfilingLockKHR(VkDevice device, VkAcquireProfilingLockInfoKHR* pInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkReleaseProfilingLockKHR(VkDevice device); + +static { public const let VK_KHR_MAINTENANCE_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_2_EXTENSION_NAME = "VK_KHR_maintenance2"; } +static { public const let VK_KHR_MAINTENANCE2_SPEC_VERSION = VK_KHR_MAINTENANCE_2_SPEC_VERSION; } +static { public const let VK_KHR_MAINTENANCE2_EXTENSION_NAME = VK_KHR_MAINTENANCE_2_EXTENSION_NAME; } + +typealias VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingProperties; +typealias VkPointClippingBehaviorKHR = VkPointClippingBehavior; +typealias VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfo; +typealias VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReference; +typealias VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfo; +typealias VkTessellationDomainOriginKHR = VkTessellationDomainOrigin; +typealias VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfo; + +static { public const let VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME = "VK_KHR_get_surface_capabilities2"; } + +[CRepr] struct VkPhysicalDeviceSurfaceInfo2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceKHR surface = null; + + public this(void* pNext = null, VkSurfaceKHR surface = null) : this() + { + this.pNext = pNext; + this.surface = surface; + } +} + +[CRepr] struct VkSurfaceCapabilities2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceCapabilitiesKHR surfaceCapabilities = default; +} + +[CRepr] struct VkSurfaceFormat2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceFormatKHR surfaceFormat = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkSurfaceCapabilities2KHR pSurfaceCapabilities); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out uint32 pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats = null); + +static { public const let VK_KHR_VARIABLE_POINTERS_SPEC_VERSION = 1; } +static { public const let VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME = "VK_KHR_variable_pointers"; } + +typealias VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures; +typealias VkPhysicalDeviceVariablePointersFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures; + +static { public const let VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME = "VK_KHR_get_display_properties2"; } + +[CRepr] struct VkDisplayProperties2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayPropertiesKHR displayProperties = default; +} + +[CRepr] struct VkDisplayPlaneProperties2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayPlanePropertiesKHR displayPlaneProperties = default; +} + +[CRepr] struct VkDisplayModeProperties2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayModePropertiesKHR displayModeProperties = default; +} + +[CRepr] struct VkDisplayPlaneInfo2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayModeKHR mode = null; + public uint32 planeIndex = 0; + + public this(void* pNext, VkDisplayModeKHR mode, uint32 planeIndex) : this() + { + this.pNext = pNext; + this.mode = mode; + this.planeIndex = planeIndex; + } +} + +[CRepr] struct VkDisplayPlaneCapabilities2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplayPlaneCapabilitiesKHR capabilities = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayProperties2KHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, out uint32 pPropertyCount, VkDisplayModeProperties2KHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, out VkDisplayPlaneCapabilities2KHR pCapabilities); + +static { public const let VK_MVK_IOS_SURFACE_SPEC_VERSION = 3; } +static { public const let VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; } + +typealias VkIOSSurfaceCreateFlagsMVK = VkFlags; + +[CRepr] struct VkIOSSurfaceCreateInfoMVK : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIOSSurfaceCreateFlagsMVK flags = default; + public void* pView = null; + + public this(void* pNext, VkIOSSurfaceCreateFlagsMVK flags, void* pView) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pView = pView; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateIOSSurfaceMVK(VkInstance instance, VkIOSSurfaceCreateInfoMVK* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_MVK_MACOS_SURFACE_SPEC_VERSION = 3; } +static { public const let VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; } + +typealias VkMacOSSurfaceCreateFlagsMVK = VkFlags; + +[CRepr] struct VkMacOSSurfaceCreateInfoMVK : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMacOSSurfaceCreateFlagsMVK flags = default; + public void* pView = null; + + public this(void* pNext, VkMacOSSurfaceCreateFlagsMVK flags, void* pView) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pView = pView; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateMacOSSurfaceMVK(VkInstance instance, VkMacOSSurfaceCreateInfoMVK* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME = "VK_EXT_external_memory_dma_buf"; } +static { public const let VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION = 1; } +static { public const let VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME = "VK_EXT_queue_family_foreign"; } +static { public const uint32 VK_QUEUE_FAMILY_FOREIGN_EXT = (~2U); } +static { public const let VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION = 3; } +static { public const let VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_KHR_dedicated_allocation"; } + +typealias VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirements; +typealias VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfo; + +static { public const let VK_EXT_DEBUG_UTILS_SPEC_VERSION = 2; } +static { public const let VK_EXT_DEBUG_UTILS_EXTENSION_NAME = "VK_EXT_debug_utils"; } + +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkDebugUtilsMessengerCallbackEXT( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +[CRepr] struct VkDebugUtilsLabelEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public char8* pLabelName = null; + public float[4] color = .(); + + public this(void* pNext, char8* pLabelName, float[4] color) : this() + { + this.pNext = pNext; + this.pLabelName = pLabelName; + this.color = color; + } +} + +[AllowDuplicates] enum VkDebugUtilsMessageSeverityFlagBitsEXT : int32 +{ + [NoShow] VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 1 << 0, + [NoShow] VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 1 << 4, + [NoShow] VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 1 << 8, + [NoShow] VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 1 << 12, + // pretty names + VerboseEXT = 1 << 0, + InfoEXT = 1 << 4, + WarningEXT = 1 << 8, + ErrorEXT = 1 << 12, +} + +typealias VkDebugUtilsMessageSeverityFlagsEXT = VkDebugUtilsMessageSeverityFlagBitsEXT; + +[AllowDuplicates] enum VkDebugUtilsMessageTypeFlagBitsEXT : int32 +{ + [NoShow] VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 1 << 0, + [NoShow] VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 1 << 1, + [NoShow] VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 1 << 2, + [NoShow] VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 1 << 3, + // pretty names + GeneralEXT = 1 << 0, + ValidationEXT = 1 << 1, + PerformanceEXT = 1 << 2, + DeviceAddressBindingEXT = 1 << 3, +} + +typealias VkDebugUtilsMessageTypeFlagsEXT = VkDebugUtilsMessageTypeFlagBitsEXT; + +[CRepr] struct VkDebugUtilsMessengerCallbackDataEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDebugUtilsMessengerCallbackDataFlagsEXT flags = default; + public char8* pMessageIdName = null; + public int32 messageIdNumber = 0; + public char8* pMessage = null; + public uint32 queueLabelCount = 0; + public VkDebugUtilsLabelEXT* pQueueLabels = null; + public Span queueLabels + { + get { return .(pQueueLabels, (.)queueLabelCount); } + set mut { pQueueLabels = value.Ptr; queueLabelCount = (.)value.Length; } + } + public uint32 cmdBufLabelCount = 0; + public VkDebugUtilsLabelEXT* pCmdBufLabels = null; + public Span cmdBufLabels + { + get { return .(pCmdBufLabels, (.)cmdBufLabelCount); } + set mut { pCmdBufLabels = value.Ptr; cmdBufLabelCount = (.)value.Length; } + } + public uint32 objectCount = 0; + public VkDebugUtilsObjectNameInfoEXT* pObjects = null; + public Span objects + { + get { return .(pObjects, (.)objectCount); } + set mut { pObjects = value.Ptr; objectCount = (.)value.Length; } + } + + public this(void* pNext, VkDebugUtilsMessengerCallbackDataFlagsEXT flags, char8* pMessageIdName, int32 messageIdNumber, char8* pMessage = null, Span queueLabels = default, Span cmdBufLabels = default, Span objects = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pMessageIdName = pMessageIdName; + this.messageIdNumber = messageIdNumber; + this.pMessage = pMessage; + this.queueLabels = queueLabels; + this.cmdBufLabels = cmdBufLabels; + this.objects = objects; + } +} + +typealias VkDebugUtilsMessengerCallbackDataFlagsEXT = VkFlags; +typealias VkDebugUtilsMessengerCreateFlagsEXT = VkFlags; + +[CRepr] struct VkDebugUtilsMessengerCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDebugUtilsMessengerCreateFlagsEXT flags = default; + public VkDebugUtilsMessageSeverityFlagsEXT messageSeverity = default; + public VkDebugUtilsMessageTypeFlagsEXT messageType = default; + public PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback = default; + public void* pUserData = null; + + public this(void* pNext, VkDebugUtilsMessengerCreateFlagsEXT flags, VkDebugUtilsMessageSeverityFlagsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback, void* pUserData = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.messageSeverity = messageSeverity; + this.messageType = messageType; + this.pfnUserCallback = pfnUserCallback; + this.pUserData = pUserData; + } +} + +struct VkDebugUtilsMessengerEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkDebugUtilsObjectNameInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkObjectType objectType = default; + public uint64 objectHandle = 0; + public char8* pObjectName = null; + + public this(void* pNext, VkObjectType objectType, uint64 objectHandle, char8* pObjectName = null) : this() + { + this.pNext = pNext; + this.objectType = objectType; + this.objectHandle = objectHandle; + this.pObjectName = pObjectName; + } +} + +[CRepr] struct VkDebugUtilsObjectTagInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkObjectType objectType = default; + public uint64 objectHandle = 0; + public uint64 tagName = 0; + public c_size tagSize = 0; + public void* pTag = null; + public Span tag + { + get { return .(pTag, (.)tagSize); } + set mut { pTag = value.Ptr; tagSize = (.)value.Length; } + } + + public this(void* pNext, VkObjectType objectType, uint64 objectHandle, uint64 tagName, Span tag) : this() + { + this.pNext = pNext; + this.objectType = objectType; + this.objectHandle = objectHandle; + this.tagName = tagName; + this.tag = tag; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetDebugUtilsObjectNameEXT(VkDevice device, VkDebugUtilsObjectNameInfoEXT* pNameInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetDebugUtilsObjectTagEXT(VkDevice device, VkDebugUtilsObjectTagInfoEXT* pTagInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, VkDebugUtilsLabelEXT* pLabelInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkQueueEndDebugUtilsLabelEXT(VkQueue queue); +[CallingConvention(VKAPI_PTR)] function void PFN_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, VkDebugUtilsLabelEXT* pLabelInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT* pLabelInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT* pLabelInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDebugUtilsMessengerEXT pMessenger); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +static { public const let VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION = 5; } +static { public const let VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME = "VK_ANDROID_external_memory_android_hardware_buffer"; } + +[CRepr] struct VkAndroidHardwareBufferUsageANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 androidHardwareBufferUsage = 0; +} + +[CRepr] struct VkAndroidHardwareBufferPropertiesANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize allocationSize = default; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkAndroidHardwareBufferFormatPropertiesANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public uint64 externalFormat = 0; + public VkFormatFeatureFlags formatFeatures = default; + public VkComponentMapping samplerYcbcrConversionComponents = default; + public VkSamplerYcbcrModelConversion suggestedYcbcrModel = default; + public VkSamplerYcbcrRange suggestedYcbcrRange = default; + public VkChromaLocation suggestedXChromaOffset = default; + public VkChromaLocation suggestedYChromaOffset = default; +} + +[CRepr] struct VkImportAndroidHardwareBufferInfoANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public AHardwareBuffer* buffer = null; + + public this(void* pNext, AHardwareBuffer* buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkMemoryGetAndroidHardwareBufferInfoANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + + public this(void* pNext, VkDeviceMemory memory) : this() + { + this.pNext = pNext; + this.memory = memory; + } +} + +[CRepr] struct VkExternalFormatANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 externalFormat = 0; + + public this(void* pNext, uint64 externalFormat) : this() + { + this.pNext = pNext; + this.externalFormat = externalFormat; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, out AHardwareBuffer buffer, out VkAndroidHardwareBufferPropertiesANDROID pProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, out AHardwareBuffer* pBuffer); + +struct AHardwareBuffer; + +[CRepr] struct VkAndroidHardwareBufferFormatProperties2ANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public uint64 externalFormat = 0; + public VkFormatFeatureFlags2 formatFeatures = default; + public VkComponentMapping samplerYcbcrConversionComponents = default; + public VkSamplerYcbcrModelConversion suggestedYcbcrModel = default; + public VkSamplerYcbcrRange suggestedYcbcrRange = default; + public VkChromaLocation suggestedXChromaOffset = default; + public VkChromaLocation suggestedYChromaOffset = default; +} + +static { public const let VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION = 2; } +static { public const let VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME = "VK_EXT_sampler_filter_minmax"; } + +typealias VkSamplerReductionModeEXT = VkSamplerReductionMode; +typealias VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfo; +typealias VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxProperties; + +static { public const let VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION = 1; } +static { public const let VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME = "VK_KHR_storage_buffer_storage_class"; } +static { public const let VK_AMD_GPU_SHADER_INT16_SPEC_VERSION = 2; } +static { public const let VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME = "VK_AMD_gpu_shader_int16"; } +static { public const let VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION = 2; } +static { public const let VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME = "VK_AMDX_shader_enqueue"; } +static { public const uint32 VK_SHADER_INDEX_UNUSED_AMDX = (~0U); } + +[CRepr] struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderEnqueue = false; + public VkBool32 shaderMeshEnqueue = false; + + public this(void* pNext, VkBool32 shaderEnqueue, VkBool32 shaderMeshEnqueue) : this() + { + this.pNext = pNext; + this.shaderEnqueue = shaderEnqueue; + this.shaderMeshEnqueue = shaderMeshEnqueue; + } +} + +[CRepr] struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxExecutionGraphDepth = 0; + public uint32 maxExecutionGraphShaderOutputNodes = 0; + public uint32 maxExecutionGraphShaderPayloadSize = 0; + public uint32 maxExecutionGraphShaderPayloadCount = 0; + public uint32 executionGraphDispatchAddressAlignment = 0; + public uint32[3] maxExecutionGraphWorkgroupCount = .(); + public uint32 maxExecutionGraphWorkgroups = 0; +} + +[CRepr] struct VkExecutionGraphPipelineScratchSizeAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize minSize = default; + public VkDeviceSize maxSize = default; + public VkDeviceSize sizeGranularity = default; + + public this(void* pNext, VkDeviceSize minSize, VkDeviceSize maxSize, VkDeviceSize sizeGranularity) : this() + { + this.pNext = pNext; + this.minSize = minSize; + this.maxSize = maxSize; + this.sizeGranularity = sizeGranularity; + } +} + +[CRepr] struct VkExecutionGraphPipelineCreateInfoAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags flags = default; + public uint32 stageCount = 0; + public VkPipelineShaderStageCreateInfo* pStages = null; + public Span stages + { + get { return .(pStages, (.)stageCount); } + set mut { pStages = value.Ptr; stageCount = (.)value.Length; } + } + public VkPipelineLibraryCreateInfoKHR* pLibraryInfo = null; + public VkPipelineLayout layout = null; + public VkPipeline basePipelineHandle = null; + public int32 basePipelineIndex = 0; + + public this(void* pNext, VkPipelineCreateFlags flags, Span stages, VkPipelineLibraryCreateInfoKHR* pLibraryInfo, VkPipelineLayout layout, VkPipeline basePipelineHandle, int32 basePipelineIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stages = stages; + this.pLibraryInfo = pLibraryInfo; + this.layout = layout; + this.basePipelineHandle = basePipelineHandle; + this.basePipelineIndex = basePipelineIndex; + } +} + +[CRepr] struct VkDispatchGraphInfoAMDX : this() +{ + public uint32 nodeIndex = 0; + public uint32 payloadCount = 0; + public VkDeviceOrHostAddressConstAMDX payloads = default; + public uint64 payloadStride = 0; + + public this(uint32 nodeIndex, uint32 payloadCount, VkDeviceOrHostAddressConstAMDX payloads, uint64 payloadStride) : this() + { + this.nodeIndex = nodeIndex; + this.payloadCount = payloadCount; + this.payloads = payloads; + this.payloadStride = payloadStride; + } +} + +[CRepr] struct VkDispatchGraphCountInfoAMDX : this() +{ + public uint32 count = 0; + public VkDeviceOrHostAddressConstAMDX infos = default; + public uint64 stride = 0; + + public this(uint32 count, VkDeviceOrHostAddressConstAMDX infos, uint64 stride) : this() + { + this.count = count; + this.infos = infos; + this.stride = stride; + } +} + +[CRepr] struct VkPipelineShaderStageNodeCreateInfoAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public char8* pName = null; + public uint32 index = 0; + + public this(void* pNext, char8* pName, uint32 index) : this() + { + this.pNext = pNext; + this.pName = pName; + this.index = index; + } +} + +[CRepr, Union] struct VkDeviceOrHostAddressConstAMDX : this() +{ + public VkDeviceAddress deviceAddress = default; + public void* hostAddress = null; + + public this(VkDeviceAddress deviceAddress, void* hostAddress) : this() + { + this.deviceAddress = deviceAddress; + this.hostAddress = hostAddress; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, uint32 createInfoCount, VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, out VkExecutionGraphPipelineScratchSizeAMDX pSizeInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetExecutionGraphPipelineNodeIndexAMDX(VkDevice device, VkPipeline executionGraph, VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, out uint32 pNodeIndex); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDispatchGraphCountInfoAMDX* pCountInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDispatchGraphCountInfoAMDX* pCountInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo); + +static { public const let VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION = 1; } +static { public const let VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME = "VK_AMD_mixed_attachment_samples"; } + +[CRepr] struct VkAttachmentSampleCountInfoAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 colorAttachmentCount = 0; + public VkSampleCountFlagBits* pColorAttachmentSamples = null; + public Span colorAttachmentSamples + { + get { return .(pColorAttachmentSamples, (.)colorAttachmentCount); } + set mut { pColorAttachmentSamples = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkSampleCountFlagBits depthStencilAttachmentSamples = default; + + public this(void* pNext = null, Span colorAttachmentSamples = default, VkSampleCountFlagBits depthStencilAttachmentSamples = default) : this() + { + this.pNext = pNext; + this.colorAttachmentSamples = colorAttachmentSamples; + this.depthStencilAttachmentSamples = depthStencilAttachmentSamples; + } +} + +static { public const let VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME = "VK_AMD_shader_fragment_mask"; } +static { public const let VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION = 1; } +static { public const let VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME = "VK_EXT_inline_uniform_block"; } + +typealias VkPhysicalDeviceInlineUniformBlockFeaturesEXT = VkPhysicalDeviceInlineUniformBlockFeatures; +typealias VkPhysicalDeviceInlineUniformBlockPropertiesEXT = VkPhysicalDeviceInlineUniformBlockProperties; +typealias VkWriteDescriptorSetInlineUniformBlockEXT = VkWriteDescriptorSetInlineUniformBlock; +typealias VkDescriptorPoolInlineUniformBlockCreateInfoEXT = VkDescriptorPoolInlineUniformBlockCreateInfo; + +static { public const let VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME = "VK_EXT_shader_stencil_export"; } +static { public const let VK_KHR_SHADER_BFLOAT16_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME = "VK_KHR_shader_bfloat16"; } + +[CRepr] struct VkPhysicalDeviceShaderBfloat16FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderBFloat16Type = false; + public VkBool32 shaderBFloat16DotProduct = false; + public VkBool32 shaderBFloat16CooperativeMatrix = false; + + public this(void* pNext, VkBool32 shaderBFloat16Type, VkBool32 shaderBFloat16DotProduct, VkBool32 shaderBFloat16CooperativeMatrix) : this() + { + this.pNext = pNext; + this.shaderBFloat16Type = shaderBFloat16Type; + this.shaderBFloat16DotProduct = shaderBFloat16DotProduct; + this.shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix; + } +} + +static { public const let VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION = 1; } +static { public const let VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME = "VK_EXT_sample_locations"; } + +[CRepr] struct VkSampleLocationEXT : this() +{ + public float x = 0; + public float y = 0; + + public this(float x, float y) : this() + { + this.x = x; + this.y = y; + } +} + +[CRepr] struct VkSampleLocationsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSampleCountFlagBits sampleLocationsPerPixel = default; + public VkExtent2D sampleLocationGridSize = default; + public uint32 sampleLocationsCount = 0; + public VkSampleLocationEXT* pSampleLocations = null; + public Span sampleLocations + { + get { return .(pSampleLocations, (.)sampleLocationsCount); } + set mut { pSampleLocations = value.Ptr; sampleLocationsCount = (.)value.Length; } + } + + public this(void* pNext, VkSampleCountFlagBits sampleLocationsPerPixel, VkExtent2D sampleLocationGridSize, Span sampleLocations = default) : this() + { + this.pNext = pNext; + this.sampleLocationsPerPixel = sampleLocationsPerPixel; + this.sampleLocationGridSize = sampleLocationGridSize; + this.sampleLocations = sampleLocations; + } +} + +[CRepr] struct VkAttachmentSampleLocationsEXT : this() +{ + public uint32 attachmentIndex = 0; + public VkSampleLocationsInfoEXT sampleLocationsInfo = default; + + public this(uint32 attachmentIndex, VkSampleLocationsInfoEXT sampleLocationsInfo) : this() + { + this.attachmentIndex = attachmentIndex; + this.sampleLocationsInfo = sampleLocationsInfo; + } +} + +[CRepr] struct VkSubpassSampleLocationsEXT : this() +{ + public uint32 subpassIndex = 0; + public VkSampleLocationsInfoEXT sampleLocationsInfo = default; + + public this(uint32 subpassIndex, VkSampleLocationsInfoEXT sampleLocationsInfo) : this() + { + this.subpassIndex = subpassIndex; + this.sampleLocationsInfo = sampleLocationsInfo; + } +} + +[CRepr] struct VkRenderPassSampleLocationsBeginInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 attachmentInitialSampleLocationsCount = 0; + public VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations = null; + public Span attachmentInitialSampleLocations + { + get { return .(pAttachmentInitialSampleLocations, (.)attachmentInitialSampleLocationsCount); } + set mut { pAttachmentInitialSampleLocations = value.Ptr; attachmentInitialSampleLocationsCount = (.)value.Length; } + } + public uint32 postSubpassSampleLocationsCount = 0; + public VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations = null; + public Span postSubpassSampleLocations + { + get { return .(pPostSubpassSampleLocations, (.)postSubpassSampleLocationsCount); } + set mut { pPostSubpassSampleLocations = value.Ptr; postSubpassSampleLocationsCount = (.)value.Length; } + } + + public this(void* pNext = null, Span attachmentInitialSampleLocations = default, Span postSubpassSampleLocations = default) : this() + { + this.pNext = pNext; + this.attachmentInitialSampleLocations = attachmentInitialSampleLocations; + this.postSubpassSampleLocations = postSubpassSampleLocations; + } +} + +[CRepr] struct VkPipelineSampleLocationsStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 sampleLocationsEnable = false; + public VkSampleLocationsInfoEXT sampleLocationsInfo = default; + + public this(void* pNext, VkBool32 sampleLocationsEnable, VkSampleLocationsInfoEXT sampleLocationsInfo) : this() + { + this.pNext = pNext; + this.sampleLocationsEnable = sampleLocationsEnable; + this.sampleLocationsInfo = sampleLocationsInfo; + } +} + +[CRepr] struct VkPhysicalDeviceSampleLocationsPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSampleCountFlags sampleLocationSampleCounts = default; + public VkExtent2D maxSampleLocationGridSize = default; + public float[2] sampleLocationCoordinateRange = .(); + public uint32 sampleLocationSubPixelBits = 0; + public VkBool32 variableSampleLocations = false; +} + +[CRepr] struct VkMultisamplePropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D maxSampleLocationGridSize = default; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, VkSampleLocationsInfoEXT* pSampleLocationsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, out VkMultisamplePropertiesEXT pMultisampleProperties); + +static { public const let VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION = 1; } +static { public const let VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME = "VK_KHR_relaxed_block_layout"; } +static { public const let VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME = "VK_KHR_get_memory_requirements2"; } + +typealias VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2; +typealias VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2; +typealias VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2; +typealias VkMemoryRequirements2KHR = VkMemoryRequirements2; +typealias VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2; + +typealias PFN_vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2; +typealias PFN_vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2; +typealias PFN_vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2; + +static { public const let VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION = 1; } +static { public const let VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME = "VK_KHR_image_format_list"; } + +typealias VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfo; + +static { public const let VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION = 2; } +static { public const let VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME = "VK_EXT_blend_operation_advanced"; } + +[CRepr] struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 advancedBlendCoherentOperations = false; + + public this(void* pNext, VkBool32 advancedBlendCoherentOperations) : this() + { + this.pNext = pNext; + this.advancedBlendCoherentOperations = advancedBlendCoherentOperations; + } +} + +[CRepr] struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 advancedBlendMaxColorAttachments = 0; + public VkBool32 advancedBlendIndependentBlend = false; + public VkBool32 advancedBlendNonPremultipliedSrcColor = false; + public VkBool32 advancedBlendNonPremultipliedDstColor = false; + public VkBool32 advancedBlendCorrelatedOverlap = false; + public VkBool32 advancedBlendAllOperations = false; +} + +[CRepr] struct VkPipelineColorBlendAdvancedStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 srcPremultiplied = false; + public VkBool32 dstPremultiplied = false; + public VkBlendOverlapEXT blendOverlap = default; + + public this(void* pNext, VkBool32 srcPremultiplied, VkBool32 dstPremultiplied, VkBlendOverlapEXT blendOverlap) : this() + { + this.pNext = pNext; + this.srcPremultiplied = srcPremultiplied; + this.dstPremultiplied = dstPremultiplied; + this.blendOverlap = blendOverlap; + } +} + +[AllowDuplicates] enum VkBlendOverlapEXT : int32 +{ + [NoShow] VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + [NoShow] VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + [NoShow] VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + // pretty names + UncorrelatedEXT = 0, + DisjointEXT = 1, + ConjointEXT = 2, +} + +static { public const let VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION = 1; } +static { public const let VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME = "VK_NV_fragment_coverage_to_color"; } + +typealias VkPipelineCoverageToColorStateCreateFlagsNV = VkFlags; + +[CRepr] struct VkPipelineCoverageToColorStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCoverageToColorStateCreateFlagsNV flags = default; + public VkBool32 coverageToColorEnable = false; + public uint32 coverageToColorLocation = 0; + + public this(void* pNext, VkPipelineCoverageToColorStateCreateFlagsNV flags, VkBool32 coverageToColorEnable, uint32 coverageToColorLocation = 0) : this() + { + this.pNext = pNext; + this.flags = flags; + this.coverageToColorEnable = coverageToColorEnable; + this.coverageToColorLocation = coverageToColorLocation; + } +} + +static { public const let VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION = 13; } +static { public const let VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME = "VK_KHR_acceleration_structure"; } + +[AllowDuplicates] enum VkAccelerationStructureTypeKHR : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + [NoShow] VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + [NoShow] VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + [NoShow] VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + [NoShow] VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + // pretty names + TopLevelKHR = 0, + BottomLevelKHR = 1, + GenericKHR = 2, + TopLevelNV = TopLevelKHR, + BottomLevelNV = BottomLevelKHR, +} + +[CRepr, Union] struct VkDeviceOrHostAddressKHR : this() +{ + public VkDeviceAddress deviceAddress = default; + public void* hostAddress = null; + + public this(VkDeviceAddress deviceAddress, void* hostAddress) : this() + { + this.deviceAddress = deviceAddress; + this.hostAddress = hostAddress; + } +} + +[CRepr, Union] struct VkDeviceOrHostAddressConstKHR : this() +{ + public VkDeviceAddress deviceAddress = default; + public void* hostAddress = null; + + public this(VkDeviceAddress deviceAddress, void* hostAddress) : this() + { + this.deviceAddress = deviceAddress; + this.hostAddress = hostAddress; + } +} + +[CRepr] struct VkAccelerationStructureBuildRangeInfoKHR : this() +{ + public uint32 primitiveCount = 0; + public uint32 primitiveOffset = 0; + public uint32 firstVertex = 0; + public uint32 transformOffset = 0; + + public this(uint32 primitiveCount, uint32 primitiveOffset, uint32 firstVertex, uint32 transformOffset) : this() + { + this.primitiveCount = primitiveCount; + this.primitiveOffset = primitiveOffset; + this.firstVertex = firstVertex; + this.transformOffset = transformOffset; + } +} + +[CRepr] struct VkAabbPositionsKHR : this() +{ + public float minX = 0; + public float minY = 0; + public float minZ = 0; + public float maxX = 0; + public float maxY = 0; + public float maxZ = 0; + + public this(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) : this() + { + this.minX = minX; + this.minY = minY; + this.minZ = minZ; + this.maxX = maxX; + this.maxY = maxY; + this.maxZ = maxZ; + } +} + +[CRepr] struct VkAccelerationStructureGeometryTrianglesDataKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat vertexFormat = default; + public VkDeviceOrHostAddressConstKHR vertexData = default; + public VkDeviceSize vertexStride = default; + public uint32 maxVertex = 0; + public VkIndexType indexType = default; + public VkDeviceOrHostAddressConstKHR indexData = default; + public VkDeviceOrHostAddressConstKHR transformData = default; + + public this(void* pNext, VkFormat vertexFormat, VkDeviceOrHostAddressConstKHR vertexData, VkDeviceSize vertexStride, uint32 maxVertex, VkIndexType indexType, VkDeviceOrHostAddressConstKHR indexData, VkDeviceOrHostAddressConstKHR transformData) : this() + { + this.pNext = pNext; + this.vertexFormat = vertexFormat; + this.vertexData = vertexData; + this.vertexStride = vertexStride; + this.maxVertex = maxVertex; + this.indexType = indexType; + this.indexData = indexData; + this.transformData = transformData; + } +} + +[CRepr] struct VkTransformMatrixKHR : this() +{ + public float[3][4] matrix = .(); + + public this(float[3][4] matrix) : this() + { + this.matrix = matrix; + } +} + +[CRepr] struct VkAccelerationStructureBuildGeometryInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureTypeKHR type = default; + public VkBuildAccelerationStructureFlagsKHR flags = default; + public VkBuildAccelerationStructureModeKHR mode = default; + public VkAccelerationStructureKHR srcAccelerationStructure = null; + public VkAccelerationStructureKHR dstAccelerationStructure = null; + public uint32 geometryCount = 0; + public VkAccelerationStructureGeometryKHR* pGeometries = null; + public Span geometries + { + get { return .(pGeometries, (.)geometryCount); } + set mut { pGeometries = value.Ptr; geometryCount = (.)value.Length; } + } + public VkAccelerationStructureGeometryKHR** ppGeometries = null; + public VkDeviceOrHostAddressKHR scratchData = default; + + public this(void* pNext, VkAccelerationStructureTypeKHR type, VkBuildAccelerationStructureFlagsKHR flags, VkBuildAccelerationStructureModeKHR mode, VkAccelerationStructureKHR srcAccelerationStructure, VkAccelerationStructureKHR dstAccelerationStructure, Span geometries, VkAccelerationStructureGeometryKHR** ppGeometries, VkDeviceOrHostAddressKHR scratchData) : this() + { + this.pNext = pNext; + this.type = type; + this.flags = flags; + this.mode = mode; + this.srcAccelerationStructure = srcAccelerationStructure; + this.dstAccelerationStructure = dstAccelerationStructure; + this.geometries = geometries; + this.ppGeometries = ppGeometries; + this.scratchData = scratchData; + } +} + +[AllowDuplicates] enum VkAccelerationStructureBuildTypeKHR : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, + [NoShow] VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, + [NoShow] VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, + // pretty names + HostKHR = 0, + DeviceKHR = 1, + HostOrDeviceKHR = 2, +} + +[CRepr] struct VkAccelerationStructureGeometryAabbsDataKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceOrHostAddressConstKHR data = default; + public VkDeviceSize stride = default; + + public this(void* pNext, VkDeviceOrHostAddressConstKHR data, VkDeviceSize stride) : this() + { + this.pNext = pNext; + this.data = data; + this.stride = stride; + } +} + +[CRepr] struct VkAccelerationStructureInstanceKHR : this() +{ + + public VkTransformMatrixKHR transform = default; + [Bitfield(.Public, .Bits(24), "instanceCustomIndex")] + [Bitfield(.Public, .Bits(8), "mask")] + private uint32 __bitfields_mask = 0; + [Bitfield(.Public, .Bits(24), "instanceShaderBindingTableRecordOffset")] + [Bitfield(.Public, .Bits(8), "flags")] + private VkFlags __bitfields_flags = 0; + public uint64 accelerationStructureReference = 0; + + public this(VkTransformMatrixKHR transform, uint32 instanceCustomIndex, uint32 mask, uint32 instanceShaderBindingTableRecordOffset, VkFlags flags, uint64 accelerationStructureReference) : this() + { + this.transform = transform; + this.instanceCustomIndex = instanceCustomIndex; + this.mask = mask; + this.instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset; + this.flags = flags; + this.accelerationStructureReference = accelerationStructureReference; + } +} + +[CRepr] struct VkAccelerationStructureGeometryInstancesDataKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 arrayOfPointers = false; + public VkDeviceOrHostAddressConstKHR data = default; + + public this(void* pNext, VkBool32 arrayOfPointers, VkDeviceOrHostAddressConstKHR data) : this() + { + this.pNext = pNext; + this.arrayOfPointers = arrayOfPointers; + this.data = data; + } +} + +[CRepr, Union] struct VkAccelerationStructureGeometryDataKHR : this() +{ + public VkAccelerationStructureGeometryTrianglesDataKHR triangles = default; + public VkAccelerationStructureGeometryAabbsDataKHR aabbs = default; + public VkAccelerationStructureGeometryInstancesDataKHR instances = default; + + public this(VkAccelerationStructureGeometryTrianglesDataKHR triangles, VkAccelerationStructureGeometryAabbsDataKHR aabbs, VkAccelerationStructureGeometryInstancesDataKHR instances) : this() + { + this.triangles = triangles; + this.aabbs = aabbs; + this.instances = instances; + } +} + +[CRepr] struct VkAccelerationStructureGeometryKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkGeometryTypeKHR geometryType = default; + public VkAccelerationStructureGeometryDataKHR geometry = default; + public VkGeometryFlagsKHR flags = default; + + public this(void* pNext, VkGeometryTypeKHR geometryType, VkAccelerationStructureGeometryDataKHR geometry, VkGeometryFlagsKHR flags = default) : this() + { + this.pNext = pNext; + this.geometryType = geometryType; + this.geometry = geometry; + this.flags = flags; + } +} + +typealias VkGeometryFlagsKHR = VkGeometryFlagBitsKHR; +typealias VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagBitsKHR; + +[AllowDuplicates] enum VkGeometryFlagBitsKHR : int32 +{ + [NoShow] VK_GEOMETRY_OPAQUE_BIT_KHR = 1 << 0, + [NoShow] VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 1 << 1, + [NoShow] VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, + [NoShow] VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, + // pretty names + OpaqueKHR = 1 << 0, + NoDuplicateAnyHitInvocationKHR = 1 << 1, + OpaqueNV = OpaqueKHR, + NoDuplicateAnyHitInvocationNV = NoDuplicateAnyHitInvocationKHR, +} + +[AllowDuplicates] enum VkGeometryInstanceFlagBitsKHR : int32 +{ + [NoShow] VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 1 << 0, + [NoShow] VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 1 << 1, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 1 << 2, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 1 << 3, + [NoShow] VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, + [NoShow] VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, + [NoShow] VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 1 << 4, + [NoShow] VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + [NoShow] VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 1 << 5, + [NoShow] VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + // pretty names + TriangleFacingCullDisableKHR = 1 << 0, + TriangleFlipFacingKHR = 1 << 1, + ForceOpaqueKHR = 1 << 2, + ForceNoOpaqueKHR = 1 << 3, + TriangleFrontCounterclockwiseKHR = TriangleFlipFacingKHR, + TriangleCullDisableNV = TriangleFacingCullDisableKHR, + TriangleFrontCounterclockwiseNV = TriangleFrontCounterclockwiseKHR, + ForceOpaqueNV = ForceOpaqueKHR, + ForceNoOpaqueNV = ForceNoOpaqueKHR, + ForceOpacityMicromap2_StateEXT = 1 << 4, + DisableOpacityMicromapsEXT = 1 << 5, +} + +[CRepr] struct VkAccelerationStructureCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureCreateFlagsKHR createFlags = default; + public VkBuffer buffer = null; + public VkDeviceSize offset = default; // Specified in bytes + public VkDeviceSize size = default; + public VkAccelerationStructureTypeKHR type = default; + public VkDeviceAddress deviceAddress = default; + + public this(void* pNext, VkAccelerationStructureCreateFlagsKHR createFlags, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkAccelerationStructureTypeKHR type, VkDeviceAddress deviceAddress = default) : this() + { + this.pNext = pNext; + this.createFlags = createFlags; + this.buffer = buffer; + this.offset = offset; + this.size = size; + this.type = type; + this.deviceAddress = deviceAddress; + } +} + +struct VkAccelerationStructureKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkBuildAccelerationStructureFlagBitsKHR : int32 +{ + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 1 << 0, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 1 << 1, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 1 << 2, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 1 << 3, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 1 << 4, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 1 << 5, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 1 << 6, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 1 << 7, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 1 << 8, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 1 << 9, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 1 << 11, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 1 << 12, + // pretty names + AllowUpdateKHR = 1 << 0, + AllowCompactionKHR = 1 << 1, + PreferFastTraceKHR = 1 << 2, + PreferFastBuildKHR = 1 << 3, + LowMemoryKHR = 1 << 4, + AllowUpdateNV = AllowUpdateKHR, + AllowCompactionNV = AllowCompactionKHR, + PreferFastTraceNV = PreferFastTraceKHR, + PreferFastBuildNV = PreferFastBuildKHR, + LowMemoryNV = LowMemoryKHR, + MotionNV = 1 << 5, + AllowOpacityMicromapUpdateEXT = 1 << 6, + AllowDisableOpacityMicromapsEXT = 1 << 7, + AllowOpacityMicromapDataUpdateEXT = 1 << 8, + AllowDisplacementMicromapUpdateNV = 1 << 9, + AllowDataAccessKHR = 1 << 11, + AllowClusterOpacityMicromapsNV = 1 << 12, +} + +typealias VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagBitsKHR; + +[AllowDuplicates] enum VkCopyAccelerationStructureModeKHR : int32 +{ + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, + [NoShow] VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, + // pretty names + CloneKHR = 0, + CompactKHR = 1, + SerializeKHR = 2, + DeserializeKHR = 3, + CloneNV = CloneKHR, + CompactNV = CompactKHR, +} + +[AllowDuplicates] enum VkGeometryTypeKHR : int32 +{ + [NoShow] VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, + [NoShow] VK_GEOMETRY_TYPE_AABBS_KHR = 1, + [NoShow] VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, + [NoShow] VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, + [NoShow] VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, + [NoShow] VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004, + [NoShow] VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005, + [NoShow] VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, + // pretty names + TrianglesKHR = 0, + AabbsKHR = 1, + InstancesKHR = 2, + TrianglesNV = TrianglesKHR, + AabbsNV = AabbsKHR, + SpheresNV = 1000429004, + LinearSweptSpheresNV = 1000429005, + DenseGeometryFormatTrianglesAMDX = 1000478000, +} + +[CRepr] struct VkWriteDescriptorSetAccelerationStructureKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 accelerationStructureCount = 0; + public VkAccelerationStructureKHR* pAccelerationStructures = null; + public Span accelerationStructures + { + get { return .(pAccelerationStructures, (.)accelerationStructureCount); } + set mut { pAccelerationStructures = value.Ptr; accelerationStructureCount = (.)value.Length; } + } + + public this(void* pNext, Span accelerationStructures) : this() + { + this.pNext = pNext; + this.accelerationStructures = accelerationStructures; + } +} + +[CRepr] struct VkPhysicalDeviceAccelerationStructureFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 accelerationStructure = false; + public VkBool32 accelerationStructureCaptureReplay = false; + public VkBool32 accelerationStructureIndirectBuild = false; + public VkBool32 accelerationStructureHostCommands = false; + public VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind = false; + + public this(void* pNext, VkBool32 accelerationStructure, VkBool32 accelerationStructureCaptureReplay, VkBool32 accelerationStructureIndirectBuild, VkBool32 accelerationStructureHostCommands, VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind) : this() + { + this.pNext = pNext; + this.accelerationStructure = accelerationStructure; + this.accelerationStructureCaptureReplay = accelerationStructureCaptureReplay; + this.accelerationStructureIndirectBuild = accelerationStructureIndirectBuild; + this.accelerationStructureHostCommands = accelerationStructureHostCommands; + this.descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind; + } +} + +[CRepr] struct VkPhysicalDeviceAccelerationStructurePropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 maxGeometryCount = 0; + public uint64 maxInstanceCount = 0; + public uint64 maxPrimitiveCount = 0; + public uint32 maxPerStageDescriptorAccelerationStructures = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindAccelerationStructures = 0; + public uint32 maxDescriptorSetAccelerationStructures = 0; + public uint32 maxDescriptorSetUpdateAfterBindAccelerationStructures = 0; + public uint32 minAccelerationStructureScratchOffsetAlignment = 0; +} + +[CRepr] struct VkAccelerationStructureDeviceAddressInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureKHR accelerationStructure = null; + + public this(void* pNext, VkAccelerationStructureKHR accelerationStructure) : this() + { + this.pNext = pNext; + this.accelerationStructure = accelerationStructure; + } +} + +[CRepr] struct VkAccelerationStructureVersionInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8* pVersionData = null; + + public this(void* pNext, uint8* pVersionData) : this() + { + this.pNext = pNext; + this.pVersionData = pVersionData; + } +} + +[CRepr] struct VkCopyAccelerationStructureToMemoryInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureKHR src = null; + public VkDeviceOrHostAddressKHR dst = default; + public VkCopyAccelerationStructureModeKHR mode = default; + + public this(void* pNext, VkAccelerationStructureKHR src, VkDeviceOrHostAddressKHR dst, VkCopyAccelerationStructureModeKHR mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[CRepr] struct VkCopyMemoryToAccelerationStructureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceOrHostAddressConstKHR src = default; + public VkAccelerationStructureKHR dst = null; + public VkCopyAccelerationStructureModeKHR mode = default; + + public this(void* pNext, VkDeviceOrHostAddressConstKHR src, VkAccelerationStructureKHR dst, VkCopyAccelerationStructureModeKHR mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[CRepr] struct VkCopyAccelerationStructureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureKHR src = null; + public VkAccelerationStructureKHR dst = null; + public VkCopyAccelerationStructureModeKHR mode = default; + + public this(void* pNext, VkAccelerationStructureKHR src, VkAccelerationStructureKHR dst, VkCopyAccelerationStructureModeKHR mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[AllowDuplicates] enum VkAccelerationStructureCompatibilityKHR : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, + [NoShow] VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, + // pretty names + CompatibleKHR = 0, + IncompatibleKHR = 1, +} + +[AllowDuplicates] enum VkAccelerationStructureCreateFlagBitsKHR : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 1 << 0, + [NoShow] VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 1 << 3, + [NoShow] VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 1 << 2, + // pretty names + DeviceAddressCaptureReplayKHR = 1 << 0, + DescriptorBufferCaptureReplayEXT = 1 << 3, + MotionNV = 1 << 2, +} + +typealias VkAccelerationStructureCreateFlagsKHR = VkAccelerationStructureCreateFlagBitsKHR; + +[AllowDuplicates] enum VkBuildAccelerationStructureModeKHR : int32 +{ + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, + [NoShow] VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, + // pretty names + BuildKHR = 0, + UpdateKHR = 1, +} + +[CRepr] struct VkAccelerationStructureBuildSizesInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize accelerationStructureSize = default; + public VkDeviceSize updateScratchSize = default; + public VkDeviceSize buildScratchSize = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateAccelerationStructureKHR(VkDevice device, VkAccelerationStructureCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkAccelerationStructureKHR pAccelerationStructure); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkAccelerationStructureBuildRangeInfoKHR** ppBuildRangeInfos); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkDeviceAddress* pIndirectDeviceAddresses, uint32* pIndirectStrides, uint32** ppMaxPrimitiveCounts); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32 infoCount, VkAccelerationStructureBuildGeometryInfoKHR* pInfos, VkAccelerationStructureBuildRangeInfoKHR** ppBuildRangeInfos); +[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 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); +[CallingConvention(VKAPI_PTR)] function VkDeviceAddress PFN_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32 accelerationStructureCount, VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, VkAccelerationStructureVersionInfoKHR* pVersionInfo, out VkAccelerationStructureCompatibilityKHR pCompatibility); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, uint32* pMaxPrimitiveCounts, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo); + +static { public const let VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION = 1; } +static { public const let VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME = "VK_KHR_ray_tracing_pipeline"; } +static { public const uint32 VK_SHADER_UNUSED_KHR = (~0U); } + +[CRepr] struct VkRayTracingShaderGroupCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRayTracingShaderGroupTypeKHR type = default; + public uint32 generalShader = 0; + public uint32 closestHitShader = 0; + public uint32 anyHitShader = 0; + public uint32 intersectionShader = 0; + public void* pShaderGroupCaptureReplayHandle = null; + + public this(void* pNext, VkRayTracingShaderGroupTypeKHR type, uint32 generalShader, uint32 closestHitShader, uint32 anyHitShader, uint32 intersectionShader, void* pShaderGroupCaptureReplayHandle = null) : this() + { + this.pNext = pNext; + this.type = type; + this.generalShader = generalShader; + this.closestHitShader = closestHitShader; + this.anyHitShader = anyHitShader; + this.intersectionShader = intersectionShader; + this.pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle; + } +} + +[AllowDuplicates] enum VkRayTracingShaderGroupTypeKHR : int32 +{ + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, + [NoShow] VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, + // pretty names + GeneralKHR = 0, + TrianglesHitGroupKHR = 1, + ProceduralHitGroupKHR = 2, + GeneralNV = GeneralKHR, + TrianglesHitGroupNV = TrianglesHitGroupKHR, + ProceduralHitGroupNV = ProceduralHitGroupKHR, +} + +[CRepr] struct VkRayTracingPipelineCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags flags = default; // Pipeline creation flags + public uint32 stageCount = 0; + public VkPipelineShaderStageCreateInfo* pStages = null; // One entry for each active shader stage + public Span stages + { + get { return .(pStages, (.)stageCount); } + set mut { pStages = value.Ptr; stageCount = (.)value.Length; } + } + public uint32 groupCount = 0; + public VkRayTracingShaderGroupCreateInfoKHR* pGroups = null; + public Span groups + { + get { return .(pGroups, (.)groupCount); } + set mut { pGroups = value.Ptr; groupCount = (.)value.Length; } + } + public uint32 maxPipelineRayRecursionDepth = 0; + public VkPipelineLibraryCreateInfoKHR* pLibraryInfo = null; + public VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface = null; + public VkPipelineDynamicStateCreateInfo* pDynamicState = null; + public VkPipelineLayout layout = null; // Interface layout of the pipeline + public VkPipeline basePipelineHandle = null; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + public int32 basePipelineIndex = 0; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + public this(void* pNext, VkPipelineCreateFlags flags, Span stages, Span groups, uint32 maxPipelineRayRecursionDepth, VkPipelineLibraryCreateInfoKHR* pLibraryInfo, VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface, VkPipelineDynamicStateCreateInfo* pDynamicState, VkPipelineLayout layout, VkPipeline basePipelineHandle, int32 basePipelineIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stages = stages; + this.groups = groups; + this.maxPipelineRayRecursionDepth = maxPipelineRayRecursionDepth; + this.pLibraryInfo = pLibraryInfo; + this.pLibraryInterface = pLibraryInterface; + this.pDynamicState = pDynamicState; + this.layout = layout; + this.basePipelineHandle = basePipelineHandle; + this.basePipelineIndex = basePipelineIndex; + } +} + +[CRepr] struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingPipeline = false; + public VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay = false; + public VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed = false; + public VkBool32 rayTracingPipelineTraceRaysIndirect = false; + public VkBool32 rayTraversalPrimitiveCulling = false; + + public this(void* pNext, VkBool32 rayTracingPipeline, VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay, VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed, VkBool32 rayTracingPipelineTraceRaysIndirect, VkBool32 rayTraversalPrimitiveCulling) : this() + { + this.pNext = pNext; + this.rayTracingPipeline = rayTracingPipeline; + this.rayTracingPipelineShaderGroupHandleCaptureReplay = rayTracingPipelineShaderGroupHandleCaptureReplay; + this.rayTracingPipelineShaderGroupHandleCaptureReplayMixed = rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + this.rayTracingPipelineTraceRaysIndirect = rayTracingPipelineTraceRaysIndirect; + this.rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling; + } +} + +[CRepr] struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderGroupHandleSize = 0; + public uint32 maxRayRecursionDepth = 0; + public uint32 maxShaderGroupStride = 0; + public uint32 shaderGroupBaseAlignment = 0; + public uint32 shaderGroupHandleCaptureReplaySize = 0; + public uint32 maxRayDispatchInvocationCount = 0; + public uint32 shaderGroupHandleAlignment = 0; + public uint32 maxRayHitAttributeSize = 0; +} + +[CRepr] struct VkStridedDeviceAddressRegionKHR : this() +{ + public VkDeviceAddress deviceAddress = default; + public VkDeviceSize stride = default; + public VkDeviceSize size = default; + + public this(VkDeviceAddress deviceAddress, VkDeviceSize stride, VkDeviceSize size) : this() + { + this.deviceAddress = deviceAddress; + this.stride = stride; + this.size = size; + } +} + +[CRepr] struct VkTraceRaysIndirectCommandKHR : this() +{ + public uint32 width = 0; + public uint32 height = 0; + public uint32 depth = 0; + + public this(uint32 width, uint32 height, uint32 depth) : this() + { + this.width = width; + this.height = height; + this.depth = depth; + } +} + +[CRepr] struct VkRayTracingPipelineInterfaceCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxPipelineRayPayloadSize = 0; + public uint32 maxPipelineRayHitAttributeSize = 0; + + public this(void* pNext, uint32 maxPipelineRayPayloadSize, uint32 maxPipelineRayHitAttributeSize) : this() + { + this.pNext = pNext; + this.maxPipelineRayPayloadSize = maxPipelineRayPayloadSize; + this.maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize; + } +} + +[AllowDuplicates] enum VkShaderGroupShaderKHR : int32 +{ + [NoShow] VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, + [NoShow] VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, + [NoShow] VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, + [NoShow] VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, + // pretty names + GeneralKHR = 0, + ClosestHitKHR = 1, + AnyHitKHR = 2, + IntersectionKHR = 3, +} + +[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 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); + +static { public const let VK_KHR_RAY_QUERY_SPEC_VERSION = 1; } +static { public const let VK_KHR_RAY_QUERY_EXTENSION_NAME = "VK_KHR_ray_query"; } + +[CRepr] struct VkPhysicalDeviceRayQueryFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayQuery = false; + + public this(void* pNext, VkBool32 rayQuery) : this() + { + this.pNext = pNext; + this.rayQuery = rayQuery; + } +} + +static { public const let VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1; } +static { public const let VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME = "VK_NV_framebuffer_mixed_samples"; } + +[CRepr] struct VkPipelineCoverageModulationStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCoverageModulationStateCreateFlagsNV flags = default; + public VkCoverageModulationModeNV coverageModulationMode = default; + public VkBool32 coverageModulationTableEnable = false; + public uint32 coverageModulationTableCount = 0; + public float* pCoverageModulationTable = null; + public Span coverageModulationTable + { + get { return .(pCoverageModulationTable, (.)coverageModulationTableCount); } + set mut { pCoverageModulationTable = value.Ptr; coverageModulationTableCount = (.)value.Length; } + } + + public this(void* pNext, VkPipelineCoverageModulationStateCreateFlagsNV flags, VkCoverageModulationModeNV coverageModulationMode, VkBool32 coverageModulationTableEnable, Span coverageModulationTable = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.coverageModulationMode = coverageModulationMode; + this.coverageModulationTableEnable = coverageModulationTableEnable; + this.coverageModulationTable = coverageModulationTable; + } +} + +typealias VkPipelineCoverageModulationStateCreateFlagsNV = VkFlags; + +[AllowDuplicates] enum VkCoverageModulationModeNV : int32 +{ + [NoShow] VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + [NoShow] VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + [NoShow] VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + [NoShow] VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + // pretty names + NoneNV = 0, + RgbNV = 1, + AlphaNV = 2, + RgbaNV = 3, +} + +typealias VkAttachmentSampleCountInfoNV = VkAttachmentSampleCountInfoAMD; + +static { public const let VK_NV_FILL_RECTANGLE_SPEC_VERSION = 1; } +static { public const let VK_NV_FILL_RECTANGLE_EXTENSION_NAME = "VK_NV_fill_rectangle"; } +static { public const let VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION = 1; } +static { public const let VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME = "VK_NV_shader_sm_builtins"; } + +[CRepr] struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderSMCount = 0; + public uint32 shaderWarpsPerSM = 0; +} + +[CRepr] struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderSMBuiltins = false; + + public this(void* pNext, VkBool32 shaderSMBuiltins) : this() + { + this.pNext = pNext; + this.shaderSMBuiltins = shaderSMBuiltins; + } +} + +static { public const let VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION = 1; } +static { public const let VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME = "VK_EXT_post_depth_coverage"; } +static { public const let VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION = 14; } +static { public const let VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME = "VK_KHR_sampler_ycbcr_conversion"; } + +typealias VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfo; +typealias VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfo; +typealias VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfo; +typealias VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfo; +typealias VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeatures; +typealias VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatProperties; + +typealias PFN_vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversion; +typealias PFN_vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversion; + +typealias VkSamplerYcbcrConversionKHR = VkSamplerYcbcrConversion; +typealias VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversion; +typealias VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRange; +typealias VkChromaLocationKHR = VkChromaLocation; + +static { public const let VK_KHR_BIND_MEMORY_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_BIND_MEMORY_2_EXTENSION_NAME = "VK_KHR_bind_memory2"; } + +typealias PFN_vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2; +typealias PFN_vkBindImageMemory2KHR = PFN_vkBindImageMemory2; + +typealias VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfo; +typealias VkBindImageMemoryInfoKHR = VkBindImageMemoryInfo; + +static { public const let VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION = 2; } +static { public const let VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME = "VK_EXT_image_drm_format_modifier"; } + +[CRepr] struct VkDrmFormatModifierPropertiesListEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 drmFormatModifierCount = 0; + public VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties = null; + public Span drmFormatModifierProperties + { + get { return .(pDrmFormatModifierProperties, (.)drmFormatModifierCount); } + set mut { pDrmFormatModifierProperties = value.Ptr; drmFormatModifierCount = (.)value.Length; } + } +} + +[CRepr] struct VkDrmFormatModifierPropertiesEXT : this() +{ + public uint64 drmFormatModifier = 0; + public uint32 drmFormatModifierPlaneCount = 0; + public VkFormatFeatureFlags drmFormatModifierTilingFeatures = default; +} + +[CRepr] struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 drmFormatModifier = 0; + public VkSharingMode sharingMode = default; + public uint32 queueFamilyIndexCount = 0; + public uint32* pQueueFamilyIndices = null; + public Span queueFamilyIndices + { + get { return .(pQueueFamilyIndices, (.)queueFamilyIndexCount); } + set mut { pQueueFamilyIndices = value.Ptr; queueFamilyIndexCount = (.)value.Length; } + } + + public this(void* pNext, uint64 drmFormatModifier, VkSharingMode sharingMode, Span queueFamilyIndices = default) : this() + { + this.pNext = pNext; + this.drmFormatModifier = drmFormatModifier; + this.sharingMode = sharingMode; + this.queueFamilyIndices = queueFamilyIndices; + } +} + +[CRepr] struct VkImageDrmFormatModifierListCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 drmFormatModifierCount = 0; + public uint64* pDrmFormatModifiers = null; + public Span drmFormatModifiers + { + get { return .(pDrmFormatModifiers, (.)drmFormatModifierCount); } + set mut { pDrmFormatModifiers = value.Ptr; drmFormatModifierCount = (.)value.Length; } + } + + public this(void* pNext, Span drmFormatModifiers) : this() + { + this.pNext = pNext; + this.drmFormatModifiers = drmFormatModifiers; + } +} + +[CRepr] struct VkImageDrmFormatModifierExplicitCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 drmFormatModifier = 0; + public uint32 drmFormatModifierPlaneCount = 0; + public VkSubresourceLayout* pPlaneLayouts = null; + public Span planeLayouts + { + get { return .(pPlaneLayouts, (.)drmFormatModifierPlaneCount); } + set mut { pPlaneLayouts = value.Ptr; drmFormatModifierPlaneCount = (.)value.Length; } + } + + public this(void* pNext, uint64 drmFormatModifier, Span planeLayouts) : this() + { + this.pNext = pNext; + this.drmFormatModifier = drmFormatModifier; + this.planeLayouts = planeLayouts; + } +} + +[CRepr] struct VkImageDrmFormatModifierPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 drmFormatModifier = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, out VkImageDrmFormatModifierPropertiesEXT pProperties); + +[CRepr] struct VkDrmFormatModifierPropertiesList2EXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 drmFormatModifierCount = 0; + public VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties = null; + public Span drmFormatModifierProperties + { + get { return .(pDrmFormatModifierProperties, (.)drmFormatModifierCount); } + set mut { pDrmFormatModifierProperties = value.Ptr; drmFormatModifierCount = (.)value.Length; } + } +} + +[CRepr] struct VkDrmFormatModifierProperties2EXT : this() +{ + public uint64 drmFormatModifier = 0; + public uint32 drmFormatModifierPlaneCount = 0; + public VkFormatFeatureFlags2 drmFormatModifierTilingFeatures = default; +} + +static { public const let VK_EXT_VALIDATION_CACHE_SPEC_VERSION = 1; } +static { public const let VK_EXT_VALIDATION_CACHE_EXTENSION_NAME = "VK_EXT_validation_cache"; } + +struct VkValidationCacheEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_VALIDATION_CACHE_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkValidationCacheCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkValidationCacheCreateFlagsEXT flags = default; + public c_size initialDataSize = 0; + public void* pInitialData = null; + public Span initialData + { + get { return .(pInitialData, (.)initialDataSize); } + set mut { pInitialData = value.Ptr; initialDataSize = (.)value.Length; } + } + + public this(void* pNext = null, VkValidationCacheCreateFlagsEXT flags = default, Span initialData = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.initialData = initialData; + } +} + +[CRepr] struct VkShaderModuleValidationCacheCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkValidationCacheEXT validationCache = null; + + public this(void* pNext, VkValidationCacheEXT validationCache) : this() + { + this.pNext = pNext; + this.validationCache = validationCache; + } +} + +[AllowDuplicates] enum VkValidationCacheHeaderVersionEXT : int32 +{ + [NoShow] VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + // pretty names + OneEXT = 1, +} + +typealias VkValidationCacheCreateFlagsEXT = VkFlags; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateValidationCacheEXT(VkDevice device, VkValidationCacheCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkValidationCacheEXT pValidationCache); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32 srcCacheCount, VkValidationCacheEXT* pSrcCaches); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, out c_size pDataSize, void* pData = null); + +static { public const let VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION = 2; } +static { public const let VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME = "VK_EXT_descriptor_indexing"; } + +typealias VkDescriptorSetLayoutBindingFlagsCreateInfoEXT = VkDescriptorSetLayoutBindingFlagsCreateInfo; +typealias VkPhysicalDeviceDescriptorIndexingFeaturesEXT = VkPhysicalDeviceDescriptorIndexingFeatures; +typealias VkPhysicalDeviceDescriptorIndexingPropertiesEXT = VkPhysicalDeviceDescriptorIndexingProperties; +typealias VkDescriptorSetVariableDescriptorCountAllocateInfoEXT = VkDescriptorSetVariableDescriptorCountAllocateInfo; +typealias VkDescriptorSetVariableDescriptorCountLayoutSupportEXT = VkDescriptorSetVariableDescriptorCountLayoutSupport; +typealias VkDescriptorBindingFlagBitsEXT = VkDescriptorBindingFlagBits; +typealias VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlags; + +static { public const let VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME = "VK_EXT_shader_viewport_index_layer"; } +static { public const let VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION = 1; } +static { public const let VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME = "VK_KHR_portability_subset"; } + +[CRepr] struct VkPhysicalDevicePortabilitySubsetFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 constantAlphaColorBlendFactors = false; + public VkBool32 events = false; + public VkBool32 imageViewFormatReinterpretation = false; + public VkBool32 imageViewFormatSwizzle = false; + public VkBool32 imageView2DOn3DImage = false; + public VkBool32 multisampleArrayImage = false; + public VkBool32 mutableComparisonSamplers = false; + public VkBool32 pointPolygons = false; + public VkBool32 samplerMipLodBias = false; + public VkBool32 separateStencilMaskRef = false; + public VkBool32 shaderSampleRateInterpolationFunctions = false; + public VkBool32 tessellationIsolines = false; + public VkBool32 tessellationPointMode = false; + public VkBool32 triangleFans = false; + public VkBool32 vertexAttributeAccessBeyondStride = false; + + public this(void* pNext, VkBool32 constantAlphaColorBlendFactors, VkBool32 events, VkBool32 imageViewFormatReinterpretation, VkBool32 imageViewFormatSwizzle, VkBool32 imageView2DOn3DImage, VkBool32 multisampleArrayImage, VkBool32 mutableComparisonSamplers, VkBool32 pointPolygons, VkBool32 samplerMipLodBias, VkBool32 separateStencilMaskRef, VkBool32 shaderSampleRateInterpolationFunctions, VkBool32 tessellationIsolines, VkBool32 tessellationPointMode, VkBool32 triangleFans, VkBool32 vertexAttributeAccessBeyondStride) : this() + { + this.pNext = pNext; + this.constantAlphaColorBlendFactors = constantAlphaColorBlendFactors; + this.events = events; + this.imageViewFormatReinterpretation = imageViewFormatReinterpretation; + this.imageViewFormatSwizzle = imageViewFormatSwizzle; + this.imageView2DOn3DImage = imageView2DOn3DImage; + this.multisampleArrayImage = multisampleArrayImage; + this.mutableComparisonSamplers = mutableComparisonSamplers; + this.pointPolygons = pointPolygons; + this.samplerMipLodBias = samplerMipLodBias; + this.separateStencilMaskRef = separateStencilMaskRef; + this.shaderSampleRateInterpolationFunctions = shaderSampleRateInterpolationFunctions; + this.tessellationIsolines = tessellationIsolines; + this.tessellationPointMode = tessellationPointMode; + this.triangleFans = triangleFans; + this.vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride; + } +} + +[CRepr] struct VkPhysicalDevicePortabilitySubsetPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 minVertexInputBindingStrideAlignment = 0; +} + +static { public const let VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION = 3; } +static { public const let VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME = "VK_NV_shading_rate_image"; } + +[AllowDuplicates] enum VkShadingRatePaletteEntryNV : int32 +{ + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + [NoShow] VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + // pretty names + NoInvocationsNV = 0, + _16_InvocationsPerPixelNV = 1, + _8_InvocationsPerPixelNV = 2, + _4_InvocationsPerPixelNV = 3, + _2_InvocationsPerPixelNV = 4, + _1_InvocationPerPixelNV = 5, + _1_InvocationPer2x1_PixelsNV = 6, + _1_InvocationPer1x2_PixelsNV = 7, + _1_InvocationPer2x2_PixelsNV = 8, + _1_InvocationPer4x2_PixelsNV = 9, + _1_InvocationPer2x4_PixelsNV = 10, + _1_InvocationPer4x4_PixelsNV = 11, +} + +[CRepr] struct VkShadingRatePaletteNV : this() +{ + public uint32 shadingRatePaletteEntryCount = 0; + public VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries = null; + public Span shadingRatePaletteEntries + { + get { return .(pShadingRatePaletteEntries, (.)shadingRatePaletteEntryCount); } + set mut { pShadingRatePaletteEntries = value.Ptr; shadingRatePaletteEntryCount = (.)value.Length; } + } + + public this(Span shadingRatePaletteEntries) : this() + { + this.shadingRatePaletteEntries = shadingRatePaletteEntries; + } +} + +[CRepr] struct VkPipelineViewportShadingRateImageStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shadingRateImageEnable = false; + public uint32 viewportCount = 0; + public VkShadingRatePaletteNV* pShadingRatePalettes = null; + public Span shadingRatePalettes + { + get { return .(pShadingRatePalettes, (.)viewportCount); } + set mut { pShadingRatePalettes = value.Ptr; viewportCount = (.)value.Length; } + } + + public this(void* pNext, VkBool32 shadingRateImageEnable, Span shadingRatePalettes = default) : this() + { + this.pNext = pNext; + this.shadingRateImageEnable = shadingRateImageEnable; + this.shadingRatePalettes = shadingRatePalettes; + } +} + +[CRepr] struct VkPhysicalDeviceShadingRateImageFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shadingRateImage = false; + public VkBool32 shadingRateCoarseSampleOrder = false; + + public this(void* pNext, VkBool32 shadingRateImage, VkBool32 shadingRateCoarseSampleOrder) : this() + { + this.pNext = pNext; + this.shadingRateImage = shadingRateImage; + this.shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder; + } +} + +[CRepr] struct VkPhysicalDeviceShadingRateImagePropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D shadingRateTexelSize = default; + public uint32 shadingRatePaletteSize = 0; + public uint32 shadingRateMaxCoarseSamples = 0; +} + +[CRepr] struct VkCoarseSampleLocationNV : this() +{ + public uint32 pixelX = 0; + public uint32 pixelY = 0; + public uint32 sample = 0; + + public this(uint32 pixelX, uint32 pixelY, uint32 sample) : this() + { + this.pixelX = pixelX; + this.pixelY = pixelY; + this.sample = sample; + } +} + +[CRepr] struct VkCoarseSampleOrderCustomNV : this() +{ + public VkShadingRatePaletteEntryNV shadingRate = default; + public uint32 sampleCount = 0; + public uint32 sampleLocationCount = 0; + public VkCoarseSampleLocationNV* pSampleLocations = null; + public Span sampleLocations + { + get { return .(pSampleLocations, (.)sampleLocationCount); } + set mut { pSampleLocations = value.Ptr; sampleLocationCount = (.)value.Length; } + } + + public this(VkShadingRatePaletteEntryNV shadingRate, uint32 sampleCount, Span sampleLocations) : this() + { + this.shadingRate = shadingRate; + this.sampleCount = sampleCount; + this.sampleLocations = sampleLocations; + } +} + +[CRepr] struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCoarseSampleOrderTypeNV sampleOrderType = default; + public uint32 customSampleOrderCount = 0; + public VkCoarseSampleOrderCustomNV* pCustomSampleOrders = null; + public Span customSampleOrders + { + get { return .(pCustomSampleOrders, (.)customSampleOrderCount); } + set mut { pCustomSampleOrders = value.Ptr; customSampleOrderCount = (.)value.Length; } + } + + public this(void* pNext, VkCoarseSampleOrderTypeNV sampleOrderType, Span customSampleOrders = default) : this() + { + this.pNext = pNext; + this.sampleOrderType = sampleOrderType; + this.customSampleOrders = customSampleOrders; + } +} + +[AllowDuplicates] enum VkCoarseSampleOrderTypeNV : int32 +{ + [NoShow] VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + [NoShow] VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + [NoShow] VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + [NoShow] VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + // pretty names + DefaultNV = 0, + CustomNV = 1, + PixelMajorNV = 2, + SampleMajorNV = 3, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkShadingRatePaletteNV* pShadingRatePalettes); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32 customSampleOrderCount, VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + +static { public const let VK_NV_RAY_TRACING_SPEC_VERSION = 3; } +static { public const let VK_NV_RAY_TRACING_EXTENSION_NAME = "VK_NV_ray_tracing"; } +static { public const let VK_SHADER_UNUSED_NV = VK_SHADER_UNUSED_KHR; } + +[CRepr] struct VkRayTracingShaderGroupCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRayTracingShaderGroupTypeKHR type = default; + public uint32 generalShader = 0; + public uint32 closestHitShader = 0; + public uint32 anyHitShader = 0; + public uint32 intersectionShader = 0; + + public this(void* pNext, VkRayTracingShaderGroupTypeKHR type, uint32 generalShader, uint32 closestHitShader, uint32 anyHitShader, uint32 intersectionShader) : this() + { + this.pNext = pNext; + this.type = type; + this.generalShader = generalShader; + this.closestHitShader = closestHitShader; + this.anyHitShader = anyHitShader; + this.intersectionShader = intersectionShader; + } +} + +typealias VkRayTracingShaderGroupTypeNV = VkRayTracingShaderGroupTypeKHR; + +[CRepr] struct VkRayTracingPipelineCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags flags = default; // Pipeline creation flags + public uint32 stageCount = 0; + public VkPipelineShaderStageCreateInfo* pStages = null; // One entry for each active shader stage + public Span stages + { + get { return .(pStages, (.)stageCount); } + set mut { pStages = value.Ptr; stageCount = (.)value.Length; } + } + public uint32 groupCount = 0; + public VkRayTracingShaderGroupCreateInfoNV* pGroups = null; + public Span groups + { + get { return .(pGroups, (.)groupCount); } + set mut { pGroups = value.Ptr; groupCount = (.)value.Length; } + } + public uint32 maxRecursionDepth = 0; + public VkPipelineLayout layout = null; // Interface layout of the pipeline + public VkPipeline basePipelineHandle = null; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + public int32 basePipelineIndex = 0; // If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + public this(void* pNext, VkPipelineCreateFlags flags, Span stages, Span groups, uint32 maxRecursionDepth, VkPipelineLayout layout, VkPipeline basePipelineHandle, int32 basePipelineIndex) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stages = stages; + this.groups = groups; + this.maxRecursionDepth = maxRecursionDepth; + this.layout = layout; + this.basePipelineHandle = basePipelineHandle; + this.basePipelineIndex = basePipelineIndex; + } +} + +typealias VkGeometryTypeNV = VkGeometryTypeKHR; +typealias VkAccelerationStructureTypeNV = VkAccelerationStructureTypeKHR; + +[CRepr] struct VkGeometryTrianglesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer vertexData = null; + public VkDeviceSize vertexOffset = default; + public uint32 vertexCount = 0; + public VkDeviceSize vertexStride = default; + public VkFormat vertexFormat = default; + public VkBuffer indexData = null; + public VkDeviceSize indexOffset = default; + public uint32 indexCount = 0; + public VkIndexType indexType = default; + public VkBuffer transformData = null; // Optional reference to array of floats representing a 3x4 row major affine transformation matrix. + public VkDeviceSize transformOffset = default; + + public this(void* pNext, VkBuffer vertexData, VkDeviceSize vertexOffset, uint32 vertexCount, VkDeviceSize vertexStride, VkFormat vertexFormat, VkBuffer indexData, VkDeviceSize indexOffset, uint32 indexCount, VkIndexType indexType, VkBuffer transformData, VkDeviceSize transformOffset) : this() + { + this.pNext = pNext; + this.vertexData = vertexData; + this.vertexOffset = vertexOffset; + this.vertexCount = vertexCount; + this.vertexStride = vertexStride; + this.vertexFormat = vertexFormat; + this.indexData = indexData; + this.indexOffset = indexOffset; + this.indexCount = indexCount; + this.indexType = indexType; + this.transformData = transformData; + this.transformOffset = transformOffset; + } +} + +[CRepr] struct VkGeometryAABBNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer aabbData = null; + public uint32 numAABBs = 0; + public uint32 stride = 0; // Stride in bytes between AABBs + public VkDeviceSize offset = default; // Offset in bytes of the first AABB in aabbData + + public this(void* pNext, VkBuffer aabbData, uint32 numAABBs, uint32 stride, VkDeviceSize offset) : this() + { + this.pNext = pNext; + this.aabbData = aabbData; + this.numAABBs = numAABBs; + this.stride = stride; + this.offset = offset; + } +} + +[CRepr] struct VkGeometryDataNV : this() +{ + public VkGeometryTrianglesNV triangles = default; + public VkGeometryAABBNV aabbs = default; + + public this(VkGeometryTrianglesNV triangles, VkGeometryAABBNV aabbs) : this() + { + this.triangles = triangles; + this.aabbs = aabbs; + } +} + +[CRepr] struct VkGeometryNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GEOMETRY_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkGeometryTypeKHR geometryType = default; + public VkGeometryDataNV geometry = default; + public VkGeometryFlagsKHR flags = default; + + public this(void* pNext, VkGeometryTypeKHR geometryType, VkGeometryDataNV geometry, VkGeometryFlagsKHR flags = default) : this() + { + this.pNext = pNext; + this.geometryType = geometryType; + this.geometry = geometry; + this.flags = flags; + } +} + +typealias VkGeometryFlagsNV = VkGeometryFlagsKHR; +typealias VkGeometryFlagBitsNV = VkGeometryFlagBitsKHR; +typealias VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsKHR; +typealias VkGeometryInstanceFlagBitsNV = VkGeometryInstanceFlagBitsKHR; + +[CRepr] struct VkAccelerationStructureInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureTypeNV type = default; + public VkBuildAccelerationStructureFlagsNV flags = default; + public uint32 instanceCount = 0; + public uint32 geometryCount = 0; + public VkGeometryNV* pGeometries = null; + public Span geometries + { + get { return .(pGeometries, (.)geometryCount); } + set mut { pGeometries = value.Ptr; geometryCount = (.)value.Length; } + } + + public this(void* pNext, VkAccelerationStructureTypeNV type, VkBuildAccelerationStructureFlagsNV flags = default, uint32 instanceCount = 0, Span geometries = default) : this() + { + this.pNext = pNext; + this.type = type; + this.flags = flags; + this.instanceCount = instanceCount; + this.geometries = geometries; + } +} + +[CRepr] struct VkAccelerationStructureCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize compactedSize = default; + public VkAccelerationStructureInfoNV info = default; + + public this(void* pNext, VkDeviceSize compactedSize, VkAccelerationStructureInfoNV info) : this() + { + this.pNext = pNext; + this.compactedSize = compactedSize; + this.info = info; + } +} + +struct VkAccelerationStructureNV : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkBuildAccelerationStructureFlagBitsNV = VkBuildAccelerationStructureFlagBitsKHR; +typealias VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsKHR; +typealias VkCopyAccelerationStructureModeNV = VkCopyAccelerationStructureModeKHR; + +[CRepr] struct VkBindAccelerationStructureMemoryInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureNV accelerationStructure = null; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + public uint32 deviceIndexCount = 0; + public uint32* pDeviceIndices = null; + public Span deviceIndices + { + get { return .(pDeviceIndices, (.)deviceIndexCount); } + set mut { pDeviceIndices = value.Ptr; deviceIndexCount = (.)value.Length; } + } + + public this(void* pNext, VkAccelerationStructureNV accelerationStructure, VkDeviceMemory memory, VkDeviceSize memoryOffset, Span deviceIndices = default) : this() + { + this.pNext = pNext; + this.accelerationStructure = accelerationStructure; + this.memory = memory; + this.memoryOffset = memoryOffset; + this.deviceIndices = deviceIndices; + } +} + +[CRepr] struct VkWriteDescriptorSetAccelerationStructureNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 accelerationStructureCount = 0; + public VkAccelerationStructureNV* pAccelerationStructures = null; + public Span accelerationStructures + { + get { return .(pAccelerationStructures, (.)accelerationStructureCount); } + set mut { pAccelerationStructures = value.Ptr; accelerationStructureCount = (.)value.Length; } + } + + public this(void* pNext, Span accelerationStructures) : this() + { + this.pNext = pNext; + this.accelerationStructures = accelerationStructures; + } +} + +[CRepr] struct VkAccelerationStructureMemoryRequirementsInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureMemoryRequirementsTypeNV type = default; + public VkAccelerationStructureNV accelerationStructure = null; + + public this(void* pNext, VkAccelerationStructureMemoryRequirementsTypeNV type, VkAccelerationStructureNV accelerationStructure) : this() + { + this.pNext = pNext; + this.type = type; + this.accelerationStructure = accelerationStructure; + } +} + +[CRepr] struct VkPhysicalDeviceRayTracingPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderGroupHandleSize = 0; + public uint32 maxRecursionDepth = 0; + public uint32 maxShaderGroupStride = 0; + public uint32 shaderGroupBaseAlignment = 0; + public uint64 maxGeometryCount = 0; + public uint64 maxInstanceCount = 0; + public uint64 maxTriangleCount = 0; + public uint32 maxDescriptorSetAccelerationStructures = 0; +} + +[AllowDuplicates] enum VkAccelerationStructureMemoryRequirementsTypeNV : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + [NoShow] VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + [NoShow] VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + // pretty names + ObjectNV = 0, + BuildScratchNV = 1, + UpdateScratchNV = 2, +} + +typealias VkTransformMatrixNV = VkTransformMatrixKHR; +typealias VkAabbPositionsNV = VkAabbPositionsKHR; +typealias VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateAccelerationStructureNV(VkDevice device, VkAccelerationStructureCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkAccelerationStructureNV pAccelerationStructure); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, out VkMemoryRequirements2KHR pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32 bindInfoCount, VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +[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 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); + +static { public const let VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION = 2; } +static { public const let VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME = "VK_NV_representative_fragment_test"; } + +[CRepr] struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 representativeFragmentTest = false; + + public this(void* pNext, VkBool32 representativeFragmentTest) : this() + { + this.pNext = pNext; + this.representativeFragmentTest = representativeFragmentTest; + } +} + +[CRepr] struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 representativeFragmentTestEnable = false; + + public this(void* pNext, VkBool32 representativeFragmentTestEnable) : this() + { + this.pNext = pNext; + this.representativeFragmentTestEnable = representativeFragmentTestEnable; + } +} + +static { public const let VK_KHR_MAINTENANCE_3_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_3_EXTENSION_NAME = "VK_KHR_maintenance3"; } +static { public const let VK_KHR_MAINTENANCE3_SPEC_VERSION = VK_KHR_MAINTENANCE_3_SPEC_VERSION; } +static { public const let VK_KHR_MAINTENANCE3_EXTENSION_NAME = VK_KHR_MAINTENANCE_3_EXTENSION_NAME; } + +typealias VkPhysicalDeviceMaintenance3PropertiesKHR = VkPhysicalDeviceMaintenance3Properties; +typealias VkDescriptorSetLayoutSupportKHR = VkDescriptorSetLayoutSupport; + +typealias PFN_vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupport; + +static { public const let VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1; } +static { public const let VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_KHR_draw_indirect_count"; } + +typealias PFN_vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCount; +typealias PFN_vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCount; + +static { public const let VK_EXT_FILTER_CUBIC_SPEC_VERSION = 3; } +static { public const let VK_EXT_FILTER_CUBIC_EXTENSION_NAME = "VK_EXT_filter_cubic"; } + +[CRepr] struct VkPhysicalDeviceImageViewImageFormatInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageViewType imageViewType = default; + + public this(void* pNext, VkImageViewType imageViewType) : this() + { + this.pNext = pNext; + this.imageViewType = imageViewType; + } +} + +[CRepr] struct VkFilterCubicImageViewImageFormatPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 filterCubic = false; // The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT + public VkBool32 filterCubicMinmax = false; // The combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max +} + +static { public const let VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION = 4; } +static { public const let VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME = "VK_QCOM_render_pass_shader_resolve"; } +static { public const let VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION = 2; } +static { public const let VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME = "VK_EXT_global_priority"; } + +typealias VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfo; +typealias VkQueueGlobalPriorityEXT = VkQueueGlobalPriority; + +static { public const let VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME = "VK_KHR_shader_subgroup_extended_types"; } + +typealias VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +static { public const let VK_KHR_8BIT_STORAGE_SPEC_VERSION = 1; } +static { public const let VK_KHR_8BIT_STORAGE_EXTENSION_NAME = "VK_KHR_8bit_storage"; } + +typealias VkPhysicalDevice8BitStorageFeaturesKHR = VkPhysicalDevice8BitStorageFeatures; + +static { public const let VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME = "VK_EXT_external_memory_host"; } + +[CRepr] struct VkImportMemoryHostPointerInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + public void* pHostPointer = null; + + public this(void* pNext, VkExternalMemoryHandleTypeFlagBits handleType, void* pHostPointer) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.pHostPointer = pHostPointer; + } +} + +[CRepr] struct VkMemoryHostPointerPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize minImportedHostPointerAlignment = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, void* pHostPointer, out VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties); + +static { public const let VK_AMD_BUFFER_MARKER_SPEC_VERSION = 1; } +static { public const let VK_AMD_BUFFER_MARKER_EXTENSION_NAME = "VK_AMD_buffer_marker"; } + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32 marker); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32 marker); + +static { public const let VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME = "VK_KHR_shader_atomic_int64"; } + +typealias VkPhysicalDeviceShaderAtomicInt64FeaturesKHR = VkPhysicalDeviceShaderAtomicInt64Features; + +static { public const let VK_KHR_SHADER_CLOCK_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_CLOCK_EXTENSION_NAME = "VK_KHR_shader_clock"; } + +[CRepr] struct VkPhysicalDeviceShaderClockFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderSubgroupClock = false; + public VkBool32 shaderDeviceClock = false; + + public this(void* pNext, VkBool32 shaderSubgroupClock, VkBool32 shaderDeviceClock) : this() + { + this.pNext = pNext; + this.shaderSubgroupClock = shaderSubgroupClock; + this.shaderDeviceClock = shaderDeviceClock; + } +} + +static { public const let VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME = "VK_AMD_pipeline_compiler_control"; } + +[AllowDuplicates] enum VkPipelineCompilerControlFlagBitsAMD : int32 +{ + // pretty names +} + +typealias VkPipelineCompilerControlFlagsAMD = VkPipelineCompilerControlFlagBitsAMD; + +[CRepr] struct VkPipelineCompilerControlCreateInfoAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCompilerControlFlagsAMD compilerControlFlags = default; + + public this(void* pNext = null, VkPipelineCompilerControlFlagsAMD compilerControlFlags = default) : this() + { + this.pNext = pNext; + this.compilerControlFlags = compilerControlFlags; + } +} + +static { public const let VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION = 2; } +static { public const let VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME = "VK_EXT_calibrated_timestamps"; } + +typealias VkTimeDomainEXT = VkTimeDomainKHR; +typealias VkCalibratedTimestampInfoEXT = VkCalibratedTimestampInfoKHR; + +typealias PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; +typealias PFN_vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsKHR; + +static { public const let VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION = 2; } +static { public const let VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME = "VK_AMD_shader_core_properties"; } + +[CRepr] struct VkPhysicalDeviceShaderCorePropertiesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderEngineCount = 0; // number of shader engines + public uint32 shaderArraysPerEngineCount = 0; // number of shader arrays + public uint32 computeUnitsPerShaderArray = 0; // number of physical CUs per shader array + public uint32 simdPerComputeUnit = 0; // number of SIMDs per compute unit + public uint32 wavefrontsPerSimd = 0; // number of wavefront slots in each SIMD + public uint32 wavefrontSize = 0; // maximum number of threads per wavefront + public uint32 sgprsPerSimd = 0; // number of physical SGPRs per SIMD + public uint32 minSgprAllocation = 0; // minimum number of SGPRs that can be allocated by a wave + public uint32 maxSgprAllocation = 0; // number of available SGPRs + public uint32 sgprAllocationGranularity = 0; // SGPRs are allocated in groups of this size + public uint32 vgprsPerSimd = 0; // number of physical VGPRs per SIMD + public uint32 minVgprAllocation = 0; // minimum number of VGPRs that can be allocated by a wave + public uint32 maxVgprAllocation = 0; // number of available VGPRs + public uint32 vgprAllocationGranularity = 0; // VGPRs are allocated in groups of this size +} + +static { public const let VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION = 8; } +static { public const let VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME = "VK_KHR_video_decode_h265"; } + +[CRepr] struct VkVideoDecodeH265ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH265ProfileIdc stdProfileIdc = default; + + public this(void* pNext, StdVideoH265ProfileIdc stdProfileIdc) : this() + { + this.pNext = pNext; + this.stdProfileIdc = stdProfileIdc; + } +} + +[CRepr] struct VkVideoDecodeH265CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH265LevelIdc maxLevelIdc = default; +} + +[CRepr] struct VkVideoDecodeH265SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxStdVPSCount = 0; + public uint32 maxStdSPSCount = 0; + public uint32 maxStdPPSCount = 0; + public VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo = null; + + public this(void* pNext, uint32 maxStdVPSCount, uint32 maxStdSPSCount, uint32 maxStdPPSCount, VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo = null) : this() + { + this.pNext = pNext; + this.maxStdVPSCount = maxStdVPSCount; + this.maxStdSPSCount = maxStdSPSCount; + this.maxStdPPSCount = maxStdPPSCount; + this.pParametersAddInfo = pParametersAddInfo; + } +} + +[CRepr] struct VkVideoDecodeH265SessionParametersAddInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stdVPSCount = 0; + public StdVideoH265VideoParameterSet* pStdVPSs = null; + public Span stdVPSs + { + get { return .(pStdVPSs, (.)stdVPSCount); } + set mut { pStdVPSs = value.Ptr; stdVPSCount = (.)value.Length; } + } + public uint32 stdSPSCount = 0; + public StdVideoH265SequenceParameterSet* pStdSPSs = null; + public Span stdSPSs + { + get { return .(pStdSPSs, (.)stdSPSCount); } + set mut { pStdSPSs = value.Ptr; stdSPSCount = (.)value.Length; } + } + public uint32 stdPPSCount = 0; + public StdVideoH265PictureParameterSet* pStdPPSs = null; // List of Picture Parameters associated with the spsStd, above + public Span stdPPSs + { + get { return .(pStdPPSs, (.)stdPPSCount); } + set mut { pStdPPSs = value.Ptr; stdPPSCount = (.)value.Length; } + } + + public this(void* pNext = null, Span stdVPSs = default, Span stdSPSs = default, Span stdPPSs = default) : this() + { + this.pNext = pNext; + this.stdVPSs = stdVPSs; + this.stdSPSs = stdSPSs; + this.stdPPSs = stdPPSs; + } +} + +[CRepr] struct VkVideoDecodeH265PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeH265PictureInfo* pStdPictureInfo = null; + public uint32 sliceSegmentCount = 0; + public uint32* pSliceSegmentOffsets = null; + public Span sliceSegmentOffsets + { + get { return .(pSliceSegmentOffsets, (.)sliceSegmentCount); } + set mut { pSliceSegmentOffsets = value.Ptr; sliceSegmentCount = (.)value.Length; } + } + + public this(void* pNext, StdVideoDecodeH265PictureInfo* pStdPictureInfo, Span sliceSegmentOffsets) : this() + { + this.pNext = pNext; + this.pStdPictureInfo = pStdPictureInfo; + this.sliceSegmentOffsets = sliceSegmentOffsets; + } +} + +[CRepr] struct VkVideoDecodeH265DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +static { public const let VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION = 1; } +static { public const let VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME = "VK_KHR_global_priority"; } +static { public const let VK_MAX_GLOBAL_PRIORITY_SIZE_KHR = VK_MAX_GLOBAL_PRIORITY_SIZE; } + +typealias VkDeviceQueueGlobalPriorityCreateInfoKHR = VkDeviceQueueGlobalPriorityCreateInfo; +typealias VkQueueGlobalPriorityKHR = VkQueueGlobalPriority; +typealias VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR = VkPhysicalDeviceGlobalPriorityQueryFeatures; +typealias VkQueueFamilyGlobalPriorityPropertiesKHR = VkQueueFamilyGlobalPriorityProperties; + +static { public const let VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION = 1; } +static { public const let VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME = "VK_AMD_memory_overallocation_behavior"; } + +[AllowDuplicates] enum VkMemoryOverallocationBehaviorAMD : int32 +{ + [NoShow] VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + [NoShow] VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + [NoShow] VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + // pretty names + DefaultAMD = 0, + AllowedAMD = 1, + DisallowedAMD = 2, +} + +[CRepr] struct VkDeviceMemoryOverallocationCreateInfoAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryOverallocationBehaviorAMD overallocationBehavior = default; + + public this(void* pNext, VkMemoryOverallocationBehaviorAMD overallocationBehavior) : this() + { + this.pNext = pNext; + this.overallocationBehavior = overallocationBehavior; + } +} + +static { public const let VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION = 3; } +static { public const let VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME = "VK_EXT_vertex_attribute_divisor"; } + +[CRepr] struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxVertexAttribDivisor = 0; // max value of vertex attribute divisor +} + +typealias VkVertexInputBindingDivisorDescriptionEXT = VkVertexInputBindingDivisorDescription; +typealias VkPipelineVertexInputDivisorStateCreateInfoEXT = VkPipelineVertexInputDivisorStateCreateInfo; +typealias VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = VkPhysicalDeviceVertexAttributeDivisorFeatures; + +static { public const let VK_GGP_FRAME_TOKEN_SPEC_VERSION = 1; } +static { public const let VK_GGP_FRAME_TOKEN_EXTENSION_NAME = "VK_GGP_frame_token"; } + +[CRepr] struct VkPresentFrameTokenGGP : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; + public VkStructureType sType = SType; + public void* pNext = null; + public GgpFrameToken frameToken = default; + + public this(void* pNext, GgpFrameToken frameToken) : this() + { + this.pNext = pNext; + this.frameToken = frameToken; + } +} + +static { public const let VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION = 1; } +static { public const let VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME = "VK_EXT_pipeline_creation_feedback"; } + +typealias VkPipelineCreationFeedbackFlagBitsEXT = VkPipelineCreationFeedbackFlagBits; +typealias VkPipelineCreationFeedbackFlagsEXT = VkPipelineCreationFeedbackFlags; +typealias VkPipelineCreationFeedbackCreateInfoEXT = VkPipelineCreationFeedbackCreateInfo; +typealias VkPipelineCreationFeedbackEXT = VkPipelineCreationFeedback; + +static { public const let VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME = "VK_KHR_driver_properties"; } +static { public const let VK_MAX_DRIVER_NAME_SIZE_KHR = VK_MAX_DRIVER_NAME_SIZE; } +static { public const let VK_MAX_DRIVER_INFO_SIZE_KHR = VK_MAX_DRIVER_INFO_SIZE; } + +typealias VkDriverIdKHR = VkDriverId; +typealias VkConformanceVersionKHR = VkConformanceVersion; +typealias VkPhysicalDeviceDriverPropertiesKHR = VkPhysicalDeviceDriverProperties; + +static { public const let VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION = 4; } +static { public const let VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME = "VK_KHR_shader_float_controls"; } + +typealias VkPhysicalDeviceFloatControlsPropertiesKHR = VkPhysicalDeviceFloatControlsProperties; +typealias VkShaderFloatControlsIndependenceKHR = VkShaderFloatControlsIndependence; + +static { public const let VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION = 1; } +static { public const let VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME = "VK_NV_shader_subgroup_partitioned"; } +static { public const let VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION = 1; } +static { public const let VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME = "VK_KHR_depth_stencil_resolve"; } + +typealias VkSubpassDescriptionDepthStencilResolveKHR = VkSubpassDescriptionDepthStencilResolve; +typealias VkPhysicalDeviceDepthStencilResolvePropertiesKHR = VkPhysicalDeviceDepthStencilResolveProperties; +typealias VkResolveModeFlagBitsKHR = VkResolveModeFlagBits; +typealias VkResolveModeFlagsKHR = VkResolveModeFlags; + +static { public const let VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION = 1; } +static { public const let VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME = "VK_KHR_swapchain_mutable_format"; } +static { public const let VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION = 1; } +static { public const let VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME = "VK_NV_compute_shader_derivatives"; } + +typealias VkPhysicalDeviceComputeShaderDerivativesFeaturesNV = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; + +static { public const let VK_NV_MESH_SHADER_SPEC_VERSION = 1; } +static { public const let VK_NV_MESH_SHADER_EXTENSION_NAME = "VK_NV_mesh_shader"; } + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32 taskCount, uint32 firstTask); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride); + +[CRepr] struct VkPhysicalDeviceMeshShaderFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 taskShader = false; + public VkBool32 meshShader = false; + + public this(void* pNext, VkBool32 taskShader, VkBool32 meshShader) : this() + { + this.pNext = pNext; + this.taskShader = taskShader; + this.meshShader = meshShader; + } +} + +[CRepr] struct VkPhysicalDeviceMeshShaderPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxDrawMeshTasksCount = 0; + public uint32 maxTaskWorkGroupInvocations = 0; + public uint32[3] maxTaskWorkGroupSize = .(); + public uint32 maxTaskTotalMemorySize = 0; + public uint32 maxTaskOutputCount = 0; + public uint32 maxMeshWorkGroupInvocations = 0; + public uint32[3] maxMeshWorkGroupSize = .(); + public uint32 maxMeshTotalMemorySize = 0; + public uint32 maxMeshOutputVertices = 0; + public uint32 maxMeshOutputPrimitives = 0; + public uint32 maxMeshMultiviewViewCount = 0; + public uint32 meshOutputPerVertexGranularity = 0; + public uint32 meshOutputPerPrimitiveGranularity = 0; +} + +[CRepr] struct VkDrawMeshTasksIndirectCommandNV : this() +{ + public uint32 taskCount = 0; + public uint32 firstTask = 0; + + public this(uint32 taskCount, uint32 firstTask) : this() + { + this.taskCount = taskCount; + this.firstTask = firstTask; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride); + +static { public const let VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION = 1; } +static { public const let VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME = "VK_NV_fragment_shader_barycentric"; } + +typealias VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +static { public const let VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION = 2; } +static { public const let VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME = "VK_NV_shader_image_footprint"; } + +[CRepr] struct VkPhysicalDeviceShaderImageFootprintFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imageFootprint = false; + + public this(void* pNext, VkBool32 imageFootprint) : this() + { + this.pNext = pNext; + this.imageFootprint = imageFootprint; + } +} + +static { public const let VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION = 2; } +static { public const let VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME = "VK_NV_scissor_exclusive"; } + +[CRepr] struct VkPipelineViewportExclusiveScissorStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 exclusiveScissorCount = 0; + public VkRect2D* pExclusiveScissors = null; + public Span exclusiveScissors + { + get { return .(pExclusiveScissors, (.)exclusiveScissorCount); } + set mut { pExclusiveScissors = value.Ptr; exclusiveScissorCount = (.)value.Length; } + } + + public this(void* pNext = null, Span exclusiveScissors = default) : this() + { + this.pNext = pNext; + this.exclusiveScissors = exclusiveScissors; + } +} + +[CRepr] struct VkPhysicalDeviceExclusiveScissorFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 exclusiveScissor = false; + + public this(void* pNext, VkBool32 exclusiveScissor) : this() + { + this.pNext = pNext; + this.exclusiveScissor = exclusiveScissor; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, uint32 exclusiveScissorCount, VkBool32* pExclusiveScissorEnables); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32 firstExclusiveScissor, uint32 exclusiveScissorCount, VkRect2D* pExclusiveScissors); + +static { public const let VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION = 2; } +static { public const let VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME = "VK_NV_device_diagnostic_checkpoints"; } + +[CRepr] struct VkQueueFamilyCheckpointPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags checkpointExecutionStageMask = default; +} + +[CRepr] struct VkCheckpointDataNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlagBits stage = default; + public void* pCheckpointMarker = null; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, void* pCheckpointMarker); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetQueueCheckpointDataNV(VkQueue queue, out uint32 pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData = null); + +[CRepr] struct VkQueueFamilyCheckpointProperties2NV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 checkpointExecutionStageMask = default; +} + +[CRepr] struct VkCheckpointData2NV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 stage = default; + public void* pCheckpointMarker = null; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetQueueCheckpointData2NV(VkQueue queue, out uint32 pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData = null); + +static { public const let VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION = 2; } +static { public const let VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME = "VK_KHR_timeline_semaphore"; } + +typealias VkSemaphoreTypeKHR = VkSemaphoreType; +typealias VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = VkPhysicalDeviceTimelineSemaphoreFeatures; +typealias VkPhysicalDeviceTimelineSemaphorePropertiesKHR = VkPhysicalDeviceTimelineSemaphoreProperties; +typealias VkSemaphoreTypeCreateInfoKHR = VkSemaphoreTypeCreateInfo; +typealias VkTimelineSemaphoreSubmitInfoKHR = VkTimelineSemaphoreSubmitInfo; +typealias VkSemaphoreWaitFlagBitsKHR = VkSemaphoreWaitFlagBits; +typealias VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlags; +typealias VkSemaphoreWaitInfoKHR = VkSemaphoreWaitInfo; +typealias VkSemaphoreSignalInfoKHR = VkSemaphoreSignalInfo; + +typealias PFN_vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValue; +typealias PFN_vkWaitSemaphoresKHR = PFN_vkWaitSemaphores; +typealias PFN_vkSignalSemaphoreKHR = PFN_vkSignalSemaphore; + +static { public const let VK_EXT_PRESENT_TIMING_SPEC_VERSION = 3; } +static { public const let VK_EXT_PRESENT_TIMING_EXTENSION_NAME = "VK_EXT_present_timing"; } + +[CRepr] struct VkPhysicalDevicePresentTimingFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentTiming = false; // vkGetPastPresentationTimingEXT is supported + public VkBool32 presentAtAbsoluteTime = false; // Absolute time can be used to specify present time + public VkBool32 presentAtRelativeTime = false; // Relative time can be used to specify present duration + + public this(void* pNext, VkBool32 presentTiming, VkBool32 presentAtAbsoluteTime, VkBool32 presentAtRelativeTime) : this() + { + this.pNext = pNext; + this.presentTiming = presentTiming; + this.presentAtAbsoluteTime = presentAtAbsoluteTime; + this.presentAtRelativeTime = presentAtRelativeTime; + } +} + +[CRepr] struct VkPresentTimingSurfaceCapabilitiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentTimingSupported = false; // presentation timings of the surface can be queried using vkGetPastPresentationTimingEXT + public VkBool32 presentAtAbsoluteTimeSupported = false; // surface can be presented using absolute times + public VkBool32 presentAtRelativeTimeSupported = false; // surface can be presented using relative times + public VkPresentStageFlagsEXT presentStageQueries = default; // present stages that can be queried + + public this(void* pNext, VkBool32 presentTimingSupported, VkBool32 presentAtAbsoluteTimeSupported, VkBool32 presentAtRelativeTimeSupported, VkPresentStageFlagsEXT presentStageQueries) : this() + { + this.pNext = pNext; + this.presentTimingSupported = presentTimingSupported; + this.presentAtAbsoluteTimeSupported = presentAtAbsoluteTimeSupported; + this.presentAtRelativeTimeSupported = presentAtRelativeTimeSupported; + this.presentStageQueries = presentStageQueries; + } +} + +[CRepr] struct VkSwapchainCalibratedTimestampInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainKHR swapchain = null; + public VkPresentStageFlagsEXT presentStage = default; + public uint64 timeDomainId = 0; + + public this(void* pNext, VkSwapchainKHR swapchain, VkPresentStageFlagsEXT presentStage, uint64 timeDomainId) : this() + { + this.pNext = pNext; + this.swapchain = swapchain; + this.presentStage = presentStage; + this.timeDomainId = timeDomainId; + } +} + +[CRepr] struct VkSwapchainTimingPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 refreshDuration = 0; // Number of nanoseconds from the start of one refresh cycle to the next + public uint64 refreshInterval = 0; // Interval in nanoseconds between refresh cycles durations + + public this(void* pNext, uint64 refreshDuration, uint64 refreshInterval) : this() + { + this.pNext = pNext; + this.refreshDuration = refreshDuration; + this.refreshInterval = refreshInterval; + } +} + +[CRepr] struct VkSwapchainTimeDomainPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 timeDomainCount = 0; + public VkTimeDomainKHR* pTimeDomains = null; // Available time domains to use with the swapchain + public uint64* pTimeDomainIds = null; // Unique identifier for a time domain + + public this(void* pNext, uint32 timeDomainCount, VkTimeDomainKHR* pTimeDomains = null, uint64* pTimeDomainIds = null) : this() + { + this.pNext = pNext; + this.timeDomainCount = timeDomainCount; + this.pTimeDomains = pTimeDomains; + this.pTimeDomainIds = pTimeDomainIds; + } +} + +[CRepr] struct VkPastPresentationTimingInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPastPresentationTimingFlagsEXT flags = default; + public VkSwapchainKHR swapchain = null; + + public this(void* pNext, VkPastPresentationTimingFlagsEXT flags, VkSwapchainKHR swapchain) : this() + { + this.pNext = pNext; + this.flags = flags; + this.swapchain = swapchain; + } +} + +[CRepr] struct VkPastPresentationTimingPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 timingPropertiesCounter = 0; + public uint64 timeDomainsCounter = 0; + public uint32 presentationTimingCount = 0; + public VkPastPresentationTimingEXT* pPresentationTimings = null; + public Span presentationTimings + { + get { return .(pPresentationTimings, (.)presentationTimingCount); } + set mut { pPresentationTimings = value.Ptr; presentationTimingCount = (.)value.Length; } + } + + public this(void* pNext, uint64 timingPropertiesCounter, uint64 timeDomainsCounter, Span presentationTimings) : this() + { + this.pNext = pNext; + this.timingPropertiesCounter = timingPropertiesCounter; + this.timeDomainsCounter = timeDomainsCounter; + this.presentationTimings = presentationTimings; + } +} + +[CRepr] struct VkPastPresentationTimingEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 presentId = 0; // Application-provided identifier, previously given to vkQueuePresentKHR + public uint64 targetTime = 0; // Application-provided present time + public uint32 presentStageCount = 0; // Number of present stages results available in pPresentStages + public VkPresentStageTimeEXT* pPresentStages = null; // Reported timings for each present stage + public Span presentStages + { + get { return .(pPresentStages, (.)presentStageCount); } + set mut { pPresentStages = value.Ptr; presentStageCount = (.)value.Length; } + } + public VkTimeDomainKHR timeDomain = default; // Time domain of the present stages + public uint64 timeDomainId = 0; // Time domain id of the present stages + public VkBool32 reportComplete = false; // VK_TRUE if all the present stages have been reported + + public this(void* pNext, uint64 presentId, uint64 targetTime, Span presentStages, VkTimeDomainKHR timeDomain, uint64 timeDomainId, VkBool32 reportComplete) : this() + { + this.pNext = pNext; + this.presentId = presentId; + this.targetTime = targetTime; + this.presentStages = presentStages; + this.timeDomain = timeDomain; + this.timeDomainId = timeDomainId; + this.reportComplete = reportComplete; + } +} + +[CRepr] struct VkPresentTimingsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public VkPresentTimingInfoEXT* pTimingInfos = null; // Present timing details for each swapchain + public Span timingInfos + { + get { return .(pTimingInfos, (.)swapchainCount); } + set mut { pTimingInfos = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span timingInfos = default) : this() + { + this.pNext = pNext; + this.timingInfos = timingInfos; + } +} + +[CRepr] struct VkPresentTimingInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPresentTimingInfoFlagsEXT flags = default; + public uint64 targetTime = 0; + public uint64 timeDomainId = 0; // Time domain to interpret the target present time and collect present stages timings with + public VkPresentStageFlagsEXT presentStageQueries = default; // Present stages to collect timing information for + public VkPresentStageFlagsEXT targetTimeDomainPresentStage = default; // Target stage-local time domain's stage + + public this(void* pNext, VkPresentTimingInfoFlagsEXT flags, uint64 targetTime, uint64 timeDomainId, VkPresentStageFlagsEXT presentStageQueries = default, VkPresentStageFlagsEXT targetTimeDomainPresentStage = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.targetTime = targetTime; + this.timeDomainId = timeDomainId; + this.presentStageQueries = presentStageQueries; + this.targetTimeDomainPresentStage = targetTimeDomainPresentStage; + } +} + +[CRepr] struct VkPresentStageTimeEXT : this() +{ + public VkPresentStageFlagsEXT stage = default; + public uint64 time = 0; // Time in nanoseconds of the associated stage + + public this(VkPresentStageFlagsEXT stage, uint64 time) : this() + { + this.stage = stage; + this.time = time; + } +} + +[AllowDuplicates] enum VkPresentStageFlagBitsEXT : int32 +{ + [NoShow] VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT = 1 << 0, + [NoShow] VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT = 1 << 1, + [NoShow] VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT = 1 << 2, + [NoShow] VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT = 1 << 3, + // pretty names + QueueOperationsEndEXT = 1 << 0, + RequestDequeuedEXT = 1 << 1, + ImageFirstPixelOutEXT = 1 << 2, + ImageFirstPixelVisibleEXT = 1 << 3, +} + +typealias VkPresentStageFlagsEXT = VkFlags; + +[AllowDuplicates] enum VkPresentTimingInfoFlagBitsEXT : int32 +{ + [NoShow] VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT = 1 << 0, + [NoShow] VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT = 1 << 1, + // pretty names + PresentAtRelativeTimeEXT = 1 << 0, + PresentAtNearestRefreshCycleEXT = 1 << 1, +} + +typealias VkPresentTimingInfoFlagsEXT = VkFlags; + +[AllowDuplicates] enum VkPastPresentationTimingFlagBitsEXT : int32 +{ + [NoShow] VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT = 1 << 0, + [NoShow] VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT = 1 << 1, + // pretty names + AllowPartialResultsEXT = 1 << 0, + AllowOutOfOrderResultsEXT = 1 << 1, +} + +typealias VkPastPresentationTimingFlagsEXT = VkFlags; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32 size); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, out VkSwapchainTimingPropertiesEXT pSwapchainTimingProperties, out uint64 pSwapchainTimingPropertiesCounter); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, out VkSwapchainTimeDomainPropertiesEXT pSwapchainTimeDomainProperties, out uint64 pTimeDomainsCounter); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPastPresentationTimingEXT(VkDevice device, VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, out VkPastPresentationTimingPropertiesEXT pPastPresentationTimingProperties); + +static { public const let VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION = 1; } +static { public const let VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME = "VK_INTEL_shader_integer_functions2"; } + +[CRepr] struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderIntegerFunctions2 = false; + + public this(void* pNext, VkBool32 shaderIntegerFunctions2) : this() + { + this.pNext = pNext; + this.shaderIntegerFunctions2 = shaderIntegerFunctions2; + } +} + +static { public const let VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION = 2; } +static { public const let VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_INTEL_performance_query"; } + +[AllowDuplicates] enum VkPerformanceConfigurationTypeINTEL : int32 +{ + [NoShow] VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, + // pretty names + CommandQueueMetricsDiscoveryActivatedINTEL = 0, +} + +[AllowDuplicates] enum VkQueryPoolSamplingModeINTEL : int32 +{ + [NoShow] VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, + // pretty names + ManualINTEL = 0, +} + +[AllowDuplicates] enum VkPerformanceOverrideTypeINTEL : int32 +{ + [NoShow] VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, + [NoShow] VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, + // pretty names + NullHardwareINTEL = 0, + FlushGpuCachesINTEL = 1, +} + +[AllowDuplicates] enum VkPerformanceParameterTypeINTEL : int32 +{ + [NoShow] VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, + [NoShow] VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, + // pretty names + HwCountersSupportedINTEL = 0, + StreamMarkerValidBitsINTEL = 1, +} + +[AllowDuplicates] enum VkPerformanceValueTypeINTEL : int32 +{ + [NoShow] VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, + [NoShow] VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, + [NoShow] VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, + [NoShow] VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, + [NoShow] VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, + // pretty names + Uint32INTEL = 0, + Uint64INTEL = 1, + FloatINTEL = 2, + BoolINTEL = 3, + StringINTEL = 4, +} + +[CRepr, Union] struct VkPerformanceValueDataINTEL : this() +{ + public uint32 value32 = 0; + public uint64 value64 = 0; + public float valueFloat = 0; + public VkBool32 valueBool = false; + public char8* valueString = null; + + public this(uint32 value32, uint64 value64, float valueFloat, VkBool32 valueBool, char8* valueString) : this() + { + this.value32 = value32; + this.value64 = value64; + this.valueFloat = valueFloat; + this.valueBool = valueBool; + this.valueString = valueString; + } +} + +[CRepr] struct VkPerformanceValueINTEL : this() +{ + public VkPerformanceValueTypeINTEL type = default; + public VkPerformanceValueDataINTEL data = default; +} + +[CRepr] struct VkInitializePerformanceApiInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public void* pUserData = null; + + public this(void* pNext = null, void* pUserData = null) : this() + { + this.pNext = pNext; + this.pUserData = pUserData; + } +} + +typealias VkQueryPoolCreateInfoINTEL = VkQueryPoolPerformanceQueryCreateInfoINTEL; + +[CRepr] struct VkQueryPoolPerformanceQueryCreateInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueryPoolSamplingModeINTEL performanceCountersSampling = default; + + public this(void* pNext, VkQueryPoolSamplingModeINTEL performanceCountersSampling) : this() + { + this.pNext = pNext; + this.performanceCountersSampling = performanceCountersSampling; + } +} + +[CRepr] struct VkPerformanceMarkerInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 marker = 0; + + public this(void* pNext, uint64 marker) : this() + { + this.pNext = pNext; + this.marker = marker; + } +} + +[CRepr] struct VkPerformanceStreamMarkerInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 marker = 0; + + public this(void* pNext, uint32 marker) : this() + { + this.pNext = pNext; + this.marker = marker; + } +} + +[CRepr] struct VkPerformanceOverrideInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPerformanceOverrideTypeINTEL type = default; + public VkBool32 enable = false; + public uint64 parameter = 0; + + public this(void* pNext, VkPerformanceOverrideTypeINTEL type, VkBool32 enable, uint64 parameter) : this() + { + this.pNext = pNext; + this.type = type; + this.enable = enable; + this.parameter = parameter; + } +} + +[CRepr] struct VkPerformanceConfigurationAcquireInfoINTEL : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPerformanceConfigurationTypeINTEL type = default; + + public this(void* pNext, VkPerformanceConfigurationTypeINTEL type) : this() + { + this.pNext = pNext; + this.type = type; + } +} + +struct VkPerformanceConfigurationINTEL : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkInitializePerformanceApiINTEL(VkDevice device, VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUninitializePerformanceApiINTEL(VkDevice device); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, VkPerformanceMarkerInfoINTEL* pMarkerInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, VkPerformanceOverrideInfoINTEL* pOverrideInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquirePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, out VkPerformanceConfigurationINTEL pConfiguration); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, out VkPerformanceValueINTEL pValue); + +static { public const let VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION = 3; } +static { public const let VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME = "VK_KHR_vulkan_memory_model"; } + +typealias VkPhysicalDeviceVulkanMemoryModelFeaturesKHR = VkPhysicalDeviceVulkanMemoryModelFeatures; + +static { public const let VK_EXT_PCI_BUS_INFO_SPEC_VERSION = 2; } +static { public const let VK_EXT_PCI_BUS_INFO_EXTENSION_NAME = "VK_EXT_pci_bus_info"; } + +[CRepr] struct VkPhysicalDevicePCIBusInfoPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 pciDomain = 0; + public uint32 pciBus = 0; + public uint32 pciDevice = 0; + public uint32 pciFunction = 0; +} + +static { public const let VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION = 1; } +static { public const let VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME = "VK_AMD_display_native_hdr"; } + +[CRepr] struct VkDisplayNativeHdrSurfaceCapabilitiesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 localDimmingSupport = false; +} + +[CRepr] struct VkSwapchainDisplayNativeHdrCreateInfoAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 localDimmingEnable = false; + + public this(void* pNext, VkBool32 localDimmingEnable) : this() + { + this.pNext = pNext; + this.localDimmingEnable = localDimmingEnable; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); + +static { public const let VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME = "VK_FUCHSIA_imagepipe_surface"; } + +typealias VkImagePipeSurfaceCreateFlagsFUCHSIA = VkFlags; + +[CRepr] struct VkImagePipeSurfaceCreateInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImagePipeSurfaceCreateFlagsFUCHSIA flags = default; + public zx_handle_t imagePipeHandle = default; + + public this(void* pNext, VkImagePipeSurfaceCreateFlagsFUCHSIA flags, zx_handle_t imagePipeHandle) : this() + { + this.pNext = pNext; + this.flags = flags; + this.imagePipeHandle = imagePipeHandle; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME = "VK_KHR_shader_terminate_invocation"; } + +typealias VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = VkPhysicalDeviceShaderTerminateInvocationFeatures; + +static { public const let VK_EXT_METAL_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_EXT_METAL_SURFACE_EXTENSION_NAME = "VK_EXT_metal_surface"; } + +typealias VkMetalSurfaceCreateFlagsEXT = VkFlags; + +[CRepr] struct VkMetalSurfaceCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMetalSurfaceCreateFlagsEXT flags = default; + public CAMetalLayer* pLayer = null; + + public this(void* pNext, VkMetalSurfaceCreateFlagsEXT flags, CAMetalLayer* pLayer) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pLayer = pLayer; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateMetalSurfaceEXT(VkInstance instance, VkMetalSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +struct CAMetalLayer : int {} + +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION = 2; } +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME = "VK_EXT_fragment_density_map"; } + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentDensityMap = false; + public VkBool32 fragmentDensityMapDynamic = false; + public VkBool32 fragmentDensityMapNonSubsampledImages = false; + + public this(void* pNext, VkBool32 fragmentDensityMap, VkBool32 fragmentDensityMapDynamic, VkBool32 fragmentDensityMapNonSubsampledImages) : this() + { + this.pNext = pNext; + this.fragmentDensityMap = fragmentDensityMap; + this.fragmentDensityMapDynamic = fragmentDensityMapDynamic; + this.fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D minFragmentDensityTexelSize = default; + public VkExtent2D maxFragmentDensityTexelSize = default; + public VkBool32 fragmentDensityInvocations = false; +} + +[CRepr] struct VkRenderPassFragmentDensityMapCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAttachmentReference fragmentDensityMapAttachment = default; + + public this(void* pNext, VkAttachmentReference fragmentDensityMapAttachment) : this() + { + this.pNext = pNext; + this.fragmentDensityMapAttachment = fragmentDensityMapAttachment; + } +} + +[CRepr] struct VkRenderingFragmentDensityMapAttachmentInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView imageView = null; + public VkImageLayout imageLayout = default; + + public this(void* pNext, VkImageView imageView, VkImageLayout imageLayout) : this() + { + this.pNext = pNext; + this.imageView = imageView; + this.imageLayout = imageLayout; + } +} + +static { public const let VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION = 1; } +static { public const let VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME = "VK_EXT_scalar_block_layout"; } + +typealias VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = VkPhysicalDeviceScalarBlockLayoutFeatures; + +static { public const let VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION = 1; } +static { public const let VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME = "VK_GOOGLE_hlsl_functionality1"; } +static { public const let VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION; } +static { public const let VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME; } +static { public const let VK_GOOGLE_DECORATE_STRING_SPEC_VERSION = 1; } +static { public const let VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME = "VK_GOOGLE_decorate_string"; } +static { public const let VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION = 2; } +static { public const let VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME = "VK_EXT_subgroup_size_control"; } + +typealias VkPhysicalDeviceSubgroupSizeControlFeaturesEXT = VkPhysicalDeviceSubgroupSizeControlFeatures; +typealias VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = VkPhysicalDeviceSubgroupSizeControlProperties; +typealias VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + +static { public const let VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION = 2; } +static { public const let VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME = "VK_KHR_fragment_shading_rate"; } + +[AllowDuplicates] enum VkFragmentShadingRateCombinerOpKHR : int32 +{ + [NoShow] VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + [NoShow] VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + [NoShow] VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + [NoShow] VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + [NoShow] VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + // pretty names + KeepKHR = 0, + ReplaceKHR = 1, + MinKHR = 2, + MaxKHR = 3, + MulKHR = 4, +} + +[CRepr] struct VkFragmentShadingRateAttachmentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAttachmentReference2* pFragmentShadingRateAttachment = null; + public VkExtent2D shadingRateAttachmentTexelSize = default; + + public this(void* pNext, VkAttachmentReference2* pFragmentShadingRateAttachment, VkExtent2D shadingRateAttachmentTexelSize) : this() + { + this.pNext = pNext; + this.pFragmentShadingRateAttachment = pFragmentShadingRateAttachment; + this.shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize; + } +} + +[CRepr] struct VkPipelineFragmentShadingRateStateCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D fragmentSize = default; + public VkFragmentShadingRateCombinerOpKHR[2] combinerOps = .(); + + public this(void* pNext, VkExtent2D fragmentSize, VkFragmentShadingRateCombinerOpKHR[2] combinerOps) : this() + { + this.pNext = pNext; + this.fragmentSize = fragmentSize; + this.combinerOps = combinerOps; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineFragmentShadingRate = false; + public VkBool32 primitiveFragmentShadingRate = false; + public VkBool32 attachmentFragmentShadingRate = false; + + public this(void* pNext, VkBool32 pipelineFragmentShadingRate, VkBool32 primitiveFragmentShadingRate, VkBool32 attachmentFragmentShadingRate) : this() + { + this.pNext = pNext; + this.pipelineFragmentShadingRate = pipelineFragmentShadingRate; + this.primitiveFragmentShadingRate = primitiveFragmentShadingRate; + this.attachmentFragmentShadingRate = attachmentFragmentShadingRate; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D minFragmentShadingRateAttachmentTexelSize = default; + public VkExtent2D maxFragmentShadingRateAttachmentTexelSize = default; + public uint32 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = 0; + public VkBool32 primitiveFragmentShadingRateWithMultipleViewports = false; + public VkBool32 layeredShadingRateAttachments = false; + public VkBool32 fragmentShadingRateNonTrivialCombinerOps = false; + public VkExtent2D maxFragmentSize = default; + public uint32 maxFragmentSizeAspectRatio = 0; + public uint32 maxFragmentShadingRateCoverageSamples = 0; + public VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples = default; + public VkBool32 fragmentShadingRateWithShaderDepthStencilWrites = false; + public VkBool32 fragmentShadingRateWithSampleMask = false; + public VkBool32 fragmentShadingRateWithShaderSampleMask = false; + public VkBool32 fragmentShadingRateWithConservativeRasterization = false; + public VkBool32 fragmentShadingRateWithFragmentShaderInterlock = false; + public VkBool32 fragmentShadingRateWithCustomSampleLocations = false; + public VkBool32 fragmentShadingRateStrictMultiplyCombiner = false; +} + +[CRepr] struct VkPhysicalDeviceFragmentShadingRateKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSampleCountFlags sampleCounts = default; + public VkExtent2D fragmentSize = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, out uint32 pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, VkExtent2D* pFragmentSize, VkFragmentShadingRateCombinerOpKHR[2] combinerOps); + +// Remove 'api' attribute once gitlab #4074 is fixed +[CRepr] struct VkRenderingFragmentShadingRateAttachmentInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView imageView = null; + public VkImageLayout imageLayout = default; + public VkExtent2D shadingRateAttachmentTexelSize = default; + + public this(void* pNext, VkImageView imageView, VkImageLayout imageLayout, VkExtent2D shadingRateAttachmentTexelSize) : this() + { + this.pNext = pNext; + this.imageView = imageView; + this.imageLayout = imageLayout; + this.shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize; + } +} + +static { public const let VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME = "VK_AMD_shader_core_properties2"; } + +[CRepr] struct VkPhysicalDeviceShaderCoreProperties2AMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; + public VkStructureType sType = SType; + public void* pNext = null; // Pointer to next structure + public VkShaderCorePropertiesFlagsAMD shaderCoreFeatures = default; // features supported by the shader core + public uint32 activeComputeUnitCount = 0; // number of active compute units across all shader engines/arrays +} + +[AllowDuplicates] enum VkShaderCorePropertiesFlagBitsAMD : int32 +{ + // pretty names +} + +typealias VkShaderCorePropertiesFlagsAMD = VkShaderCorePropertiesFlagBitsAMD; + +static { public const let VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME = "VK_AMD_device_coherent_memory"; } + +[CRepr] struct VkPhysicalDeviceCoherentMemoryFeaturesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceCoherentMemory = false; + + public this(void* pNext, VkBool32 deviceCoherentMemory) : this() + { + this.pNext = pNext; + this.deviceCoherentMemory = deviceCoherentMemory; + } +} + +static { public const let VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION = 1; } +static { public const let VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME = "VK_KHR_dynamic_rendering_local_read"; } + +typealias PFN_vkCmdSetRenderingAttachmentLocationsKHR = PFN_vkCmdSetRenderingAttachmentLocations; +typealias PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = PFN_vkCmdSetRenderingInputAttachmentIndices; + +typealias VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VkPhysicalDeviceDynamicRenderingLocalReadFeatures; +typealias VkRenderingAttachmentLocationInfoKHR = VkRenderingAttachmentLocationInfo; +typealias VkRenderingInputAttachmentIndexInfoKHR = VkRenderingInputAttachmentIndexInfo; + +static { public const let VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME = "VK_EXT_shader_image_atomic_int64"; } + +[CRepr] struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderImageInt64Atomics = false; + public VkBool32 sparseImageInt64Atomics = false; + + public this(void* pNext, VkBool32 shaderImageInt64Atomics, VkBool32 sparseImageInt64Atomics) : this() + { + this.pNext = pNext; + this.shaderImageInt64Atomics = shaderImageInt64Atomics; + this.sparseImageInt64Atomics = sparseImageInt64Atomics; + } +} + +static { public const let VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME = "VK_KHR_shader_quad_control"; } + +[CRepr] struct VkPhysicalDeviceShaderQuadControlFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderQuadControl = false; + + public this(void* pNext, VkBool32 shaderQuadControl) : this() + { + this.pNext = pNext; + this.shaderQuadControl = shaderQuadControl; + } +} + +static { public const let VK_KHR_SPIRV_1_4_SPEC_VERSION = 1; } +static { public const let VK_KHR_SPIRV_1_4_EXTENSION_NAME = "VK_KHR_spirv_1_4"; } +static { public const let VK_EXT_MEMORY_BUDGET_SPEC_VERSION = 1; } +static { public const let VK_EXT_MEMORY_BUDGET_EXTENSION_NAME = "VK_EXT_memory_budget"; } + +[CRepr] struct VkPhysicalDeviceMemoryBudgetPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize[VK_MAX_MEMORY_HEAPS] heapBudget = .(); + public VkDeviceSize[VK_MAX_MEMORY_HEAPS] heapUsage = .(); +} + +static { public const let VK_EXT_MEMORY_PRIORITY_SPEC_VERSION = 1; } +static { public const let VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME = "VK_EXT_memory_priority"; } + +[CRepr] struct VkPhysicalDeviceMemoryPriorityFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 memoryPriority = false; + + public this(void* pNext, VkBool32 memoryPriority) : this() + { + this.pNext = pNext; + this.memoryPriority = memoryPriority; + } +} + +[CRepr] struct VkMemoryPriorityAllocateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public float priority = 0; + + public this(void* pNext, float priority) : this() + { + this.pNext = pNext; + this.priority = priority; + } +} + +static { public const let VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME = "VK_KHR_surface_protected_capabilities"; } + +[CRepr] struct VkSurfaceProtectedCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 supportsProtected = false; // Represents if surface can be protected +} + +static { public const let VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION = 1; } +static { public const let VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME = "VK_NV_dedicated_allocation_image_aliasing"; } + +[CRepr] struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dedicatedAllocationImageAliasing = false; + + public this(void* pNext, VkBool32 dedicatedAllocationImageAliasing) : this() + { + this.pNext = pNext; + this.dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing; + } +} + +static { public const let VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION = 1; } +static { public const let VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME = "VK_KHR_separate_depth_stencil_layouts"; } + +typealias VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; +typealias VkAttachmentReferenceStencilLayoutKHR = VkAttachmentReferenceStencilLayout; +typealias VkAttachmentDescriptionStencilLayoutKHR = VkAttachmentDescriptionStencilLayout; + +static { public const let VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION = 2; } +static { public const let VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME = "VK_EXT_buffer_device_address"; } + +typealias VkPhysicalDeviceBufferAddressFeaturesEXT = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; + +[CRepr] struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 bufferDeviceAddress = false; + public VkBool32 bufferDeviceAddressCaptureReplay = false; + public VkBool32 bufferDeviceAddressMultiDevice = false; + + public this(void* pNext, VkBool32 bufferDeviceAddress, VkBool32 bufferDeviceAddressCaptureReplay, VkBool32 bufferDeviceAddressMultiDevice) : this() + { + this.pNext = pNext; + this.bufferDeviceAddress = bufferDeviceAddress; + this.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay; + this.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice; + } +} + +typealias VkBufferDeviceAddressInfoEXT = VkBufferDeviceAddressInfo; + +[CRepr] struct VkBufferDeviceAddressCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddress deviceAddress = default; + + public this(void* pNext = null, VkDeviceAddress deviceAddress = default) : this() + { + this.pNext = pNext; + this.deviceAddress = deviceAddress; + } +} + +typealias PFN_vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddress; + +static { public const let VK_EXT_TOOLING_INFO_SPEC_VERSION = 1; } +static { public const let VK_EXT_TOOLING_INFO_EXTENSION_NAME = "VK_EXT_tooling_info"; } + +typealias VkToolPurposeFlagBitsEXT = VkToolPurposeFlagBits; +typealias VkToolPurposeFlagsEXT = VkToolPurposeFlags; +typealias VkPhysicalDeviceToolPropertiesEXT = VkPhysicalDeviceToolProperties; + +typealias PFN_vkGetPhysicalDeviceToolPropertiesEXT = PFN_vkGetPhysicalDeviceToolProperties; + +static { public const let VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION = 1; } +static { public const let VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME = "VK_EXT_separate_stencil_usage"; } + +typealias VkImageStencilUsageCreateInfoEXT = VkImageStencilUsageCreateInfo; + +static { public const let VK_EXT_VALIDATION_FEATURES_SPEC_VERSION = 6; } +static { public const let VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME = "VK_EXT_validation_features"; } + +[CRepr] struct VkValidationFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; + public VkStructureType sType = SType; // Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT + public void* pNext = null; + public uint32 enabledValidationFeatureCount = 0; // Number of validation features to enable + public VkValidationFeatureEnableEXT* pEnabledValidationFeatures = null; // Validation features to enable + public Span enabledValidationFeatures + { + get { return .(pEnabledValidationFeatures, (.)enabledValidationFeatureCount); } + set mut { pEnabledValidationFeatures = value.Ptr; enabledValidationFeatureCount = (.)value.Length; } + } + public uint32 disabledValidationFeatureCount = 0; // Number of validation features to disable + public VkValidationFeatureDisableEXT* pDisabledValidationFeatures = null; // Validation features to disable + public Span disabledValidationFeatures + { + get { return .(pDisabledValidationFeatures, (.)disabledValidationFeatureCount); } + set mut { pDisabledValidationFeatures = value.Ptr; disabledValidationFeatureCount = (.)value.Length; } + } + + public this(void* pNext = null, Span enabledValidationFeatures = default, Span disabledValidationFeatures = default) : this() + { + this.pNext = pNext; + this.enabledValidationFeatures = enabledValidationFeatures; + this.disabledValidationFeatures = disabledValidationFeatures; + } +} + +[AllowDuplicates] enum VkValidationFeatureEnableEXT : int32 +{ + [NoShow] VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + [NoShow] VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + [NoShow] VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + [NoShow] VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + [NoShow] VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + // pretty names + GpuAssistedEXT = 0, + GpuAssistedReserveBindingSlotEXT = 1, + BestPracticesEXT = 2, + DebugPrintfEXT = 3, + SynchronizationValidationEXT = 4, +} + +[AllowDuplicates] enum VkValidationFeatureDisableEXT : int32 +{ + [NoShow] VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + [NoShow] VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + // pretty names + AllEXT = 0, + ShadersEXT = 1, + ThreadSafetyEXT = 2, + ApiParametersEXT = 3, + ObjectLifetimesEXT = 4, + CoreChecksEXT = 5, + UniqueHandlesEXT = 6, + ShaderValidationCacheEXT = 7, +} + +static { public const let VK_KHR_PRESENT_WAIT_SPEC_VERSION = 1; } +static { public const let VK_KHR_PRESENT_WAIT_EXTENSION_NAME = "VK_KHR_present_wait"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64 presentId, uint64 timeout); + +[CRepr] struct VkPhysicalDevicePresentWaitFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentWait = false; // vkWaitForPresentKHR is supported + + public this(void* pNext, VkBool32 presentWait) : this() + { + this.pNext = pNext; + this.presentWait = presentWait; + } +} + +static { public const let VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION = 1; } +static { public const let VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME = "VK_NV_cooperative_matrix"; } + +[CRepr] struct VkCooperativeMatrixPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 MSize = 0; + public uint32 NSize = 0; + public uint32 KSize = 0; + public VkComponentTypeNV AType = default; + public VkComponentTypeNV BType = default; + public VkComponentTypeNV CType = default; + public VkComponentTypeNV DType = default; + public VkScopeNV @scope = default; +} + +typealias VkScopeNV = VkScopeKHR; +typealias VkComponentTypeNV = VkComponentTypeKHR; + +[CRepr] struct VkPhysicalDeviceCooperativeMatrixFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cooperativeMatrix = false; + public VkBool32 cooperativeMatrixRobustBufferAccess = false; + + public this(void* pNext, VkBool32 cooperativeMatrix, VkBool32 cooperativeMatrixRobustBufferAccess) : this() + { + this.pNext = pNext; + this.cooperativeMatrix = cooperativeMatrix; + this.cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess; + } +} + +[CRepr] struct VkPhysicalDeviceCooperativeMatrixPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags cooperativeMatrixSupportedStages = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties = null); + +static { public const let VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION = 1; } +static { public const let VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME = "VK_NV_coverage_reduction_mode"; } + +[CRepr] struct VkPhysicalDeviceCoverageReductionModeFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 coverageReductionMode = false; + + public this(void* pNext, VkBool32 coverageReductionMode) : this() + { + this.pNext = pNext; + this.coverageReductionMode = coverageReductionMode; + } +} + +[CRepr] struct VkPipelineCoverageReductionStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCoverageReductionStateCreateFlagsNV flags = default; + public VkCoverageReductionModeNV coverageReductionMode = default; + + public this(void* pNext, VkPipelineCoverageReductionStateCreateFlagsNV flags, VkCoverageReductionModeNV coverageReductionMode) : this() + { + this.pNext = pNext; + this.flags = flags; + this.coverageReductionMode = coverageReductionMode; + } +} + +typealias VkPipelineCoverageReductionStateCreateFlagsNV = VkFlags; + +[AllowDuplicates] enum VkCoverageReductionModeNV : int32 +{ + [NoShow] VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, + [NoShow] VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, + // pretty names + MergeNV = 0, + TruncateNV = 1, +} + +[CRepr] struct VkFramebufferMixedSamplesCombinationNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCoverageReductionModeNV coverageReductionMode = default; + public VkSampleCountFlagBits rasterizationSamples = default; + public VkSampleCountFlags depthStencilSamples = default; + public VkSampleCountFlags colorSamples = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, out uint32 pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations = null); + +static { public const let VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION = 1; } +static { public const let VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME = "VK_EXT_fragment_shader_interlock"; } + +[CRepr] struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; // Pointer to next structure + public VkBool32 fragmentShaderSampleInterlock = false; + public VkBool32 fragmentShaderPixelInterlock = false; + public VkBool32 fragmentShaderShadingRateInterlock = false; + + public this(void* pNext, VkBool32 fragmentShaderSampleInterlock, VkBool32 fragmentShaderPixelInterlock, VkBool32 fragmentShaderShadingRateInterlock) : this() + { + this.pNext = pNext; + this.fragmentShaderSampleInterlock = fragmentShaderSampleInterlock; + this.fragmentShaderPixelInterlock = fragmentShaderPixelInterlock; + this.fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock; + } +} + +static { public const let VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION = 1; } +static { public const let VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME = "VK_EXT_ycbcr_image_arrays"; } + +[CRepr] struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 ycbcrImageArrays = false; + + public this(void* pNext, VkBool32 ycbcrImageArrays) : this() + { + this.pNext = pNext; + this.ycbcrImageArrays = ycbcrImageArrays; + } +} + +static { public const let VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION = 1; } +static { public const let VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME = "VK_KHR_uniform_buffer_standard_layout"; } + +typealias VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +static { public const let VK_EXT_PROVOKING_VERTEX_SPEC_VERSION = 1; } +static { public const let VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME = "VK_EXT_provoking_vertex"; } + +[CRepr] struct VkPhysicalDeviceProvokingVertexFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 provokingVertexLast = false; + public VkBool32 transformFeedbackPreservesProvokingVertex = false; + + public this(void* pNext, VkBool32 provokingVertexLast, VkBool32 transformFeedbackPreservesProvokingVertex) : this() + { + this.pNext = pNext; + this.provokingVertexLast = provokingVertexLast; + this.transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex; + } +} + +[CRepr] struct VkPhysicalDeviceProvokingVertexPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 provokingVertexModePerPipeline = false; + public VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex = false; +} + +[CRepr] struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkProvokingVertexModeEXT provokingVertexMode = default; + + public this(void* pNext, VkProvokingVertexModeEXT provokingVertexMode) : this() + { + this.pNext = pNext; + this.provokingVertexMode = provokingVertexMode; + } +} + +[AllowDuplicates] enum VkProvokingVertexModeEXT : int32 +{ + [NoShow] VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, + [NoShow] VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, + // pretty names + FirstVertexEXT = 0, + LastVertexEXT = 1, +} + +static { public const let VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION = 4; } +static { public const let VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME = "VK_EXT_full_screen_exclusive"; } + +[AllowDuplicates] enum VkFullScreenExclusiveEXT : int32 +{ + [NoShow] VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, + [NoShow] VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, + [NoShow] VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, + [NoShow] VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, + // pretty names + DefaultEXT = 0, + AllowedEXT = 1, + DisallowedEXT = 2, + ApplicationControlledEXT = 3, +} + +[CRepr] struct VkSurfaceFullScreenExclusiveInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFullScreenExclusiveEXT fullScreenExclusive = default; + + public this(void* pNext, VkFullScreenExclusiveEXT fullScreenExclusive) : this() + { + this.pNext = pNext; + this.fullScreenExclusive = fullScreenExclusive; + } +} + +[CRepr] struct VkSurfaceCapabilitiesFullScreenExclusiveEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fullScreenExclusiveSupported = false; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out uint32 pPresentModeCount, VkPresentModeKHR* pPresentModes = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain); + +[CRepr] struct VkSurfaceFullScreenExclusiveWin32InfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public HMONITOR hmonitor = default; + + public this(void* pNext, HMONITOR hmonitor) : this() + { + this.pNext = pNext; + this.hmonitor = hmonitor; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, out VkDeviceGroupPresentModeFlagsKHR pModes); + +static { public const let VK_EXT_HEADLESS_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME = "VK_EXT_headless_surface"; } + +typealias VkHeadlessSurfaceCreateFlagsEXT = VkFlags; + +[CRepr] struct VkHeadlessSurfaceCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkHeadlessSurfaceCreateFlagsEXT flags = default; + + public this(void* pNext = null, VkHeadlessSurfaceCreateFlagsEXT flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateHeadlessSurfaceEXT(VkInstance instance, VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION = 1; } +static { public const let VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME = "VK_KHR_buffer_device_address"; } + +typealias VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = VkPhysicalDeviceBufferDeviceAddressFeatures; +typealias VkBufferDeviceAddressInfoKHR = VkBufferDeviceAddressInfo; +typealias VkBufferOpaqueCaptureAddressCreateInfoKHR = VkBufferOpaqueCaptureAddressCreateInfo; +typealias VkMemoryOpaqueCaptureAddressAllocateInfoKHR = VkMemoryOpaqueCaptureAddressAllocateInfo; +typealias VkDeviceMemoryOpaqueCaptureAddressInfoKHR = VkDeviceMemoryOpaqueCaptureAddressInfo; + +typealias PFN_vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddress; +typealias PFN_vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddress; +typealias PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddress; + +static { public const let VK_EXT_LINE_RASTERIZATION_SPEC_VERSION = 1; } +static { public const let VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME = "VK_EXT_line_rasterization"; } + +typealias VkPhysicalDeviceLineRasterizationFeaturesEXT = VkPhysicalDeviceLineRasterizationFeatures; +typealias VkPhysicalDeviceLineRasterizationPropertiesEXT = VkPhysicalDeviceLineRasterizationProperties; +typealias VkPipelineRasterizationLineStateCreateInfoEXT = VkPipelineRasterizationLineStateCreateInfo; +typealias VkLineRasterizationModeEXT = VkLineRasterizationMode; + +typealias PFN_vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStipple; + +static { public const let VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME = "VK_EXT_shader_atomic_float"; } + +[CRepr] struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderBufferFloat32Atomics = false; + public VkBool32 shaderBufferFloat32AtomicAdd = false; + public VkBool32 shaderBufferFloat64Atomics = false; + public VkBool32 shaderBufferFloat64AtomicAdd = false; + public VkBool32 shaderSharedFloat32Atomics = false; + public VkBool32 shaderSharedFloat32AtomicAdd = false; + public VkBool32 shaderSharedFloat64Atomics = false; + public VkBool32 shaderSharedFloat64AtomicAdd = false; + public VkBool32 shaderImageFloat32Atomics = false; + public VkBool32 shaderImageFloat32AtomicAdd = false; + public VkBool32 sparseImageFloat32Atomics = false; + public VkBool32 sparseImageFloat32AtomicAdd = false; + + public this(void* pNext, VkBool32 shaderBufferFloat32Atomics, VkBool32 shaderBufferFloat32AtomicAdd, VkBool32 shaderBufferFloat64Atomics, VkBool32 shaderBufferFloat64AtomicAdd, VkBool32 shaderSharedFloat32Atomics, VkBool32 shaderSharedFloat32AtomicAdd, VkBool32 shaderSharedFloat64Atomics, VkBool32 shaderSharedFloat64AtomicAdd, VkBool32 shaderImageFloat32Atomics, VkBool32 shaderImageFloat32AtomicAdd, VkBool32 sparseImageFloat32Atomics, VkBool32 sparseImageFloat32AtomicAdd) : this() + { + this.pNext = pNext; + this.shaderBufferFloat32Atomics = shaderBufferFloat32Atomics; + this.shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd; + this.shaderBufferFloat64Atomics = shaderBufferFloat64Atomics; + this.shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd; + this.shaderSharedFloat32Atomics = shaderSharedFloat32Atomics; + this.shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd; + this.shaderSharedFloat64Atomics = shaderSharedFloat64Atomics; + this.shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd; + this.shaderImageFloat32Atomics = shaderImageFloat32Atomics; + this.shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd; + this.sparseImageFloat32Atomics = sparseImageFloat32Atomics; + this.sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd; + } +} + +static { public const let VK_EXT_HOST_QUERY_RESET_SPEC_VERSION = 1; } +static { public const let VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME = "VK_EXT_host_query_reset"; } + +typealias VkPhysicalDeviceHostQueryResetFeaturesEXT = VkPhysicalDeviceHostQueryResetFeatures; + +typealias PFN_vkResetQueryPoolEXT = PFN_vkResetQueryPool; + +static { public const let VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION = 1; } +static { public const let VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME = "VK_EXT_index_type_uint8"; } + +typealias VkPhysicalDeviceIndexTypeUint8FeaturesEXT = VkPhysicalDeviceIndexTypeUint8Features; + +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME = "VK_EXT_extended_dynamic_state"; } + +[CRepr] struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 extendedDynamicState = false; + + public this(void* pNext, VkBool32 extendedDynamicState) : this() + { + this.pNext = pNext; + this.extendedDynamicState = extendedDynamicState; + } +} + +typealias PFN_vkCmdSetCullModeEXT = PFN_vkCmdSetCullMode; +typealias PFN_vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFace; +typealias PFN_vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopology; +typealias PFN_vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCount; +typealias PFN_vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCount; +typealias PFN_vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2; +typealias PFN_vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnable; +typealias PFN_vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnable; +typealias PFN_vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOp; +typealias PFN_vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnable; +typealias PFN_vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnable; +typealias PFN_vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOp; + +static { public const let VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION = 4; } +static { public const let VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME = "VK_KHR_deferred_host_operations"; } + +struct VkDeferredOperationKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDeferredOperationKHR(VkDevice device, VkAllocationCallbacks* pAllocator, out VkDeferredOperationKHR pDeferredOperation); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function uint32 PFN_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation); + +static { public const let VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION = 1; } +static { public const let VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME = "VK_KHR_pipeline_executable_properties"; } + +[CRepr] struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineExecutableInfo = false; + + public this(void* pNext, VkBool32 pipelineExecutableInfo) : this() + { + this.pNext = pNext; + this.pipelineExecutableInfo = pipelineExecutableInfo; + } +} + +[CRepr] struct VkPipelineInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline pipeline = null; + + public this(void* pNext, VkPipeline pipeline) : this() + { + this.pNext = pNext; + this.pipeline = pipeline; + } +} + +[CRepr] struct VkPipelineExecutablePropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags stages = default; + public char8[VK_MAX_DESCRIPTION_SIZE] name = .(); + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); + public uint32 subgroupSize = 0; +} + +[CRepr] struct VkPipelineExecutableInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline pipeline = null; + public uint32 executableIndex = 0; + + public this(void* pNext, VkPipeline pipeline, uint32 executableIndex) : this() + { + this.pNext = pNext; + this.pipeline = pipeline; + this.executableIndex = executableIndex; + } +} + +[AllowDuplicates] enum VkPipelineExecutableStatisticFormatKHR : int32 +{ + [NoShow] VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, + [NoShow] VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, + [NoShow] VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, + [NoShow] VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, + // pretty names + Bool32KHR = 0, + Int64KHR = 1, + Uint64KHR = 2, + Float64KHR = 3, +} + +[CRepr, Union] struct VkPipelineExecutableStatisticValueKHR : this() +{ + public VkBool32 b32 = false; + public int64 i64 = 0; + public uint64 u64 = 0; + public double f64 = 0; +} + +[CRepr] struct VkPipelineExecutableStatisticKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public char8[VK_MAX_DESCRIPTION_SIZE] name = .(); + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); + public VkPipelineExecutableStatisticFormatKHR format = default; + public VkPipelineExecutableStatisticValueKHR value = default; +} + +[CRepr] struct VkPipelineExecutableInternalRepresentationKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public char8[VK_MAX_DESCRIPTION_SIZE] name = .(); + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); + public VkBool32 isText = false; + public c_size dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineExecutablePropertiesKHR(VkDevice device, VkPipelineInfoKHR* pPipelineInfo, out uint32 pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineExecutableStatisticsKHR(VkDevice device, VkPipelineExecutableInfoKHR* pExecutableInfo, out uint32 pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, VkPipelineExecutableInfoKHR* pExecutableInfo, out uint32 pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations = null); + +static { public const let VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION = 1; } +static { public const let VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME = "VK_EXT_host_image_copy"; } + +typealias VkPhysicalDeviceHostImageCopyFeaturesEXT = VkPhysicalDeviceHostImageCopyFeatures; +typealias VkPhysicalDeviceHostImageCopyPropertiesEXT = VkPhysicalDeviceHostImageCopyProperties; +typealias VkHostImageCopyFlagBitsEXT = VkHostImageCopyFlagBits; +typealias VkHostImageCopyFlagsEXT = VkHostImageCopyFlags; +typealias VkMemoryToImageCopyEXT = VkMemoryToImageCopy; +typealias VkImageToMemoryCopyEXT = VkImageToMemoryCopy; +typealias VkCopyMemoryToImageInfoEXT = VkCopyMemoryToImageInfo; +typealias VkCopyImageToMemoryInfoEXT = VkCopyImageToMemoryInfo; +typealias VkCopyImageToImageInfoEXT = VkCopyImageToImageInfo; +typealias VkHostImageLayoutTransitionInfoEXT = VkHostImageLayoutTransitionInfo; +typealias VkSubresourceHostMemcpySizeEXT = VkSubresourceHostMemcpySize; +typealias VkHostImageCopyDevicePerformanceQueryEXT = VkHostImageCopyDevicePerformanceQuery; + +typealias PFN_vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImage; +typealias PFN_vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemory; +typealias PFN_vkCopyImageToImageEXT = PFN_vkCopyImageToImage; +typealias PFN_vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayout; + +typealias VkSubresourceLayout2EXT = VkSubresourceLayout2; +typealias VkImageSubresource2EXT = VkImageSubresource2; + +typealias PFN_vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2; + +static { public const let VK_KHR_MAP_MEMORY_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAP_MEMORY_2_EXTENSION_NAME = "VK_KHR_map_memory2"; } + +typealias VkMemoryMapInfoKHR = VkMemoryMapInfo; +typealias VkMemoryUnmapInfoKHR = VkMemoryUnmapInfo; +typealias VkMemoryUnmapFlagBitsKHR = VkMemoryUnmapFlagBits; +typealias VkMemoryUnmapFlagsKHR = VkMemoryUnmapFlags; + +typealias PFN_vkMapMemory2KHR = PFN_vkMapMemory2; +typealias PFN_vkUnmapMemory2KHR = PFN_vkUnmapMemory2; + +static { public const let VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION = 1; } +static { public const let VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME = "VK_EXT_map_memory_placed"; } + +[CRepr] struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 memoryMapPlaced = false; + public VkBool32 memoryMapRangePlaced = false; + public VkBool32 memoryUnmapReserve = false; + + public this(void* pNext, VkBool32 memoryMapPlaced, VkBool32 memoryMapRangePlaced, VkBool32 memoryUnmapReserve) : this() + { + this.pNext = pNext; + this.memoryMapPlaced = memoryMapPlaced; + this.memoryMapRangePlaced = memoryMapRangePlaced; + this.memoryUnmapReserve = memoryUnmapReserve; + } +} + +[CRepr] struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize minPlacedMemoryMapAlignment = default; +} + +[CRepr] struct VkMemoryMapPlacedInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public void* pPlacedAddress = null; + + public this(void* pNext, void* pPlacedAddress) : this() + { + this.pNext = pNext; + this.pPlacedAddress = pPlacedAddress; + } +} + +static { public const let VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME = "VK_EXT_shader_atomic_float2"; } + +[CRepr] struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderBufferFloat16Atomics = false; + public VkBool32 shaderBufferFloat16AtomicAdd = false; + public VkBool32 shaderBufferFloat16AtomicMinMax = false; + public VkBool32 shaderBufferFloat32AtomicMinMax = false; + public VkBool32 shaderBufferFloat64AtomicMinMax = false; + public VkBool32 shaderSharedFloat16Atomics = false; + public VkBool32 shaderSharedFloat16AtomicAdd = false; + public VkBool32 shaderSharedFloat16AtomicMinMax = false; + public VkBool32 shaderSharedFloat32AtomicMinMax = false; + public VkBool32 shaderSharedFloat64AtomicMinMax = false; + public VkBool32 shaderImageFloat32AtomicMinMax = false; + public VkBool32 sparseImageFloat32AtomicMinMax = false; + + public this(void* pNext, VkBool32 shaderBufferFloat16Atomics, VkBool32 shaderBufferFloat16AtomicAdd, VkBool32 shaderBufferFloat16AtomicMinMax, VkBool32 shaderBufferFloat32AtomicMinMax, VkBool32 shaderBufferFloat64AtomicMinMax, VkBool32 shaderSharedFloat16Atomics, VkBool32 shaderSharedFloat16AtomicAdd, VkBool32 shaderSharedFloat16AtomicMinMax, VkBool32 shaderSharedFloat32AtomicMinMax, VkBool32 shaderSharedFloat64AtomicMinMax, VkBool32 shaderImageFloat32AtomicMinMax, VkBool32 sparseImageFloat32AtomicMinMax) : this() + { + this.pNext = pNext; + this.shaderBufferFloat16Atomics = shaderBufferFloat16Atomics; + this.shaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd; + this.shaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax; + this.shaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax; + this.shaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax; + this.shaderSharedFloat16Atomics = shaderSharedFloat16Atomics; + this.shaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd; + this.shaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax; + this.shaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax; + this.shaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax; + this.shaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax; + this.sparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax; + } +} + +static { public const let VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME = "VK_EXT_surface_maintenance1"; } + +typealias VkSurfacePresentModeEXT = VkSurfacePresentModeKHR; +typealias VkPresentScalingFlagBitsEXT = VkPresentScalingFlagBitsKHR; +typealias VkPresentScalingFlagsEXT = VkPresentScalingFlagsKHR; +typealias VkPresentGravityFlagBitsEXT = VkPresentGravityFlagBitsKHR; +typealias VkPresentGravityFlagsEXT = VkPresentGravityFlagsKHR; +typealias VkSurfacePresentScalingCapabilitiesEXT = VkSurfacePresentScalingCapabilitiesKHR; +typealias VkSurfacePresentModeCompatibilityEXT = VkSurfacePresentModeCompatibilityKHR; + +static { public const let VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME = "VK_EXT_swapchain_maintenance1"; } + +typealias VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; +typealias VkSwapchainPresentFenceInfoEXT = VkSwapchainPresentFenceInfoKHR; +typealias VkSwapchainPresentModesCreateInfoEXT = VkSwapchainPresentModesCreateInfoKHR; +typealias VkSwapchainPresentModeInfoEXT = VkSwapchainPresentModeInfoKHR; +typealias VkSwapchainPresentScalingCreateInfoEXT = VkSwapchainPresentScalingCreateInfoKHR; +typealias VkReleaseSwapchainImagesInfoEXT = VkReleaseSwapchainImagesInfoKHR; + +typealias PFN_vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesKHR; + +static { public const let VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME = "VK_EXT_shader_demote_to_helper_invocation"; } + +typealias VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +static { public const let VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 3; } +static { public const let VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = "VK_NV_device_generated_commands"; } + +[CRepr] struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxGraphicsShaderGroupCount = 0; + public uint32 maxIndirectSequenceCount = 0; + public uint32 maxIndirectCommandsTokenCount = 0; + public uint32 maxIndirectCommandsStreamCount = 0; + public uint32 maxIndirectCommandsTokenOffset = 0; + public uint32 maxIndirectCommandsStreamStride = 0; + public uint32 minSequencesCountBufferOffsetAlignment = 0; + public uint32 minSequencesIndexBufferOffsetAlignment = 0; + public uint32 minIndirectCommandsBufferOffsetAlignment = 0; +} + +[CRepr] struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceGeneratedCommands = false; + + public this(void* pNext, VkBool32 deviceGeneratedCommands) : this() + { + this.pNext = pNext; + this.deviceGeneratedCommands = deviceGeneratedCommands; + } +} + +[CRepr] struct VkGraphicsShaderGroupCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stageCount = 0; + public VkPipelineShaderStageCreateInfo* pStages = null; + public Span stages + { + get { return .(pStages, (.)stageCount); } + set mut { pStages = value.Ptr; stageCount = (.)value.Length; } + } + public VkPipelineVertexInputStateCreateInfo* pVertexInputState = null; + public VkPipelineTessellationStateCreateInfo* pTessellationState = null; + + public this(void* pNext, Span stages, VkPipelineVertexInputStateCreateInfo* pVertexInputState = null, VkPipelineTessellationStateCreateInfo* pTessellationState = null) : this() + { + this.pNext = pNext; + this.stages = stages; + this.pVertexInputState = pVertexInputState; + this.pTessellationState = pTessellationState; + } +} + +[CRepr] struct VkGraphicsPipelineShaderGroupsCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 groupCount = 0; + public VkGraphicsShaderGroupCreateInfoNV* pGroups = null; + public Span groups + { + get { return .(pGroups, (.)groupCount); } + set mut { pGroups = value.Ptr; groupCount = (.)value.Length; } + } + public uint32 pipelineCount = 0; + public VkPipeline* pPipelines = null; + public Span pipelines + { + get { return .(pPipelines, (.)pipelineCount); } + set mut { pPipelines = value.Ptr; pipelineCount = (.)value.Length; } + } + + public this(void* pNext = null, Span groups = default, Span pipelines = default) : this() + { + this.pNext = pNext; + this.groups = groups; + this.pipelines = pipelines; + } +} + +[CRepr] struct VkBindShaderGroupIndirectCommandNV : this() +{ + public uint32 groupIndex = 0; + + public this(uint32 groupIndex) : this() + { + this.groupIndex = groupIndex; + } +} + +[CRepr] struct VkBindIndexBufferIndirectCommandNV : this() +{ + public VkDeviceAddress bufferAddress = default; + public uint32 size = 0; + public VkIndexType indexType = default; + + public this(VkDeviceAddress bufferAddress, uint32 size, VkIndexType indexType) : this() + { + this.bufferAddress = bufferAddress; + this.size = size; + this.indexType = indexType; + } +} + +[CRepr] struct VkBindVertexBufferIndirectCommandNV : this() +{ + public VkDeviceAddress bufferAddress = default; + public uint32 size = 0; + public uint32 stride = 0; + + public this(VkDeviceAddress bufferAddress, uint32 size, uint32 stride) : this() + { + this.bufferAddress = bufferAddress; + this.size = size; + this.stride = stride; + } +} + +[CRepr] struct VkSetStateFlagsIndirectCommandNV : this() +{ + public uint32 data = 0; + + public this(uint32 data) : this() + { + this.data = data; + } +} + +[AllowDuplicates] enum VkIndirectStateFlagBitsNV : int32 +{ + [NoShow] VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1 << 0, + // pretty names + FlagFrontfaceNV = 1 << 0, +} + +typealias VkIndirectStateFlagsNV = VkIndirectStateFlagBitsNV; +struct VkIndirectCommandsLayoutNV : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkIndirectCommandsTokenTypeNV : int32 +{ + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004, + // pretty names + ShaderGroupNV = 0, + StateFlagsNV = 1, + IndexBufferNV = 2, + VertexBufferNV = 3, + PushConstantNV = 4, + DrawIndexedNV = 5, + DrawNV = 6, + DrawTasksNV = 7, + DrawMeshTasksNV = 1000328000, + PipelineNV = 1000428003, + DispatchNV = 1000428004, +} + +[AllowDuplicates] enum VkIndirectCommandsLayoutUsageFlagBitsNV : int32 +{ + [NoShow] VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 1 << 0, + [NoShow] VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 1 << 1, + [NoShow] VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 1 << 2, + // pretty names + ExplicitPreprocessNV = 1 << 0, + IndexedSequencesNV = 1 << 1, + UnorderedSequencesNV = 1 << 2, +} + +typealias VkIndirectCommandsLayoutUsageFlagsNV = VkIndirectCommandsLayoutUsageFlagBitsNV; + +[CRepr] struct VkIndirectCommandsStreamNV : this() +{ + public VkBuffer buffer = null; + public VkDeviceSize offset = default; + + public this(VkBuffer buffer, VkDeviceSize offset) : this() + { + this.buffer = buffer; + this.offset = offset; + } +} + +[CRepr] struct VkIndirectCommandsLayoutTokenNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectCommandsTokenTypeNV tokenType = default; + public uint32 stream = 0; + public uint32 offset = 0; + public uint32 vertexBindingUnit = 0; + public VkBool32 vertexDynamicStride = false; + public VkPipelineLayout pushconstantPipelineLayout = null; + public VkShaderStageFlags pushconstantShaderStageFlags = default; + public uint32 pushconstantOffset = 0; + public uint32 pushconstantSize = 0; + public VkIndirectStateFlagsNV indirectStateFlags = default; + public uint32 indexTypeCount = 0; + public VkIndexType* pIndexTypes = null; + public uint32* pIndexTypeValues = null; + + public this(void* pNext, VkIndirectCommandsTokenTypeNV tokenType, uint32 stream, uint32 offset, uint32 vertexBindingUnit, VkBool32 vertexDynamicStride, VkPipelineLayout pushconstantPipelineLayout, VkShaderStageFlags pushconstantShaderStageFlags, uint32 pushconstantOffset, uint32 pushconstantSize, VkIndirectStateFlagsNV indirectStateFlags, uint32 indexTypeCount, VkIndexType* pIndexTypes, uint32* pIndexTypeValues) : this() + { + this.pNext = pNext; + this.tokenType = tokenType; + this.stream = stream; + this.offset = offset; + this.vertexBindingUnit = vertexBindingUnit; + this.vertexDynamicStride = vertexDynamicStride; + this.pushconstantPipelineLayout = pushconstantPipelineLayout; + this.pushconstantShaderStageFlags = pushconstantShaderStageFlags; + this.pushconstantOffset = pushconstantOffset; + this.pushconstantSize = pushconstantSize; + this.indirectStateFlags = indirectStateFlags; + this.indexTypeCount = indexTypeCount; + this.pIndexTypes = pIndexTypes; + this.pIndexTypeValues = pIndexTypeValues; + } +} + +[CRepr] struct VkIndirectCommandsLayoutCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectCommandsLayoutUsageFlagsNV flags = default; + public VkPipelineBindPoint pipelineBindPoint = default; + public uint32 tokenCount = 0; + public VkIndirectCommandsLayoutTokenNV* pTokens = null; + public Span tokens + { + get { return .(pTokens, (.)tokenCount); } + set mut { pTokens = value.Ptr; tokenCount = (.)value.Length; } + } + public uint32 streamCount = 0; + public uint32* pStreamStrides = null; + public Span streamStrides + { + get { return .(pStreamStrides, (.)streamCount); } + set mut { pStreamStrides = value.Ptr; streamCount = (.)value.Length; } + } + + public this(void* pNext, VkIndirectCommandsLayoutUsageFlagsNV flags, VkPipelineBindPoint pipelineBindPoint, Span tokens, Span streamStrides) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pipelineBindPoint = pipelineBindPoint; + this.tokens = tokens; + this.streamStrides = streamStrides; + } +} + +[CRepr] struct VkGeneratedCommandsInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineBindPoint pipelineBindPoint = default; + public VkPipeline pipeline = null; + public VkIndirectCommandsLayoutNV indirectCommandsLayout = null; + public uint32 streamCount = 0; + public VkIndirectCommandsStreamNV* pStreams = null; + public Span streams + { + get { return .(pStreams, (.)streamCount); } + set mut { pStreams = value.Ptr; streamCount = (.)value.Length; } + } + public uint32 sequencesCount = 0; + public VkBuffer preprocessBuffer = null; + public VkDeviceSize preprocessOffset = default; + public VkDeviceSize preprocessSize = default; + public VkBuffer sequencesCountBuffer = null; + public VkDeviceSize sequencesCountOffset = default; + public VkBuffer sequencesIndexBuffer = null; + public VkDeviceSize sequencesIndexOffset = default; + + public this(void* pNext, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, VkIndirectCommandsLayoutNV indirectCommandsLayout, Span streams, uint32 sequencesCount, VkBuffer preprocessBuffer, VkDeviceSize preprocessOffset, VkDeviceSize preprocessSize, VkBuffer sequencesCountBuffer, VkDeviceSize sequencesCountOffset, VkBuffer sequencesIndexBuffer, VkDeviceSize sequencesIndexOffset) : this() + { + this.pNext = pNext; + this.pipelineBindPoint = pipelineBindPoint; + this.pipeline = pipeline; + this.indirectCommandsLayout = indirectCommandsLayout; + this.streams = streams; + this.sequencesCount = sequencesCount; + this.preprocessBuffer = preprocessBuffer; + this.preprocessOffset = preprocessOffset; + this.preprocessSize = preprocessSize; + this.sequencesCountBuffer = sequencesCountBuffer; + this.sequencesCountOffset = sequencesCountOffset; + this.sequencesIndexBuffer = sequencesIndexBuffer; + this.sequencesIndexOffset = sequencesIndexOffset; + } +} + +[CRepr] struct VkGeneratedCommandsMemoryRequirementsInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineBindPoint pipelineBindPoint = default; + public VkPipeline pipeline = null; + public VkIndirectCommandsLayoutNV indirectCommandsLayout = null; + public uint32 maxSequencesCount = 0; + + public this(void* pNext, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, VkIndirectCommandsLayoutNV indirectCommandsLayout, uint32 maxSequencesCount) : this() + { + this.pNext = pNext; + this.pipelineBindPoint = pipelineBindPoint; + this.pipeline = pipeline; + this.indirectCommandsLayout = indirectCommandsLayout; + this.maxSequencesCount = maxSequencesCount; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32 groupIndex); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectCommandsLayoutNV pIndirectCommandsLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout = null, VkAllocationCallbacks* pAllocator = null); + +static { public const let VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION = 1; } +static { public const let VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME = "VK_NV_inherited_viewport_scissor"; } + +[CRepr] struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 inheritedViewportScissor2D = false; + + public this(void* pNext, VkBool32 inheritedViewportScissor2D) : this() + { + this.pNext = pNext; + this.inheritedViewportScissor2D = inheritedViewportScissor2D; + } +} + +[CRepr] struct VkCommandBufferInheritanceViewportScissorInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 viewportScissor2D = false; + public uint32 viewportDepthCount = 0; + public VkViewport* pViewportDepths = null; + + public this(void* pNext, VkBool32 viewportScissor2D, uint32 viewportDepthCount, VkViewport* pViewportDepths) : this() + { + this.pNext = pNext; + this.viewportScissor2D = viewportScissor2D; + this.viewportDepthCount = viewportDepthCount; + this.pViewportDepths = pViewportDepths; + } +} + +static { public const let VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME = "VK_KHR_shader_integer_dot_product"; } + +typealias VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = VkPhysicalDeviceShaderIntegerDotProductFeatures; +typealias VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = VkPhysicalDeviceShaderIntegerDotProductProperties; + +static { public const let VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION = 1; } +static { public const let VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME = "VK_EXT_texel_buffer_alignment"; } + +[CRepr] struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 texelBufferAlignment = false; + + public this(void* pNext, VkBool32 texelBufferAlignment) : this() + { + this.pNext = pNext; + this.texelBufferAlignment = texelBufferAlignment; + } +} + +typealias VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = VkPhysicalDeviceTexelBufferAlignmentProperties; + +static { public const let VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION = 5; } +static { public const let VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME = "VK_QCOM_render_pass_transform"; } + +[CRepr] struct VkRenderPassTransformBeginInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; // Pointer to next structure + public VkSurfaceTransformFlagBitsKHR transform = default; + + public this(void* pNext, VkSurfaceTransformFlagBitsKHR transform) : this() + { + this.pNext = pNext; + this.transform = transform; + } +} + +[CRepr] struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; // Pointer to next structure + public VkSurfaceTransformFlagBitsKHR transform = default; + public VkRect2D renderArea = default; + + public this(void* pNext, VkSurfaceTransformFlagBitsKHR transform, VkRect2D renderArea) : this() + { + this.pNext = pNext; + this.transform = transform; + this.renderArea = renderArea; + } +} + +static { public const let VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME = "VK_EXT_depth_bias_control"; } + +[CRepr] struct VkPhysicalDeviceDepthBiasControlFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 depthBiasControl = false; + public VkBool32 leastRepresentableValueForceUnormRepresentation = false; + public VkBool32 floatRepresentation = false; + public VkBool32 depthBiasExact = false; + + public this(void* pNext, VkBool32 depthBiasControl, VkBool32 leastRepresentableValueForceUnormRepresentation, VkBool32 floatRepresentation, VkBool32 depthBiasExact) : this() + { + this.pNext = pNext; + this.depthBiasControl = depthBiasControl; + this.leastRepresentableValueForceUnormRepresentation = leastRepresentableValueForceUnormRepresentation; + this.floatRepresentation = floatRepresentation; + this.depthBiasExact = depthBiasExact; + } +} + +[CRepr] struct VkDepthBiasInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public float depthBiasConstantFactor = 0; + public float depthBiasClamp = 0; + public float depthBiasSlopeFactor = 0; + + public this(void* pNext, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) : this() + { + this.pNext = pNext; + this.depthBiasConstantFactor = depthBiasConstantFactor; + this.depthBiasClamp = depthBiasClamp; + this.depthBiasSlopeFactor = depthBiasSlopeFactor; + } +} + +[AllowDuplicates] enum VkDepthBiasRepresentationEXT : int32 +{ + [NoShow] VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT = 0, + [NoShow] VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT = 1, + [NoShow] VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT = 2, + // pretty names + LeastRepresentableValueFormatEXT = 0, + LeastRepresentableValueForceUnormEXT = 1, + FloatEXT = 2, +} + +[CRepr] struct VkDepthBiasRepresentationInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDepthBiasRepresentationEXT depthBiasRepresentation = default; + public VkBool32 depthBiasExact = false; + + public this(void* pNext, VkDepthBiasRepresentationEXT depthBiasRepresentation, VkBool32 depthBiasExact) : this() + { + this.pNext = pNext; + this.depthBiasRepresentation = depthBiasRepresentation; + this.depthBiasExact = depthBiasExact; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, VkDepthBiasInfoEXT* pDepthBiasInfo); + +static { public const let VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION = 2; } +static { public const let VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME = "VK_EXT_device_memory_report"; } + +[CRepr] struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceMemoryReport = false; + + public this(void* pNext, VkBool32 deviceMemoryReport) : this() + { + this.pNext = pNext; + this.deviceMemoryReport = deviceMemoryReport; + } +} + +[CRepr] struct VkDeviceDeviceMemoryReportCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemoryReportFlagsEXT flags = default; + public PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback = default; + public void* pUserData = null; + + public this(void* pNext, VkDeviceMemoryReportFlagsEXT flags, PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback, void* pUserData) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pfnUserCallback = pfnUserCallback; + this.pUserData = pUserData; + } +} + +[CRepr] struct VkDeviceMemoryReportCallbackDataEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemoryReportFlagsEXT flags = default; + public VkDeviceMemoryReportEventTypeEXT type = default; + public uint64 memoryObjectId = 0; + public VkDeviceSize size = default; + public VkObjectType objectType = default; + public uint64 objectHandle = 0; + public uint32 heapIndex = 0; +} + +typealias VkDeviceMemoryReportFlagsEXT = VkFlags; + +[AllowDuplicates] enum VkDeviceMemoryReportEventTypeEXT : int32 +{ + [NoShow] VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, + [NoShow] VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, + [NoShow] VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, + [NoShow] VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, + [NoShow] VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, + // pretty names + AllocateEXT = 0, + FreeEXT = 1, + ImportEXT = 2, + UnimportEXT = 3, + AllocationFailedEXT = 4, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkDeviceMemoryReportCallbackEXT( + VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + +// codespell:ignore devault +static { public const let VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION = 1; } +static { public const let VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_drm_display"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32 drmFd, VkDisplayKHR display); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32 drmFd, uint32 connectorId, out VkDisplayKHR display); + +static { public const let VK_EXT_ROBUSTNESS_2_SPEC_VERSION = 1; } +static { public const let VK_EXT_ROBUSTNESS_2_EXTENSION_NAME = "VK_EXT_robustness2"; } + +typealias VkPhysicalDeviceRobustness2FeaturesEXT = VkPhysicalDeviceRobustness2FeaturesKHR; +typealias VkPhysicalDeviceRobustness2PropertiesEXT = VkPhysicalDeviceRobustness2PropertiesKHR; + +static { public const let VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION = 12; } +static { public const let VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME = "VK_EXT_custom_border_color"; } + +[CRepr] struct VkSamplerCustomBorderColorCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkClearColorValue customBorderColor = default; + public VkFormat format = default; + + public this(void* pNext, VkClearColorValue customBorderColor, VkFormat format) : this() + { + this.pNext = pNext; + this.customBorderColor = customBorderColor; + this.format = format; + } +} + +[CRepr] struct VkPhysicalDeviceCustomBorderColorPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxCustomBorderColorSamplers = 0; +} + +[CRepr] struct VkPhysicalDeviceCustomBorderColorFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 customBorderColors = false; + public VkBool32 customBorderColorWithoutFormat = false; + + public this(void* pNext, VkBool32 customBorderColors, VkBool32 customBorderColorWithoutFormat) : this() + { + this.pNext = pNext; + this.customBorderColors = customBorderColors; + this.customBorderColorWithoutFormat = customBorderColorWithoutFormat; + } +} + +static { public const let VK_GOOGLE_USER_TYPE_SPEC_VERSION = 1; } +static { public const let VK_GOOGLE_USER_TYPE_EXTENSION_NAME = "VK_GOOGLE_user_type"; } +static { public const let VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION = 1; } +static { public const let VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME = "VK_KHR_pipeline_library"; } + +[CRepr] struct VkPipelineLibraryCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 libraryCount = 0; + public VkPipeline* pLibraries = null; + public Span libraries + { + get { return .(pLibraries, (.)libraryCount); } + set mut { pLibraries = value.Ptr; libraryCount = (.)value.Length; } + } + + public this(void* pNext = null, Span libraries = default) : this() + { + this.pNext = pNext; + this.libraries = libraries; + } +} + +static { public const let VK_NV_PRESENT_BARRIER_SPEC_VERSION = 1; } +static { public const let VK_NV_PRESENT_BARRIER_EXTENSION_NAME = "VK_NV_present_barrier"; } + +[CRepr] struct VkPhysicalDevicePresentBarrierFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentBarrier = false; + + public this(void* pNext, VkBool32 presentBarrier) : this() + { + this.pNext = pNext; + this.presentBarrier = presentBarrier; + } +} + +[CRepr] struct VkSurfaceCapabilitiesPresentBarrierNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentBarrierSupported = false; +} + +[CRepr] struct VkSwapchainPresentBarrierCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentBarrierEnable = false; + + public this(void* pNext, VkBool32 presentBarrierEnable) : this() + { + this.pNext = pNext; + this.presentBarrierEnable = presentBarrierEnable; + } +} + +static { public const let VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME = "VK_KHR_shader_non_semantic_info"; } +static { public const let VK_KHR_PRESENT_ID_SPEC_VERSION = 1; } +static { public const let VK_KHR_PRESENT_ID_EXTENSION_NAME = "VK_KHR_present_id"; } + +[CRepr] struct VkPresentIdKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_ID_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public uint64* pPresentIds = null; // Present ID values for each swapchain + public Span presentIds + { + get { return .(pPresentIds, (.)swapchainCount); } + set mut { pPresentIds = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span presentIds = default) : this() + { + this.pNext = pNext; + this.presentIds = presentIds; + } +} + +[CRepr] struct VkPhysicalDevicePresentIdFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentId = false; // Present ID in VkPresentInfoKHR + + public this(void* pNext, VkBool32 presentId) : this() + { + this.pNext = pNext; + this.presentId = presentId; + } +} + +static { public const let VK_EXT_PRIVATE_DATA_SPEC_VERSION = 1; } +static { public const let VK_EXT_PRIVATE_DATA_EXTENSION_NAME = "VK_EXT_private_data"; } + +typealias VkPhysicalDevicePrivateDataFeaturesEXT = VkPhysicalDevicePrivateDataFeatures; +typealias VkDevicePrivateDataCreateInfoEXT = VkDevicePrivateDataCreateInfo; +typealias VkPrivateDataSlotCreateInfoEXT = VkPrivateDataSlotCreateInfo; +typealias VkPrivateDataSlotEXT = VkPrivateDataSlot; +typealias VkPrivateDataSlotCreateFlagsEXT = VkPrivateDataSlotCreateFlags; + +typealias PFN_vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlot; +typealias PFN_vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlot; +typealias PFN_vkSetPrivateDataEXT = PFN_vkSetPrivateData; +typealias PFN_vkGetPrivateDataEXT = PFN_vkGetPrivateData; + +static { public const let VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION = 3; } +static { public const let VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME = "VK_EXT_pipeline_creation_cache_control"; } + +typealias VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = VkPhysicalDevicePipelineCreationCacheControlFeatures; + +static { public const let VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION = 12; } +static { public const let VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME = "VK_KHR_video_encode_queue"; } + +typealias VkVideoEncodeFlagsKHR = VkVideoEncodeFlagBitsKHR; + +[CRepr] struct VkVideoEncodeInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeFlagsKHR flags = default; + public VkBuffer dstBuffer = null; + public VkDeviceSize dstBufferOffset = default; + public VkDeviceSize dstBufferRange = default; + public VkVideoPictureResourceInfoKHR srcPictureResource = default; + public VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot = null; + public uint32 referenceSlotCount = 0; + public VkVideoReferenceSlotInfoKHR* pReferenceSlots = null; + public Span referenceSlots + { + get { return .(pReferenceSlots, (.)referenceSlotCount); } + set mut { pReferenceSlots = value.Ptr; referenceSlotCount = (.)value.Length; } + } + public uint32 precedingExternallyEncodedBytes = 0; + + public this(void* pNext, VkVideoEncodeFlagsKHR flags, VkBuffer dstBuffer, VkDeviceSize dstBufferOffset, VkDeviceSize dstBufferRange, VkVideoPictureResourceInfoKHR srcPictureResource, VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot, Span referenceSlots, uint32 precedingExternallyEncodedBytes) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dstBuffer = dstBuffer; + this.dstBufferOffset = dstBufferOffset; + this.dstBufferRange = dstBufferRange; + this.srcPictureResource = srcPictureResource; + this.pSetupReferenceSlot = pSetupReferenceSlot; + this.referenceSlots = referenceSlots; + this.precedingExternallyEncodedBytes = precedingExternallyEncodedBytes; + } +} + +[AllowDuplicates] enum VkVideoEncodeCapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR = 1 << 3, + // pretty names + PrecedingExternallyEncodedBytesKHR = 1 << 0, + InsufficientBitstreamBufferRangeDetectionKHR = 1 << 1, + QuantizationDeltaMapKHR = 1 << 2, + EmphasisMapKHR = 1 << 3, +} + +typealias VkVideoEncodeCapabilityFlagsKHR = VkVideoEncodeCapabilityFlagBitsKHR; + +[CRepr] struct VkVideoEncodeCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeCapabilityFlagsKHR flags = default; + public VkVideoEncodeRateControlModeFlagsKHR rateControlModes = default; + public uint32 maxRateControlLayers = 0; + public uint64 maxBitrate = 0; + public uint32 maxQualityLevels = 0; + public VkExtent2D encodeInputPictureGranularity = default; + public VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = default; +} + +[CRepr] struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags = default; + + public this(void* pNext, VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags) : this() + { + this.pNext = pNext; + this.encodeFeedbackFlags = encodeFeedbackFlags; + } +} + +[AllowDuplicates] enum VkVideoEncodeFeedbackFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 1 << 2, + // pretty names + BitstreamBufferOffsetKHR = 1 << 0, + BitstreamBytesWrittenKHR = 1 << 1, + BitstreamHasOverridesKHR = 1 << 2, +} + +typealias VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeUsageFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 1 << 3, + // pretty names + DefaultKHR = 0, + TranscodingKHR = 1 << 0, + StreamingKHR = 1 << 1, + RecordingKHR = 1 << 2, + ConferencingKHR = 1 << 3, +} + +typealias VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeContentFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 1 << 2, + // pretty names + DefaultKHR = 0, + CameraKHR = 1 << 0, + DesktopKHR = 1 << 1, + RenderedKHR = 1 << 2, +} + +typealias VkVideoEncodeContentFlagsKHR = VkVideoEncodeContentFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeTuningModeKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, + [NoShow] VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, + [NoShow] VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, + [NoShow] VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, + // pretty names + DefaultKHR = 0, + HighQualityKHR = 1, + LowLatencyKHR = 2, + UltraLowLatencyKHR = 3, + LosslessKHR = 4, +} + +[CRepr] struct VkVideoEncodeUsageInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeUsageFlagsKHR videoUsageHints = default; + public VkVideoEncodeContentFlagsKHR videoContentHints = default; + public VkVideoEncodeTuningModeKHR tuningMode = default; + + public this(void* pNext = null, VkVideoEncodeUsageFlagsKHR videoUsageHints = default, VkVideoEncodeContentFlagsKHR videoContentHints = default, VkVideoEncodeTuningModeKHR tuningMode = default) : this() + { + this.pNext = pNext; + this.videoUsageHints = videoUsageHints; + this.videoContentHints = videoContentHints; + this.tuningMode = tuningMode; + } +} + +typealias VkVideoEncodeRateControlFlagsKHR = VkFlags; + +[AllowDuplicates] enum VkVideoEncodeRateControlModeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 1 << 2, + // pretty names + DefaultKHR = 0, + DisabledKHR = 1 << 0, + CbrKHR = 1 << 1, + VbrKHR = 1 << 2, +} + +typealias VkVideoEncodeRateControlModeFlagsKHR = VkVideoEncodeRateControlModeFlagBitsKHR; + +[CRepr] struct VkVideoEncodeRateControlInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeRateControlFlagsKHR flags = default; + public VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode = default; + public uint32 layerCount = 0; + public VkVideoEncodeRateControlLayerInfoKHR* pLayers = null; + public Span layers + { + get { return .(pLayers, (.)layerCount); } + set mut { pLayers = value.Ptr; layerCount = (.)value.Length; } + } + public uint32 virtualBufferSizeInMs = 0; + public uint32 initialVirtualBufferSizeInMs = 0; + + public this(void* pNext, VkVideoEncodeRateControlFlagsKHR flags, VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode, Span layers, uint32 virtualBufferSizeInMs, uint32 initialVirtualBufferSizeInMs) : this() + { + this.pNext = pNext; + this.flags = flags; + this.rateControlMode = rateControlMode; + this.layers = layers; + this.virtualBufferSizeInMs = virtualBufferSizeInMs; + this.initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs; + } +} + +[CRepr] struct VkVideoEncodeRateControlLayerInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 averageBitrate = 0; + public uint64 maxBitrate = 0; + public uint32 frameRateNumerator = 0; + public uint32 frameRateDenominator = 0; + + public this(void* pNext, uint64 averageBitrate, uint64 maxBitrate, uint32 frameRateNumerator, uint32 frameRateDenominator) : this() + { + this.pNext = pNext; + this.averageBitrate = averageBitrate; + this.maxBitrate = maxBitrate; + this.frameRateNumerator = frameRateNumerator; + this.frameRateDenominator = frameRateDenominator; + } +} + +[CRepr] struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoProfileInfoKHR* pVideoProfile = null; + public uint32 qualityLevel = 0; + + public this(void* pNext, VkVideoProfileInfoKHR* pVideoProfile, uint32 qualityLevel) : this() + { + this.pNext = pNext; + this.pVideoProfile = pVideoProfile; + this.qualityLevel = qualityLevel; + } +} + +[CRepr] struct VkVideoEncodeQualityLevelPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode = default; + public uint32 preferredRateControlLayerCount = 0; +} + +[CRepr] struct VkVideoEncodeQualityLevelInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 qualityLevel = 0; + + public this(void* pNext, uint32 qualityLevel) : this() + { + this.pNext = pNext; + this.qualityLevel = qualityLevel; + } +} + +[CRepr] struct VkVideoEncodeSessionParametersGetInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoSessionParametersKHR videoSessionParameters = null; + + public this(void* pNext, VkVideoSessionParametersKHR videoSessionParameters) : this() + { + this.pNext = pNext; + this.videoSessionParameters = videoSessionParameters; + } +} + +[CRepr] struct VkVideoEncodeSessionParametersFeedbackInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hasOverrides = false; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, out VkVideoEncodeQualityLevelPropertiesKHR pQualityLevelProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetEncodedVideoSessionParametersKHR(VkDevice device, VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, out VkVideoEncodeSessionParametersFeedbackInfoKHR pFeedbackInfo, out c_size pDataSize, void* pData = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, VkVideoEncodeInfoKHR* pEncodeInfo); + +static { public const let VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION = 2; } +static { public const let VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME = "VK_NV_device_diagnostics_config"; } + +[CRepr] struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 diagnosticsConfig = false; + + public this(void* pNext, VkBool32 diagnosticsConfig) : this() + { + this.pNext = pNext; + this.diagnosticsConfig = diagnosticsConfig; + } +} + +[CRepr] struct VkDeviceDiagnosticsConfigCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceDiagnosticsConfigFlagsNV flags = default; + + public this(void* pNext = null, VkDeviceDiagnosticsConfigFlagsNV flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +typealias VkDeviceDiagnosticsConfigFlagsNV = VkDeviceDiagnosticsConfigFlagBitsNV; + +[AllowDuplicates] enum VkDeviceDiagnosticsConfigFlagBitsNV : int32 +{ + [NoShow] VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 1 << 0, + [NoShow] VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 1 << 1, + [NoShow] VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 1 << 2, + [NoShow] VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 1 << 3, + // pretty names + EnableShaderDebugInfoNV = 1 << 0, + EnableResourceTrackingNV = 1 << 1, + EnableAutomaticCheckpointsNV = 1 << 2, + EnableShaderErrorReportingNV = 1 << 3, +} + +static { public const let VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION = 2; } +static { public const let VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME = "VK_QCOM_render_pass_store_ops"; } +static { public const let VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION = 2; } +static { public const let VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME = "VK_NV_cuda_kernel_launch"; } + +struct VkCudaModuleNV : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_CUDA_MODULE_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +struct VkCudaFunctionNV : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_CUDA_FUNCTION_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkCudaModuleCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(void* pNext, Span data) : this() + { + this.pNext = pNext; + this.data = data; + } +} + +[CRepr] struct VkCudaFunctionCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCudaModuleNV module = null; + public char8* pName = null; + + public this(void* pNext, VkCudaModuleNV module, char8* pName) : this() + { + this.pNext = pNext; + this.module = module; + this.pName = pName; + } +} + +[CRepr] struct VkCudaLaunchInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCudaFunctionNV @function = null; + public uint32 gridDimX = 0; + public uint32 gridDimY = 0; + public uint32 gridDimZ = 0; + public uint32 blockDimX = 0; + public uint32 blockDimY = 0; + public uint32 blockDimZ = 0; + public uint32 sharedMemBytes = 0; + public c_size paramCount = 0; + public void** pParams = null; + public Span @params + { + get { return .(pParams, (.)paramCount); } + set mut { pParams = value.Ptr; paramCount = (.)value.Length; } + } + public c_size extraCount = 0; + public void** pExtras = null; + public Span extras + { + get { return .(pExtras, (.)extraCount); } + set mut { pExtras = value.Ptr; extraCount = (.)value.Length; } + } + + public this(void* pNext, VkCudaFunctionNV @function, uint32 gridDimX, uint32 gridDimY, uint32 gridDimZ, uint32 blockDimX, uint32 blockDimY, uint32 blockDimZ, uint32 sharedMemBytes, Span @params = default, Span extras = default) : this() + { + this.pNext = pNext; + this.function = @function; + this.gridDimX = gridDimX; + this.gridDimY = gridDimY; + this.gridDimZ = gridDimZ; + this.blockDimX = blockDimX; + this.blockDimY = blockDimY; + this.blockDimZ = blockDimZ; + this.sharedMemBytes = sharedMemBytes; + this.params = @params; + this.extras = extras; + } +} + +[CRepr] struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cudaKernelLaunchFeatures = false; + + public this(void* pNext, VkBool32 cudaKernelLaunchFeatures) : this() + { + this.pNext = pNext; + this.cudaKernelLaunchFeatures = cudaKernelLaunchFeatures; + } +} + +[CRepr] struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 computeCapabilityMinor = 0; + public uint32 computeCapabilityMajor = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateCudaModuleNV(VkDevice device, VkCudaModuleCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCudaModuleNV pModule); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, out c_size pCacheSize, void* pCacheData = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateCudaFunctionNV(VkDevice device, VkCudaFunctionCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkCudaFunctionNV pFunction); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV @function, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, VkCudaLaunchInfoNV* pLaunchInfo); + +static { public const let VK_QCOM_TILE_SHADING_SPEC_VERSION = 2; } +static { public const let VK_QCOM_TILE_SHADING_EXTENSION_NAME = "VK_QCOM_tile_shading"; } + +[CRepr] struct VkPhysicalDeviceTileShadingFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 tileShading = false; + public VkBool32 tileShadingFragmentStage = false; + public VkBool32 tileShadingColorAttachments = false; + public VkBool32 tileShadingDepthAttachments = false; + public VkBool32 tileShadingStencilAttachments = false; + public VkBool32 tileShadingInputAttachments = false; + public VkBool32 tileShadingSampledAttachments = false; + public VkBool32 tileShadingPerTileDraw = false; + public VkBool32 tileShadingPerTileDispatch = false; + public VkBool32 tileShadingDispatchTile = false; + public VkBool32 tileShadingApron = false; + public VkBool32 tileShadingAnisotropicApron = false; + public VkBool32 tileShadingAtomicOps = false; + public VkBool32 tileShadingImageProcessing = false; + + public this(void* pNext, VkBool32 tileShading, VkBool32 tileShadingFragmentStage, VkBool32 tileShadingColorAttachments, VkBool32 tileShadingDepthAttachments, VkBool32 tileShadingStencilAttachments, VkBool32 tileShadingInputAttachments, VkBool32 tileShadingSampledAttachments, VkBool32 tileShadingPerTileDraw, VkBool32 tileShadingPerTileDispatch, VkBool32 tileShadingDispatchTile, VkBool32 tileShadingApron, VkBool32 tileShadingAnisotropicApron, VkBool32 tileShadingAtomicOps, VkBool32 tileShadingImageProcessing) : this() + { + this.pNext = pNext; + this.tileShading = tileShading; + this.tileShadingFragmentStage = tileShadingFragmentStage; + this.tileShadingColorAttachments = tileShadingColorAttachments; + this.tileShadingDepthAttachments = tileShadingDepthAttachments; + this.tileShadingStencilAttachments = tileShadingStencilAttachments; + this.tileShadingInputAttachments = tileShadingInputAttachments; + this.tileShadingSampledAttachments = tileShadingSampledAttachments; + this.tileShadingPerTileDraw = tileShadingPerTileDraw; + this.tileShadingPerTileDispatch = tileShadingPerTileDispatch; + this.tileShadingDispatchTile = tileShadingDispatchTile; + this.tileShadingApron = tileShadingApron; + this.tileShadingAnisotropicApron = tileShadingAnisotropicApron; + this.tileShadingAtomicOps = tileShadingAtomicOps; + this.tileShadingImageProcessing = tileShadingImageProcessing; + } +} + +[CRepr] struct VkPhysicalDeviceTileShadingPropertiesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxApronSize = 0; + public VkBool32 preferNonCoherent = false; + public VkExtent2D tileGranularity = default; + public VkExtent2D maxTileShadingRate = default; +} + +[CRepr] struct VkRenderPassTileShadingCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTileShadingRenderPassFlagsQCOM flags = default; + public VkExtent2D tileApronSize = default; + + public this(void* pNext = null, VkTileShadingRenderPassFlagsQCOM flags = default, VkExtent2D tileApronSize = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.tileApronSize = tileApronSize; + } +} + +[CRepr] struct VkPerTileBeginInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CRepr] struct VkPerTileEndInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CRepr] struct VkDispatchTileInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +typealias VkTileShadingRenderPassFlagsQCOM = VkTileShadingRenderPassFlagBitsQCOM; + +[AllowDuplicates] enum VkTileShadingRenderPassFlagBitsQCOM : int32 +{ + [NoShow] VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM = 1 << 0, + [NoShow] VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM = 1 << 1, + // pretty names + EnableQCOM = 1 << 0, + PerTileExecutionQCOM = 1 << 1, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, VkDispatchTileInfoQCOM* pDispatchTileInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, VkPerTileEndInfoQCOM* pPerTileEndInfo); + +static { public const let VK_NV_LOW_LATENCY_SPEC_VERSION = 1; } +static { public const let VK_NV_LOW_LATENCY_EXTENSION_NAME = "VK_NV_low_latency"; } + +[CRepr] struct VkQueryLowLatencySupportNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public void* pQueriedLowLatencyData = null; + + public this(void* pNext, void* pQueriedLowLatencyData) : this() + { + this.pNext = pNext; + this.pQueriedLowLatencyData = pQueriedLowLatencyData; + } +} + +static { public const let VK_EXT_METAL_OBJECTS_SPEC_VERSION = 2; } +static { public const let VK_EXT_METAL_OBJECTS_EXTENSION_NAME = "VK_EXT_metal_objects"; } + +[AllowDuplicates] enum VkExportMetalObjectTypeFlagBitsEXT : int32 +{ + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 1 << 0, + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 1 << 1, + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 1 << 2, + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 1 << 3, + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 1 << 4, + [NoShow] VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 1 << 5, + // pretty names + MetalDeviceEXT = 1 << 0, + MetalCommandQueueEXT = 1 << 1, + MetalBufferEXT = 1 << 2, + MetalTextureEXT = 1 << 3, + MetalIosurfaceEXT = 1 << 4, + MetalSharedEventEXT = 1 << 5, +} + +typealias VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagBitsEXT; + +[CRepr] struct VkExportMetalObjectCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExportMetalObjectTypeFlagBitsEXT exportObjectType = default; + + public this(void* pNext = null, VkExportMetalObjectTypeFlagBitsEXT exportObjectType = default) : this() + { + this.pNext = pNext; + this.exportObjectType = exportObjectType; + } +} + +[CRepr] struct VkExportMetalObjectsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CRepr] struct VkExportMetalDeviceInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public MTLDevice_id mtlDevice = default; + + public this(void* pNext, MTLDevice_id mtlDevice) : this() + { + this.pNext = pNext; + this.mtlDevice = mtlDevice; + } +} + +[CRepr] struct VkExportMetalCommandQueueInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueue queue = null; + public MTLCommandQueue_id mtlCommandQueue = default; + + public this(void* pNext, VkQueue queue, MTLCommandQueue_id mtlCommandQueue) : this() + { + this.pNext = pNext; + this.queue = queue; + this.mtlCommandQueue = mtlCommandQueue; + } +} + +[CRepr] struct VkExportMetalBufferInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public MTLBuffer_id mtlBuffer = default; + + public this(void* pNext, VkDeviceMemory memory, MTLBuffer_id mtlBuffer) : this() + { + this.pNext = pNext; + this.memory = memory; + this.mtlBuffer = mtlBuffer; + } +} + +[CRepr] struct VkImportMetalBufferInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public MTLBuffer_id mtlBuffer = default; + + public this(void* pNext, MTLBuffer_id mtlBuffer) : this() + { + this.pNext = pNext; + this.mtlBuffer = mtlBuffer; + } +} + +[CRepr] struct VkExportMetalTextureInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + public VkImageView imageView = null; + public VkBufferView bufferView = null; + public VkImageAspectFlagBits plane = default; + public MTLTexture_id mtlTexture = default; + + public this(void* pNext, VkImage image, VkImageView imageView, VkBufferView bufferView, VkImageAspectFlagBits plane, MTLTexture_id mtlTexture) : this() + { + this.pNext = pNext; + this.image = image; + this.imageView = imageView; + this.bufferView = bufferView; + this.plane = plane; + this.mtlTexture = mtlTexture; + } +} + +[CRepr] struct VkImportMetalTextureInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageAspectFlagBits plane = default; + public MTLTexture_id mtlTexture = default; + + public this(void* pNext, VkImageAspectFlagBits plane, MTLTexture_id mtlTexture) : this() + { + this.pNext = pNext; + this.plane = plane; + this.mtlTexture = mtlTexture; + } +} + +[CRepr] struct VkExportMetalIOSurfaceInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + public IOSurfaceRef ioSurface = default; + + public this(void* pNext, VkImage image, IOSurfaceRef ioSurface) : this() + { + this.pNext = pNext; + this.image = image; + this.ioSurface = ioSurface; + } +} + +[CRepr] struct VkImportMetalIOSurfaceInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public IOSurfaceRef ioSurface = default; + + public this(void* pNext = null, IOSurfaceRef ioSurface = default) : this() + { + this.pNext = pNext; + this.ioSurface = ioSurface; + } +} + +[CRepr] struct VkExportMetalSharedEventInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkEvent event = null; + public MTLSharedEvent_id mtlSharedEvent = default; + + public this(void* pNext, VkSemaphore semaphore, VkEvent event, MTLSharedEvent_id mtlSharedEvent) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.event = event; + this.mtlSharedEvent = mtlSharedEvent; + } +} + +[CRepr] struct VkImportMetalSharedEventInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public MTLSharedEvent_id mtlSharedEvent = default; + + public this(void* pNext, MTLSharedEvent_id mtlSharedEvent) : this() + { + this.pNext = pNext; + this.mtlSharedEvent = mtlSharedEvent; + } +} + +struct MTLDevice_id : int {} +struct MTLCommandQueue_id : int {} +struct MTLBuffer_id : int {} +struct MTLTexture_id : int {} +struct MTLSharedEvent_id : int {} +struct IOSurfaceRef : int {} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkExportMetalObjectsEXT(VkDevice device, out VkExportMetalObjectsInfoEXT pMetalObjectsInfo); + +static { public const let VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME = "VK_KHR_synchronization2"; } + +typealias VkPipelineStageFlags2KHR = VkPipelineStageFlags2; +typealias VkPipelineStageFlagBits2KHR = VkPipelineStageFlagBits2; +typealias VkAccessFlags2KHR = VkAccessFlags2; +typealias VkAccessFlagBits2KHR = VkAccessFlagBits2; +typealias VkMemoryBarrier2KHR = VkMemoryBarrier2; +typealias VkBufferMemoryBarrier2KHR = VkBufferMemoryBarrier2; +typealias VkImageMemoryBarrier2KHR = VkImageMemoryBarrier2; +typealias VkDependencyInfoKHR = VkDependencyInfo; +typealias VkSubmitInfo2KHR = VkSubmitInfo2; +typealias VkSemaphoreSubmitInfoKHR = VkSemaphoreSubmitInfo; +typealias VkCommandBufferSubmitInfoKHR = VkCommandBufferSubmitInfo; +typealias VkSubmitFlagBitsKHR = VkSubmitFlagBits; +typealias VkSubmitFlagsKHR = VkSubmitFlags; +typealias VkPhysicalDeviceSynchronization2FeaturesKHR = VkPhysicalDeviceSynchronization2Features; + +typealias PFN_vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2; +typealias PFN_vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2; +typealias PFN_vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2; +typealias PFN_vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2; +typealias PFN_vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2; +typealias PFN_vkQueueSubmit2KHR = PFN_vkQueueSubmit2; + +static { public const let VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION = 1; } +static { public const let VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME = "VK_EXT_descriptor_buffer"; } + +[CRepr] struct VkPhysicalDeviceDescriptorBufferPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 combinedImageSamplerDescriptorSingleArray = false; + public VkBool32 bufferlessPushDescriptors = false; + public VkBool32 allowSamplerImageViewPostSubmitCreation = false; + public VkDeviceSize descriptorBufferOffsetAlignment = default; + public uint32 maxDescriptorBufferBindings = 0; + public uint32 maxResourceDescriptorBufferBindings = 0; + public uint32 maxSamplerDescriptorBufferBindings = 0; + public uint32 maxEmbeddedImmutableSamplerBindings = 0; + public uint32 maxEmbeddedImmutableSamplers = 0; + public c_size bufferCaptureReplayDescriptorDataSize = 0; + public c_size imageCaptureReplayDescriptorDataSize = 0; + public c_size imageViewCaptureReplayDescriptorDataSize = 0; + public c_size samplerCaptureReplayDescriptorDataSize = 0; + public c_size accelerationStructureCaptureReplayDescriptorDataSize = 0; + public c_size samplerDescriptorSize = 0; + public c_size combinedImageSamplerDescriptorSize = 0; + public c_size sampledImageDescriptorSize = 0; + public c_size storageImageDescriptorSize = 0; + public c_size uniformTexelBufferDescriptorSize = 0; + public c_size robustUniformTexelBufferDescriptorSize = 0; + public c_size storageTexelBufferDescriptorSize = 0; + public c_size robustStorageTexelBufferDescriptorSize = 0; + public c_size uniformBufferDescriptorSize = 0; + public c_size robustUniformBufferDescriptorSize = 0; + public c_size storageBufferDescriptorSize = 0; + public c_size robustStorageBufferDescriptorSize = 0; + public c_size inputAttachmentDescriptorSize = 0; + public c_size accelerationStructureDescriptorSize = 0; + public VkDeviceSize maxSamplerDescriptorBufferRange = default; + public VkDeviceSize maxResourceDescriptorBufferRange = default; + public VkDeviceSize samplerDescriptorBufferAddressSpaceSize = default; + public VkDeviceSize resourceDescriptorBufferAddressSpaceSize = default; + public VkDeviceSize descriptorBufferAddressSpaceSize = default; +} + +[CRepr] struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size combinedImageSamplerDensityMapDescriptorSize = 0; +} + +[CRepr] struct VkPhysicalDeviceDescriptorBufferFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 descriptorBuffer = false; + public VkBool32 descriptorBufferCaptureReplay = false; + public VkBool32 descriptorBufferImageLayoutIgnored = false; + public VkBool32 descriptorBufferPushDescriptors = false; + + public this(void* pNext, VkBool32 descriptorBuffer, VkBool32 descriptorBufferCaptureReplay, VkBool32 descriptorBufferImageLayoutIgnored, VkBool32 descriptorBufferPushDescriptors) : this() + { + this.pNext = pNext; + this.descriptorBuffer = descriptorBuffer; + this.descriptorBufferCaptureReplay = descriptorBufferCaptureReplay; + this.descriptorBufferImageLayoutIgnored = descriptorBufferImageLayoutIgnored; + this.descriptorBufferPushDescriptors = descriptorBufferPushDescriptors; + } +} + +[CRepr] struct VkDescriptorAddressInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddress address = default; + public VkDeviceSize range = default; + public VkFormat format = default; + + public this(void* pNext, VkDeviceAddress address, VkDeviceSize range, VkFormat format) : this() + { + this.pNext = pNext; + this.address = address; + this.range = range; + this.format = format; + } +} + +[CRepr] struct VkDescriptorBufferBindingInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddress address = default; + public VkBufferUsageFlags usage = default; + + public this(void* pNext, VkDeviceAddress address, VkBufferUsageFlags usage = default) : this() + { + this.pNext = pNext; + this.address = address; + this.usage = usage; + } +} + +[CRepr] struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + + public this(void* pNext, VkBuffer buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr, Union] struct VkDescriptorDataEXT : this() +{ + public VkSampler* pSampler = null; + public VkDescriptorImageInfo* pCombinedImageSampler = null; + public VkDescriptorImageInfo* pInputAttachmentImage = null; + public VkDescriptorImageInfo* pSampledImage = null; + public VkDescriptorImageInfo* pStorageImage = null; + public VkDescriptorAddressInfoEXT* pUniformTexelBuffer = null; + public VkDescriptorAddressInfoEXT* pStorageTexelBuffer = null; + public VkDescriptorAddressInfoEXT* pUniformBuffer = null; + public VkDescriptorAddressInfoEXT* pStorageBuffer = null; + public VkDeviceAddress accelerationStructure = default; + + public this(VkSampler* pSampler, VkDescriptorImageInfo* pCombinedImageSampler, VkDescriptorImageInfo* pInputAttachmentImage, VkDescriptorImageInfo* pSampledImage, VkDescriptorImageInfo* pStorageImage, VkDescriptorAddressInfoEXT* pUniformTexelBuffer, VkDescriptorAddressInfoEXT* pStorageTexelBuffer, VkDescriptorAddressInfoEXT* pUniformBuffer, VkDescriptorAddressInfoEXT* pStorageBuffer, VkDeviceAddress accelerationStructure) : this() + { + this.pSampler = pSampler; + this.pCombinedImageSampler = pCombinedImageSampler; + this.pInputAttachmentImage = pInputAttachmentImage; + this.pSampledImage = pSampledImage; + this.pStorageImage = pStorageImage; + this.pUniformTexelBuffer = pUniformTexelBuffer; + this.pStorageTexelBuffer = pStorageTexelBuffer; + this.pUniformBuffer = pUniformBuffer; + this.pStorageBuffer = pStorageBuffer; + this.accelerationStructure = accelerationStructure; + } +} + +[CRepr] struct VkDescriptorGetInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorType type = default; + public VkDescriptorDataEXT data = default; + + public this(void* pNext, VkDescriptorType type, VkDescriptorDataEXT data) : this() + { + this.pNext = pNext; + this.type = type; + this.data = data; + } +} + +[CRepr] struct VkBufferCaptureDescriptorDataInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuffer buffer = null; + + public this(void* pNext, VkBuffer buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkImageCaptureDescriptorDataInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImage image = null; + + public this(void* pNext, VkImage image) : this() + { + this.pNext = pNext; + this.image = image; + } +} + +[CRepr] struct VkImageViewCaptureDescriptorDataInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView imageView = null; + + public this(void* pNext, VkImageView imageView) : this() + { + this.pNext = pNext; + this.imageView = imageView; + } +} + +[CRepr] struct VkSamplerCaptureDescriptorDataInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSampler sampler = null; + + public this(void* pNext, VkSampler sampler) : this() + { + this.pNext = pNext; + this.sampler = sampler; + } +} + +[CRepr] struct VkOpaqueCaptureDescriptorDataCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public void* opaqueCaptureDescriptorData = null; + + public this(void* pNext, void* opaqueCaptureDescriptorData) : this() + { + this.pNext = pNext; + this.opaqueCaptureDescriptorData = opaqueCaptureDescriptorData; + } +} + +[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_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); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, VkBufferCaptureDescriptorDataInfoEXT* pInfo, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, VkImageCaptureDescriptorDataInfoEXT* pInfo, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, VkImageViewCaptureDescriptorDataInfoEXT* pInfo, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, VkSamplerCaptureDescriptorDataInfoEXT* pInfo, out void pData); + +[CRepr] struct VkAccelerationStructureCaptureDescriptorDataInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccelerationStructureKHR accelerationStructure = null; + public VkAccelerationStructureNV accelerationStructureNV = null; + + public this(void* pNext = null, VkAccelerationStructureKHR accelerationStructure = null, VkAccelerationStructureNV accelerationStructureNV = null) : this() + { + this.pNext = pNext; + this.accelerationStructure = accelerationStructure; + this.accelerationStructureNV = accelerationStructureNV; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, out void pData); + +static { public const let VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION = 1; } +static { public const let VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME = "VK_EXT_graphics_pipeline_library"; } + +[CRepr] struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 graphicsPipelineLibrary = false; + + public this(void* pNext, VkBool32 graphicsPipelineLibrary) : this() + { + this.pNext = pNext; + this.graphicsPipelineLibrary = graphicsPipelineLibrary; + } +} + +[CRepr] struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 graphicsPipelineLibraryFastLinking = false; + public VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration = false; +} + +[CRepr] struct VkGraphicsPipelineLibraryCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkGraphicsPipelineLibraryFlagsEXT flags = default; + + public this(void* pNext, VkGraphicsPipelineLibraryFlagsEXT flags) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[AllowDuplicates] enum VkGraphicsPipelineLibraryFlagBitsEXT : int32 +{ + [NoShow] VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 1 << 0, + [NoShow] VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 1 << 1, + [NoShow] VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 1 << 2, + [NoShow] VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 1 << 3, + // pretty names + VertexInputInterfaceEXT = 1 << 0, + PreRasterizationShadersEXT = 1 << 1, + FragmentShaderEXT = 1 << 2, + FragmentOutputInterfaceEXT = 1 << 3, +} + +typealias VkGraphicsPipelineLibraryFlagsEXT = VkGraphicsPipelineLibraryFlagBitsEXT; + +[AllowDuplicates] enum VkPipelineLayoutCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 1 << 1, + // pretty names + IndependentSetsEXT = 1 << 1, +} + +static { public const let VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION = 1; } +static { public const let VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME = "VK_AMD_shader_early_and_late_fragment_tests"; } + +[CRepr] struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderEarlyAndLateFragmentTests = false; + + public this(void* pNext, VkBool32 shaderEarlyAndLateFragmentTests) : this() + { + this.pNext = pNext; + this.shaderEarlyAndLateFragmentTests = shaderEarlyAndLateFragmentTests; + } +} + +static { public const let VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION = 1; } +static { public const let VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME = "VK_KHR_fragment_shader_barycentric"; } + +[CRepr] struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentShaderBarycentric = false; + + public this(void* pNext, VkBool32 fragmentShaderBarycentric) : this() + { + this.pNext = pNext; + this.fragmentShaderBarycentric = fragmentShaderBarycentric; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 triStripVertexOrderIndependentOfProvokingVertex = false; +} + +static { public const let VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME = "VK_KHR_shader_subgroup_uniform_control_flow"; } + +[CRepr] struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderSubgroupUniformControlFlow = false; + + public this(void* pNext, VkBool32 shaderSubgroupUniformControlFlow) : this() + { + this.pNext = pNext; + this.shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow; + } +} + +static { public const let VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME = "VK_KHR_zero_initialize_workgroup_memory"; } + +typealias VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +static { public const let VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION = 1; } +static { public const let VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME = "VK_NV_fragment_shading_rate_enums"; } + +[CRepr] struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentShadingRateEnums = false; + public VkBool32 supersampleFragmentShadingRates = false; + public VkBool32 noInvocationFragmentShadingRates = false; + + public this(void* pNext, VkBool32 fragmentShadingRateEnums, VkBool32 supersampleFragmentShadingRates, VkBool32 noInvocationFragmentShadingRates) : this() + { + this.pNext = pNext; + this.fragmentShadingRateEnums = fragmentShadingRateEnums; + this.supersampleFragmentShadingRates = supersampleFragmentShadingRates; + this.noInvocationFragmentShadingRates = noInvocationFragmentShadingRates; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSampleCountFlagBits maxFragmentShadingRateInvocationCount = default; +} + +[CRepr] struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFragmentShadingRateTypeNV shadingRateType = default; + public VkFragmentShadingRateNV shadingRate = default; + public VkFragmentShadingRateCombinerOpKHR[2] combinerOps = .(); + + public this(void* pNext, VkFragmentShadingRateTypeNV shadingRateType, VkFragmentShadingRateNV shadingRate, VkFragmentShadingRateCombinerOpKHR[2] combinerOps) : this() + { + this.pNext = pNext; + this.shadingRateType = shadingRateType; + this.shadingRate = shadingRate; + this.combinerOps = combinerOps; + } +} + +[AllowDuplicates] enum VkFragmentShadingRateNV : int32 +{ + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + [NoShow] VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, + [NoShow] VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, + [NoShow] VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, + [NoShow] VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, + [NoShow] VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, + [NoShow] VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, + // pretty names + _1_InvocationPerPixelNV = 0, + _1_InvocationPer1x2_PixelsNV = 1, + _1_InvocationPer2x1_PixelsNV = 4, + _1_InvocationPer2x2_PixelsNV = 5, + _1_InvocationPer2x4_PixelsNV = 6, + _1_InvocationPer4x2_PixelsNV = 9, + _1_InvocationPer4x4_PixelsNV = 10, + _2_InvocationsPerPixelNV = 11, + _4_InvocationsPerPixelNV = 12, + _8_InvocationsPerPixelNV = 13, + _16_InvocationsPerPixelNV = 14, + NoInvocationsNV = 15, +} + +[AllowDuplicates] enum VkFragmentShadingRateTypeNV : int32 +{ + [NoShow] VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, + [NoShow] VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, + // pretty names + FragmentSizeNV = 0, + EnumsNV = 1, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, VkFragmentShadingRateCombinerOpKHR[2] combinerOps); + +static { public const let VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION = 1; } +static { public const let VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME = "VK_NV_ray_tracing_motion_blur"; } + +[CRepr] struct VkAccelerationStructureGeometryMotionTrianglesDataNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceOrHostAddressConstKHR vertexData = default; + + public this(void* pNext, VkDeviceOrHostAddressConstKHR vertexData) : this() + { + this.pNext = pNext; + this.vertexData = vertexData; + } +} + +[CRepr] struct VkAccelerationStructureMotionInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxInstances = 0; + public VkAccelerationStructureMotionInfoFlagsNV flags = default; + + public this(void* pNext, uint32 maxInstances, VkAccelerationStructureMotionInfoFlagsNV flags = default) : this() + { + this.pNext = pNext; + this.maxInstances = maxInstances; + this.flags = flags; + } +} + +[CRepr] struct VkAccelerationStructureMotionInstanceNV : this() +{ + public VkAccelerationStructureMotionInstanceTypeNV type = default; + public VkAccelerationStructureMotionInstanceFlagsNV flags = default; + public VkAccelerationStructureMotionInstanceDataNV data = default; + + public this(VkAccelerationStructureMotionInstanceTypeNV type, VkAccelerationStructureMotionInstanceFlagsNV flags, VkAccelerationStructureMotionInstanceDataNV data) : this() + { + this.type = type; + this.flags = flags; + this.data = data; + } +} + +[CRepr, Union] struct VkAccelerationStructureMotionInstanceDataNV : this() +{ + public VkAccelerationStructureInstanceKHR staticInstance = default; + public VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance = default; + public VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance = default; + + public this(VkAccelerationStructureInstanceKHR staticInstance, VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance, VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance) : this() + { + this.staticInstance = staticInstance; + this.matrixMotionInstance = matrixMotionInstance; + this.srtMotionInstance = srtMotionInstance; + } +} + +[CRepr] struct VkAccelerationStructureMatrixMotionInstanceNV : this() +{ + + public VkTransformMatrixKHR transformT0 = default; + public VkTransformMatrixKHR transformT1 = default; + [Bitfield(.Public, .Bits(24), "instanceCustomIndex")] + [Bitfield(.Public, .Bits(8), "mask")] + private uint32 __bitfields_mask = 0; + [Bitfield(.Public, .Bits(24), "instanceShaderBindingTableRecordOffset")] + [Bitfield(.Public, .Bits(8), "flags")] + private VkFlags __bitfields_flags = 0; + public uint64 accelerationStructureReference = 0; + + public this(VkTransformMatrixKHR transformT0, VkTransformMatrixKHR transformT1, uint32 instanceCustomIndex, uint32 mask, uint32 instanceShaderBindingTableRecordOffset, VkFlags flags, uint64 accelerationStructureReference) : this() + { + this.transformT0 = transformT0; + this.transformT1 = transformT1; + this.instanceCustomIndex = instanceCustomIndex; + this.mask = mask; + this.instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset; + this.flags = flags; + this.accelerationStructureReference = accelerationStructureReference; + } +} + +[CRepr] struct VkAccelerationStructureSRTMotionInstanceNV : this() +{ + + public VkSRTDataNV transformT0 = default; + public VkSRTDataNV transformT1 = default; + [Bitfield(.Public, .Bits(24), "instanceCustomIndex")] + [Bitfield(.Public, .Bits(8), "mask")] + private uint32 __bitfields_mask = 0; + [Bitfield(.Public, .Bits(24), "instanceShaderBindingTableRecordOffset")] + [Bitfield(.Public, .Bits(8), "flags")] + private VkFlags __bitfields_flags = 0; + public uint64 accelerationStructureReference = 0; + + public this(VkSRTDataNV transformT0, VkSRTDataNV transformT1, uint32 instanceCustomIndex, uint32 mask, uint32 instanceShaderBindingTableRecordOffset, VkFlags flags, uint64 accelerationStructureReference) : this() + { + this.transformT0 = transformT0; + this.transformT1 = transformT1; + this.instanceCustomIndex = instanceCustomIndex; + this.mask = mask; + this.instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset; + this.flags = flags; + this.accelerationStructureReference = accelerationStructureReference; + } +} + +[CRepr] struct VkSRTDataNV : this() +{ + public float sx = 0; + public float a = 0; + public float b = 0; + public float pvx = 0; + public float sy = 0; + public float c = 0; + public float pvy = 0; + public float sz = 0; + public float pvz = 0; + public float qx = 0; + public float qy = 0; + public float qz = 0; + public float qw = 0; + public float tx = 0; + public float ty = 0; + public float tz = 0; + + public this(float sx, float a, float b, float pvx, float sy, float c, float pvy, float sz, float pvz, float qx, float qy, float qz, float qw, float tx, float ty, float tz) : this() + { + this.sx = sx; + this.a = a; + this.b = b; + this.pvx = pvx; + this.sy = sy; + this.c = c; + this.pvy = pvy; + this.sz = sz; + this.pvz = pvz; + this.qx = qx; + this.qy = qy; + this.qz = qz; + this.qw = qw; + this.tx = tx; + this.ty = ty; + this.tz = tz; + } +} + +[AllowDuplicates] enum VkAccelerationStructureMotionInstanceTypeNV : int32 +{ + [NoShow] VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, + [NoShow] VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, + [NoShow] VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, + // pretty names + StaticNV = 0, + MatrixMotionNV = 1, + SrtMotionNV = 2, +} + +[CRepr] struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingMotionBlur = false; + public VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect = false; + + public this(void* pNext, VkBool32 rayTracingMotionBlur, VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect) : this() + { + this.pNext = pNext; + this.rayTracingMotionBlur = rayTracingMotionBlur; + this.rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect; + } +} + +typealias VkAccelerationStructureMotionInfoFlagsNV = VkFlags; +typealias VkAccelerationStructureMotionInstanceFlagsNV = VkFlags; + +static { public const let VK_EXT_MESH_SHADER_SPEC_VERSION = 1; } +static { public const let VK_EXT_MESH_SHADER_EXTENSION_NAME = "VK_EXT_mesh_shader"; } + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32 drawCount, uint32 stride); + +[CRepr] struct VkPhysicalDeviceMeshShaderFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 taskShader = false; + public VkBool32 meshShader = false; + public VkBool32 multiviewMeshShader = false; + public VkBool32 primitiveFragmentShadingRateMeshShader = false; + public VkBool32 meshShaderQueries = false; + + public this(void* pNext, VkBool32 taskShader, VkBool32 meshShader, VkBool32 multiviewMeshShader, VkBool32 primitiveFragmentShadingRateMeshShader, VkBool32 meshShaderQueries) : this() + { + this.pNext = pNext; + this.taskShader = taskShader; + this.meshShader = meshShader; + this.multiviewMeshShader = multiviewMeshShader; + this.primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader; + this.meshShaderQueries = meshShaderQueries; + } +} + +[CRepr] struct VkPhysicalDeviceMeshShaderPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxTaskWorkGroupTotalCount = 0; + public uint32[3] maxTaskWorkGroupCount = .(); + public uint32 maxTaskWorkGroupInvocations = 0; + public uint32[3] maxTaskWorkGroupSize = .(); + public uint32 maxTaskPayloadSize = 0; + public uint32 maxTaskSharedMemorySize = 0; + public uint32 maxTaskPayloadAndSharedMemorySize = 0; + public uint32 maxMeshWorkGroupTotalCount = 0; + public uint32[3] maxMeshWorkGroupCount = .(); + public uint32 maxMeshWorkGroupInvocations = 0; + public uint32[3] maxMeshWorkGroupSize = .(); + public uint32 maxMeshSharedMemorySize = 0; + public uint32 maxMeshPayloadAndSharedMemorySize = 0; + public uint32 maxMeshOutputMemorySize = 0; + public uint32 maxMeshPayloadAndOutputMemorySize = 0; + public uint32 maxMeshOutputComponents = 0; + public uint32 maxMeshOutputVertices = 0; + public uint32 maxMeshOutputPrimitives = 0; + public uint32 maxMeshOutputLayers = 0; + public uint32 maxMeshMultiviewViewCount = 0; + public uint32 meshOutputPerVertexGranularity = 0; + public uint32 meshOutputPerPrimitiveGranularity = 0; + public uint32 maxPreferredTaskWorkGroupInvocations = 0; + public uint32 maxPreferredMeshWorkGroupInvocations = 0; + public VkBool32 prefersLocalInvocationVertexOutput = false; + public VkBool32 prefersLocalInvocationPrimitiveOutput = false; + public VkBool32 prefersCompactVertexOutput = false; + public VkBool32 prefersCompactPrimitiveOutput = false; +} + +[CRepr] struct VkDrawMeshTasksIndirectCommandEXT : this() +{ + public uint32 groupCountX = 0; + public uint32 groupCountY = 0; + public uint32 groupCountZ = 0; + + public this(uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ) : this() + { + this.groupCountX = groupCountX; + this.groupCountY = groupCountY; + this.groupCountZ = groupCountZ; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32 maxDrawCount, uint32 stride); + +static { public const let VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION = 1; } +static { public const let VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME = "VK_EXT_ycbcr_2plane_444_formats"; } + +[CRepr] struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 ycbcr2plane444Formats = false; + + public this(void* pNext, VkBool32 ycbcr2plane444Formats) : this() + { + this.pNext = pNext; + this.ycbcr2plane444Formats = ycbcr2plane444Formats; + } +} + +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION = 1; } +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME = "VK_EXT_fragment_density_map2"; } + +[CRepr] struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentDensityMapDeferred = false; + + public this(void* pNext, VkBool32 fragmentDensityMapDeferred) : this() + { + this.pNext = pNext; + this.fragmentDensityMapDeferred = fragmentDensityMapDeferred; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 subsampledLoads = false; + public VkBool32 subsampledCoarseReconstructionEarlyAccess = false; + public uint32 maxSubsampledArrayLayers = 0; + public uint32 maxDescriptorSetSubsampledSamplers = 0; +} + +static { public const let VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION = 2; } +static { public const let VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME = "VK_QCOM_rotated_copy_commands"; } + +[CRepr] struct VkCopyCommandTransformInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceTransformFlagBitsKHR transform = default; + + public this(void* pNext, VkSurfaceTransformFlagBitsKHR transform) : this() + { + this.pNext = pNext; + this.transform = transform; + } +} + +static { public const let VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME = "VK_EXT_image_robustness"; } + +typealias VkPhysicalDeviceImageRobustnessFeaturesEXT = VkPhysicalDeviceImageRobustnessFeatures; + +static { public const let VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION = 1; } +static { public const let VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME = "VK_KHR_workgroup_memory_explicit_layout"; } + +[CRepr] struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 workgroupMemoryExplicitLayout = false; + public VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout = false; + public VkBool32 workgroupMemoryExplicitLayout8BitAccess = false; + public VkBool32 workgroupMemoryExplicitLayout16BitAccess = false; + + public this(void* pNext, VkBool32 workgroupMemoryExplicitLayout, VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout, VkBool32 workgroupMemoryExplicitLayout8BitAccess, VkBool32 workgroupMemoryExplicitLayout16BitAccess) : this() + { + this.pNext = pNext; + this.workgroupMemoryExplicitLayout = workgroupMemoryExplicitLayout; + this.workgroupMemoryExplicitLayoutScalarBlockLayout = workgroupMemoryExplicitLayoutScalarBlockLayout; + this.workgroupMemoryExplicitLayout8BitAccess = workgroupMemoryExplicitLayout8BitAccess; + this.workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess; + } +} + +static { public const let VK_KHR_COPY_COMMANDS_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME = "VK_KHR_copy_commands2"; } + +typealias VkCopyBufferInfo2KHR = VkCopyBufferInfo2; +typealias VkCopyImageInfo2KHR = VkCopyImageInfo2; +typealias VkCopyBufferToImageInfo2KHR = VkCopyBufferToImageInfo2; +typealias VkCopyImageToBufferInfo2KHR = VkCopyImageToBufferInfo2; +typealias VkBlitImageInfo2KHR = VkBlitImageInfo2; +typealias VkResolveImageInfo2KHR = VkResolveImageInfo2; +typealias VkBufferCopy2KHR = VkBufferCopy2; +typealias VkImageCopy2KHR = VkImageCopy2; +typealias VkImageBlit2KHR = VkImageBlit2; +typealias VkBufferImageCopy2KHR = VkBufferImageCopy2; +typealias VkImageResolve2KHR = VkImageResolve2; + +typealias PFN_vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2; +typealias PFN_vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2; +typealias PFN_vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2; +typealias PFN_vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2; +typealias PFN_vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2; +typealias PFN_vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2; + +static { public const let VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME = "VK_EXT_image_compression_control"; } + +[CRepr] struct VkPhysicalDeviceImageCompressionControlFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imageCompressionControl = false; + + public this(void* pNext, VkBool32 imageCompressionControl) : this() + { + this.pNext = pNext; + this.imageCompressionControl = imageCompressionControl; + } +} + +[CRepr] struct VkImageCompressionControlEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCompressionFlagsEXT flags = default; + public uint32 compressionControlPlaneCount = 0; + public VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags = null; + public Span fixedRateFlags + { + get { return .(pFixedRateFlags, (.)compressionControlPlaneCount); } + set mut { pFixedRateFlags = value.Ptr; compressionControlPlaneCount = (.)value.Length; } + } + + public this(void* pNext, VkImageCompressionFlagsEXT flags, Span fixedRateFlags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.fixedRateFlags = fixedRateFlags; + } +} + +[CRepr] struct VkImageCompressionPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCompressionFlagsEXT imageCompressionFlags = default; + public VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags = default; +} + +[AllowDuplicates] enum VkImageCompressionFlagBitsEXT : int32 +{ + [NoShow] VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 1 << 0, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 1 << 1, + [NoShow] VK_IMAGE_COMPRESSION_DISABLED_EXT = 1 << 2, + // pretty names + DefaultEXT = 0, + FixedRateDefaultEXT = 1 << 0, + FixedRateExplicitEXT = 1 << 1, + DisabledEXT = 1 << 2, +} + +typealias VkImageCompressionFlagsEXT = VkImageCompressionFlagBitsEXT; + +[AllowDuplicates] enum VkImageCompressionFixedRateFlagBitsEXT : int32 +{ + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 1 << 0, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 1 << 1, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 1 << 2, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 1 << 3, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 1 << 4, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 1 << 5, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 1 << 6, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 1 << 7, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 1 << 8, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 1 << 9, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 1 << 10, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 1 << 11, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 1 << 12, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 1 << 13, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 1 << 14, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 1 << 15, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 1 << 16, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 1 << 17, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 1 << 18, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 1 << 19, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 1 << 20, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 1 << 21, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 1 << 22, + [NoShow] VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 1 << 23, + // pretty names + NoneEXT = 0, + _1bpcEXT = 1 << 0, + _2bpcEXT = 1 << 1, + _3bpcEXT = 1 << 2, + _4bpcEXT = 1 << 3, + _5bpcEXT = 1 << 4, + _6bpcEXT = 1 << 5, + _7bpcEXT = 1 << 6, + _8bpcEXT = 1 << 7, + _9bpcEXT = 1 << 8, + _10bpcEXT = 1 << 9, + _11bpcEXT = 1 << 10, + _12bpcEXT = 1 << 11, + _13bpcEXT = 1 << 12, + _14bpcEXT = 1 << 13, + _15bpcEXT = 1 << 14, + _16bpcEXT = 1 << 15, + _17bpcEXT = 1 << 16, + _18bpcEXT = 1 << 17, + _19bpcEXT = 1 << 18, + _20bpcEXT = 1 << 19, + _21bpcEXT = 1 << 20, + _22bpcEXT = 1 << 21, + _23bpcEXT = 1 << 22, + _24bpcEXT = 1 << 23, +} + +typealias VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagBitsEXT; + +static { public const let VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION = 2; } +static { public const let VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME = "VK_EXT_attachment_feedback_loop_layout"; } + +[CRepr] struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 attachmentFeedbackLoopLayout = false; + + public this(void* pNext, VkBool32 attachmentFeedbackLoopLayout) : this() + { + this.pNext = pNext; + this.attachmentFeedbackLoopLayout = attachmentFeedbackLoopLayout; + } +} + +static { public const let VK_EXT_4444_FORMATS_SPEC_VERSION = 1; } +static { public const let VK_EXT_4444_FORMATS_EXTENSION_NAME = "VK_EXT_4444_formats"; } + +[CRepr] struct VkPhysicalDevice4444FormatsFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 formatA4R4G4B4 = false; + public VkBool32 formatA4B4G4R4 = false; + + public this(void* pNext, VkBool32 formatA4R4G4B4, VkBool32 formatA4B4G4R4) : this() + { + this.pNext = pNext; + this.formatA4R4G4B4 = formatA4R4G4B4; + this.formatA4B4G4R4 = formatA4B4G4R4; + } +} + +static { public const let VK_EXT_DEVICE_FAULT_SPEC_VERSION = 2; } +static { public const let VK_EXT_DEVICE_FAULT_EXTENSION_NAME = "VK_EXT_device_fault"; } + +[CRepr] struct VkPhysicalDeviceFaultFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceFault = false; + public VkBool32 deviceFaultVendorBinary = false; + + public this(void* pNext, VkBool32 deviceFault, VkBool32 deviceFaultVendorBinary) : this() + { + this.pNext = pNext; + this.deviceFault = deviceFault; + this.deviceFaultVendorBinary = deviceFaultVendorBinary; + } +} + +[CRepr] struct VkDeviceFaultCountsEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 addressInfoCount = 0; + public uint32 vendorInfoCount = 0; + public VkDeviceSize vendorBinarySize = default; // Specified in bytes + + public this(void* pNext = null, uint32 addressInfoCount = 0, uint32 vendorInfoCount = 0, VkDeviceSize vendorBinarySize = default) : this() + { + this.pNext = pNext; + this.addressInfoCount = addressInfoCount; + this.vendorInfoCount = vendorInfoCount; + this.vendorBinarySize = vendorBinarySize; + } +} + +[CRepr] struct VkDeviceFaultInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); // Free-form description of the fault + public VkDeviceFaultAddressInfoEXT* pAddressInfos = null; + public VkDeviceFaultVendorInfoEXT* pVendorInfos = null; + public void* pVendorBinaryData = null; +} + +[CRepr] struct VkDeviceFaultAddressInfoEXT : this() +{ + public VkDeviceFaultAddressTypeEXT addressType = default; + public VkDeviceAddress reportedAddress = default; + public VkDeviceSize addressPrecision = default; + + public this(VkDeviceFaultAddressTypeEXT addressType, VkDeviceAddress reportedAddress, VkDeviceSize addressPrecision) : this() + { + this.addressType = addressType; + this.reportedAddress = reportedAddress; + this.addressPrecision = addressPrecision; + } +} + +[AllowDuplicates] enum VkDeviceFaultAddressTypeEXT : int32 +{ + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, // Currently unused + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, + [NoShow] VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, + // pretty names + NoneEXT = 0, // Currently unused + ReadInvalidEXT = 1, + WriteInvalidEXT = 2, + ExecuteInvalidEXT = 3, + InstructionPointerUnknownEXT = 4, + InstructionPointerInvalidEXT = 5, + InstructionPointerFaultEXT = 6, +} + +[CRepr] struct VkDeviceFaultVendorInfoEXT : this() +{ + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); // Free-form description of the fault + public uint64 vendorFaultCode = 0; + public uint64 vendorFaultData = 0; + + public this(char8[VK_MAX_DESCRIPTION_SIZE] description, uint64 vendorFaultCode, uint64 vendorFaultData) : this() + { + this.description = description; + this.vendorFaultCode = vendorFaultCode; + this.vendorFaultData = vendorFaultData; + } +} + +[AllowDuplicates] enum VkDeviceFaultVendorBinaryHeaderVersionEXT : int32 +{ + [NoShow] VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, + // pretty names + OneEXT = 1, +} + +[CRepr] struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT : this() +{ + + public uint32 headerSize = 0; + public VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion = default; + public uint32 vendorID = 0; + public uint32 deviceID = 0; + public uint32 driverVersion = 0; + public uint8[VK_UUID_SIZE] pipelineCacheUUID = .(); + public uint32 applicationNameOffset = 0; + public uint32 applicationVersion = 0; + public uint32 engineNameOffset = 0; + public uint32 engineVersion = 0; + public uint32 apiVersion = 0; + + public this(uint32 headerSize, VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion, uint32 vendorID, uint32 deviceID, uint32 driverVersion, uint8[VK_UUID_SIZE] pipelineCacheUUID, uint32 applicationNameOffset, uint32 applicationVersion, uint32 engineNameOffset, uint32 engineVersion, uint32 apiVersion) : this() + { + this.headerSize = headerSize; + this.headerVersion = headerVersion; + this.vendorID = vendorID; + this.deviceID = deviceID; + this.driverVersion = driverVersion; + this.pipelineCacheUUID = pipelineCacheUUID; + this.applicationNameOffset = applicationNameOffset; + this.applicationVersion = applicationVersion; + this.engineNameOffset = engineNameOffset; + this.engineVersion = engineVersion; + this.apiVersion = apiVersion; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeviceFaultInfoEXT(VkDevice device, out VkDeviceFaultCountsEXT pFaultCounts, out VkDeviceFaultInfoEXT pFaultInfo); + +static { public const let VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION = 1; } +static { public const let VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME = "VK_ARM_rasterization_order_attachment_access"; } + +typealias VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +static { public const let VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION = 1; } +static { public const let VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME = "VK_EXT_rgba10x6_formats"; } + +[CRepr] struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 formatRgba10x6WithoutYCbCrSampler = false; + + public this(void* pNext, VkBool32 formatRgba10x6WithoutYCbCrSampler) : this() + { + this.pNext = pNext; + this.formatRgba10x6WithoutYCbCrSampler = formatRgba10x6WithoutYCbCrSampler; + } +} + +static { public const let VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION = 1; } +static { public const let VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME = "VK_NV_acquire_winrt_display"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32 deviceRelativeId, out VkDisplayKHR pDisplay); + +static { public const let VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME = "VK_EXT_directfb_surface"; } + +typealias VkDirectFBSurfaceCreateFlagsEXT = VkFlags; + +[CRepr] struct VkDirectFBSurfaceCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDirectFBSurfaceCreateFlagsEXT flags = default; + public IDirectFB* dfb = null; + public IDirectFBSurface* surface = null; + + public this(void* pNext, VkDirectFBSurfaceCreateFlagsEXT flags, IDirectFB* dfb, IDirectFBSurface* surface) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dfb = dfb; + this.surface = surface; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDirectFBSurfaceEXT(VkInstance instance, VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out IDirectFB dfb); + +static { public const let VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION = 1; } +static { public const let VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME = "VK_VALVE_mutable_descriptor_type"; } + +typealias VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; +typealias VkMutableDescriptorTypeListVALVE = VkMutableDescriptorTypeListEXT; +typealias VkMutableDescriptorTypeCreateInfoVALVE = VkMutableDescriptorTypeCreateInfoEXT; + +static { public const let VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION = 2; } +static { public const let VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME = "VK_EXT_vertex_input_dynamic_state"; } + +[CRepr] struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 vertexInputDynamicState = false; + + public this(void* pNext, VkBool32 vertexInputDynamicState) : this() + { + this.pNext = pNext; + this.vertexInputDynamicState = vertexInputDynamicState; + } +} + +[CRepr] struct VkVertexInputBindingDescription2EXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 binding = 0; + public uint32 stride = 0; + public VkVertexInputRate inputRate = default; + public uint32 divisor = 0; + + public this(void* pNext, uint32 binding, uint32 stride, VkVertexInputRate inputRate, uint32 divisor) : this() + { + this.pNext = pNext; + this.binding = binding; + this.stride = stride; + this.inputRate = inputRate; + this.divisor = divisor; + } +} + +[CRepr] struct VkVertexInputAttributeDescription2EXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 location = 0; // location of the shader vertex attrib + public uint32 binding = 0; // Vertex buffer binding id + public VkFormat format = default; // format of source data + public uint32 offset = 0; // Offset of first element in bytes from base of vertex + + public this(void* pNext, uint32 location, uint32 binding, VkFormat format, uint32 offset) : this() + { + this.pNext = pNext; + this.location = location; + this.binding = binding; + this.format = format; + this.offset = offset; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32 vertexBindingDescriptionCount, VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32 vertexAttributeDescriptionCount, VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + +static { public const let VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION = 1; } +static { public const let VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME = "VK_EXT_physical_device_drm"; } + +[CRepr] struct VkPhysicalDeviceDrmPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hasPrimary = false; + public VkBool32 hasRender = false; + public int64 primaryMajor = 0; + public int64 primaryMinor = 0; + public int64 renderMajor = 0; + public int64 renderMinor = 0; +} + +static { public const let VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME = "VK_EXT_device_address_binding_report"; } + +[CRepr] struct VkPhysicalDeviceAddressBindingReportFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 reportAddressBinding = false; + + public this(void* pNext, VkBool32 reportAddressBinding) : this() + { + this.pNext = pNext; + this.reportAddressBinding = reportAddressBinding; + } +} + +[CRepr] struct VkDeviceAddressBindingCallbackDataEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddressBindingFlagsEXT flags = default; + public VkDeviceAddress baseAddress = default; + public VkDeviceSize size = default; + public VkDeviceAddressBindingTypeEXT bindingType = default; + + public this(void* pNext, VkDeviceAddressBindingFlagsEXT flags, VkDeviceAddress baseAddress, VkDeviceSize size, VkDeviceAddressBindingTypeEXT bindingType) : this() + { + this.pNext = pNext; + this.flags = flags; + this.baseAddress = baseAddress; + this.size = size; + this.bindingType = bindingType; + } +} + +typealias VkDeviceAddressBindingFlagsEXT = VkDeviceAddressBindingFlagBitsEXT; + +[AllowDuplicates] enum VkDeviceAddressBindingFlagBitsEXT : int32 +{ + [NoShow] VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 1 << 0, + // pretty names + InternalObjectEXT = 1 << 0, +} + +[AllowDuplicates] enum VkDeviceAddressBindingTypeEXT : int32 +{ + [NoShow] VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, + [NoShow] VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, + // pretty names + BindEXT = 0, + UnbindEXT = 1, +} + +static { public const let VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME = "VK_EXT_depth_clip_control"; } + +[CRepr] struct VkPhysicalDeviceDepthClipControlFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 depthClipControl = false; + + public this(void* pNext, VkBool32 depthClipControl) : this() + { + this.pNext = pNext; + this.depthClipControl = depthClipControl; + } +} + +[CRepr] struct VkPipelineViewportDepthClipControlCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 negativeOneToOne = false; + + public this(void* pNext, VkBool32 negativeOneToOne) : this() + { + this.pNext = pNext; + this.negativeOneToOne = negativeOneToOne; + } +} + +static { public const let VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION = 1; } +static { public const let VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME = "VK_EXT_primitive_topology_list_restart"; } + +[CRepr] struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 primitiveTopologyListRestart = false; + public VkBool32 primitiveTopologyPatchListRestart = false; + + public this(void* pNext, VkBool32 primitiveTopologyListRestart, VkBool32 primitiveTopologyPatchListRestart) : this() + { + this.pNext = pNext; + this.primitiveTopologyListRestart = primitiveTopologyListRestart; + this.primitiveTopologyPatchListRestart = primitiveTopologyPatchListRestart; + } +} + +static { public const let VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION = 2; } +static { public const let VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME = "VK_KHR_format_feature_flags2"; } + +typealias VkFormatFeatureFlags2KHR = VkFormatFeatureFlags2; +typealias VkFormatFeatureFlagBits2KHR = VkFormatFeatureFlagBits2; +typealias VkFormatProperties3KHR = VkFormatProperties3; + +static { public const let VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION = 1; } +static { public const let VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME = "VK_EXT_present_mode_fifo_latest_ready"; } + +typealias VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + +static { public const let VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_FUCHSIA_external_memory"; } + +[CRepr] struct VkImportMemoryZirconHandleInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + public zx_handle_t handle = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagBits handleType = default, zx_handle_t handle = default) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.handle = handle; + } +} + +[CRepr] struct VkMemoryZirconHandlePropertiesFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkMemoryGetZirconHandleInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.memory = memory; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryZirconHandleFUCHSIA(VkDevice device, VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, out zx_handle_t pZirconHandle); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, out VkMemoryZirconHandlePropertiesFUCHSIA pMemoryZirconHandleProperties); + +static { public const let VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1; } +static { public const let VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_FUCHSIA_external_semaphore"; } + +[CRepr] struct VkImportSemaphoreZirconHandleInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkSemaphoreImportFlags flags = default; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + public zx_handle_t zirconHandle = default; + + public this(void* pNext, VkSemaphore semaphore, VkSemaphoreImportFlags flags, VkExternalSemaphoreHandleTypeFlagBits handleType, zx_handle_t zirconHandle) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.flags = flags; + this.handleType = handleType; + this.zirconHandle = zirconHandle; + } +} + +[CRepr] struct VkSemaphoreGetZirconHandleInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore semaphore = null; + public VkExternalSemaphoreHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.semaphore = semaphore; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, out zx_handle_t pZirconHandle); + +static { public const let VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION = 2; } +static { public const let VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME = "VK_FUCHSIA_buffer_collection"; } + +struct VkBufferCollectionFUCHSIA : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkBufferCollectionCreateInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public zx_handle_t collectionToken = default; + + public this(void* pNext, zx_handle_t collectionToken) : this() + { + this.pNext = pNext; + this.collectionToken = collectionToken; + } +} + +[CRepr] struct VkImportMemoryBufferCollectionFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCollectionFUCHSIA collection = null; + public uint32 index = 0; + + public this(void* pNext, VkBufferCollectionFUCHSIA collection, uint32 index) : this() + { + this.pNext = pNext; + this.collection = collection; + this.index = index; + } +} + +[CRepr] struct VkBufferCollectionImageCreateInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCollectionFUCHSIA collection = null; + public uint32 index = 0; + + public this(void* pNext, VkBufferCollectionFUCHSIA collection, uint32 index) : this() + { + this.pNext = pNext; + this.collection = collection; + this.index = index; + } +} + +[CRepr] struct VkBufferConstraintsInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCreateInfo createInfo = default; + public VkFormatFeatureFlags requiredFormatFeatures = default; + public VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = default; + + public this(void* pNext, VkBufferCreateInfo createInfo, VkFormatFeatureFlags requiredFormatFeatures, VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints) : this() + { + this.pNext = pNext; + this.createInfo = createInfo; + this.requiredFormatFeatures = requiredFormatFeatures; + this.bufferCollectionConstraints = bufferCollectionConstraints; + } +} + +[CRepr] struct VkBufferCollectionBufferCreateInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBufferCollectionFUCHSIA collection = null; + public uint32 index = 0; + + public this(void* pNext, VkBufferCollectionFUCHSIA collection, uint32 index) : this() + { + this.pNext = pNext; + this.collection = collection; + this.index = index; + } +} + +[CRepr] struct VkBufferCollectionPropertiesFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; + public uint32 bufferCount = 0; + public uint32 createInfoIndex = 0; + public uint64 sysmemPixelFormat = 0; + public VkFormatFeatureFlags formatFeatures = default; + public VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex = default; + public VkComponentMapping samplerYcbcrConversionComponents = default; + public VkSamplerYcbcrModelConversion suggestedYcbcrModel = default; + public VkSamplerYcbcrRange suggestedYcbcrRange = default; + public VkChromaLocation suggestedXChromaOffset = default; + public VkChromaLocation suggestedYChromaOffset = default; +} + +typealias VkImageFormatConstraintsFlagsFUCHSIA = VkFlags; + +[CRepr] struct VkSysmemColorSpaceFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 colorSpace = 0; + + public this(void* pNext, uint32 colorSpace) : this() + { + this.pNext = pNext; + this.colorSpace = colorSpace; + } +} + +[AllowDuplicates] enum VkImageConstraintsInfoFlagBitsFUCHSIA : int32 +{ + [NoShow] VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 1 << 0, + [NoShow] VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 1 << 1, + [NoShow] VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 1 << 2, + [NoShow] VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 1 << 3, + [NoShow] VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 1 << 4, + // pretty names + CpuReadRarelyFUCHSIA = 1 << 0, + CpuReadOftenFUCHSIA = 1 << 1, + CpuWriteRarelyFUCHSIA = 1 << 2, + CpuWriteOftenFUCHSIA = 1 << 3, + ProtectedOptionalFUCHSIA = 1 << 4, +} + +typealias VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA; + +[CRepr] struct VkImageConstraintsInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 formatConstraintsCount = 0; + public VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints = null; + public Span formatConstraints + { + get { return .(pFormatConstraints, (.)formatConstraintsCount); } + set mut { pFormatConstraints = value.Ptr; formatConstraintsCount = (.)value.Length; } + } + public VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = default; + public VkImageConstraintsInfoFlagsFUCHSIA flags = default; + + public this(void* pNext, Span formatConstraints, VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints, VkImageConstraintsInfoFlagsFUCHSIA flags = default) : this() + { + this.pNext = pNext; + this.formatConstraints = formatConstraints; + this.bufferCollectionConstraints = bufferCollectionConstraints; + this.flags = flags; + } +} + +[CRepr] struct VkImageFormatConstraintsInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageCreateInfo imageCreateInfo = default; + public VkFormatFeatureFlags requiredFormatFeatures = default; + public VkImageFormatConstraintsFlagsFUCHSIA flags = default; + public uint64 sysmemPixelFormat = 0; + public uint32 colorSpaceCount = 0; + public VkSysmemColorSpaceFUCHSIA* pColorSpaces = null; + public Span colorSpaces + { + get { return .(pColorSpaces, (.)colorSpaceCount); } + set mut { pColorSpaces = value.Ptr; colorSpaceCount = (.)value.Length; } + } + + public this(void* pNext, VkImageCreateInfo imageCreateInfo, VkFormatFeatureFlags requiredFormatFeatures, VkImageFormatConstraintsFlagsFUCHSIA flags, uint64 sysmemPixelFormat, Span colorSpaces) : this() + { + this.pNext = pNext; + this.imageCreateInfo = imageCreateInfo; + this.requiredFormatFeatures = requiredFormatFeatures; + this.flags = flags; + this.sysmemPixelFormat = sysmemPixelFormat; + this.colorSpaces = colorSpaces; + } +} + +[CRepr] struct VkBufferCollectionConstraintsInfoFUCHSIA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 minBufferCount = 0; + public uint32 maxBufferCount = 0; + public uint32 minBufferCountForCamping = 0; + public uint32 minBufferCountForDedicatedSlack = 0; + public uint32 minBufferCountForSharedSlack = 0; + + public this(void* pNext, uint32 minBufferCount, uint32 maxBufferCount, uint32 minBufferCountForCamping, uint32 minBufferCountForDedicatedSlack, uint32 minBufferCountForSharedSlack) : this() + { + this.pNext = pNext; + this.minBufferCount = minBufferCount; + this.maxBufferCount = maxBufferCount; + this.minBufferCountForCamping = minBufferCountForCamping; + this.minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack; + this.minBufferCountForSharedSlack = minBufferCountForSharedSlack; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkBufferCollectionFUCHSIA pCollection); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, out VkBufferCollectionPropertiesFUCHSIA pProperties); + +static { public const let VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION = 3; } +static { public const let VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME = "VK_HUAWEI_subpass_shading"; } + +[CRepr] struct VkSubpassShadingPipelineCreateInfoHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPass renderPass = null; + public uint32 subpass = 0; + + public this(void* pNext, VkRenderPass renderPass, uint32 subpass) : this() + { + this.pNext = pNext; + this.renderPass = renderPass; + this.subpass = subpass; + } +} + +[CRepr] struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 subpassShading = false; + + public this(void* pNext, VkBool32 subpassShading) : this() + { + this.pNext = pNext; + this.subpassShading = subpassShading; + } +} + +[CRepr] struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxSubpassShadingWorkgroupSizeAspectRatio = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, out VkExtent2D pMaxWorkgroupSize); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer); + +static { public const let VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION = 1; } +static { public const let VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME = "VK_HUAWEI_invocation_mask"; } + +[CRepr] struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 invocationMask = false; + + public this(void* pNext, VkBool32 invocationMask) : this() + { + this.pNext = pNext; + this.invocationMask = invocationMask; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); + +static { public const let VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME = "VK_NV_external_memory_rdma"; } + +typealias VkRemoteAddressNV = void; + +[CRepr] struct VkMemoryGetRemoteAddressInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.memory = memory; + this.handleType = handleType; + } +} + +[CRepr] struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 externalMemoryRDMA = false; + + public this(void* pNext, VkBool32 externalMemoryRDMA) : this() + { + this.pNext = pNext; + this.externalMemoryRDMA = externalMemoryRDMA; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryRemoteAddressNV(VkDevice device, VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, out VkRemoteAddressNV pAddress); + +static { public const let VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION = 1; } +static { public const let VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME = "VK_EXT_pipeline_properties"; } + +typealias VkPipelineInfoEXT = VkPipelineInfoKHR; + +[CRepr] struct VkPipelinePropertiesIdentifierEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8[VK_UUID_SIZE] pipelineIdentifier = .(); +} + +[CRepr] struct VkPhysicalDevicePipelinePropertiesFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelinePropertiesIdentifier = false; + + public this(void* pNext, VkBool32 pipelinePropertiesIdentifier) : this() + { + this.pNext = pNext; + this.pipelinePropertiesIdentifier = pipelinePropertiesIdentifier; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelinePropertiesEXT(VkDevice device, VkPipelineInfoEXT* pPipelineInfo, out VkBaseOutStructure pPipelineProperties); + +static { public const let VK_EXT_FRAME_BOUNDARY_SPEC_VERSION = 1; } +static { public const let VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME = "VK_EXT_frame_boundary"; } + +[CRepr] struct VkPhysicalDeviceFrameBoundaryFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 frameBoundary = false; + + public this(void* pNext, VkBool32 frameBoundary) : this() + { + this.pNext = pNext; + this.frameBoundary = frameBoundary; + } +} + +[CRepr] struct VkFrameBoundaryEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFrameBoundaryFlagsEXT flags = default; + public uint64 frameID = 0; + public uint32 imageCount = 0; + public VkImage* pImages = null; + public Span images + { + get { return .(pImages, (.)imageCount); } + set mut { pImages = value.Ptr; imageCount = (.)value.Length; } + } + public uint32 bufferCount = 0; + public VkBuffer* pBuffers = null; + public Span buffers + { + get { return .(pBuffers, (.)bufferCount); } + set mut { pBuffers = value.Ptr; bufferCount = (.)value.Length; } + } + public uint64 tagName = 0; + public c_size tagSize = 0; + public void* pTag = null; + public Span tag + { + get { return .(pTag, (.)tagSize); } + set mut { pTag = value.Ptr; tagSize = (.)value.Length; } + } + + public this(void* pNext, VkFrameBoundaryFlagsEXT flags, uint64 frameID, Span images = default, Span buffers = default, uint64 tagName = 0, Span tag = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.frameID = frameID; + this.images = images; + this.buffers = buffers; + this.tagName = tagName; + this.tag = tag; + } +} + +[AllowDuplicates] enum VkFrameBoundaryFlagBitsEXT : int32 +{ + [NoShow] VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 1 << 0, + // pretty names + FrameEndEXT = 1 << 0, +} + +typealias VkFrameBoundaryFlagsEXT = VkFrameBoundaryFlagBitsEXT; + +static { public const let VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION = 1; } +static { public const let VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME = "VK_EXT_multisampled_render_to_single_sampled"; } + +[CRepr] struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multisampledRenderToSingleSampled = false; + + public this(void* pNext, VkBool32 multisampledRenderToSingleSampled) : this() + { + this.pNext = pNext; + this.multisampledRenderToSingleSampled = multisampledRenderToSingleSampled; + } +} + +[CRepr] struct VkSubpassResolvePerformanceQueryEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 optimal = false; +} + +[CRepr] struct VkMultisampledRenderToSingleSampledInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multisampledRenderToSingleSampledEnable = false; + public VkSampleCountFlagBits rasterizationSamples = default; + + public this(void* pNext, VkBool32 multisampledRenderToSingleSampledEnable, VkSampleCountFlagBits rasterizationSamples) : this() + { + this.pNext = pNext; + this.multisampledRenderToSingleSampledEnable = multisampledRenderToSingleSampledEnable; + this.rasterizationSamples = rasterizationSamples; + } +} + +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME = "VK_EXT_extended_dynamic_state2"; } + +[CRepr] struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 extendedDynamicState2 = false; + public VkBool32 extendedDynamicState2LogicOp = false; + public VkBool32 extendedDynamicState2PatchControlPoints = false; + + public this(void* pNext, VkBool32 extendedDynamicState2, VkBool32 extendedDynamicState2LogicOp, VkBool32 extendedDynamicState2PatchControlPoints) : this() + { + this.pNext = pNext; + this.extendedDynamicState2 = extendedDynamicState2; + this.extendedDynamicState2LogicOp = extendedDynamicState2LogicOp; + this.extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32 patchControlPoints); +typealias PFN_vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnable; +typealias PFN_vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnable; +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typealias PFN_vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnable; + +static { public const let VK_QNX_SCREEN_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_QNX_SCREEN_SURFACE_EXTENSION_NAME = "VK_QNX_screen_surface"; } + +typealias VkScreenSurfaceCreateFlagsQNX = VkFlags; + +[CRepr] struct VkScreenSurfaceCreateInfoQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkScreenSurfaceCreateFlagsQNX flags = default; + public _screen_context* context = null; + public _screen_window* window = null; + + public this(void* pNext, VkScreenSurfaceCreateFlagsQNX flags, _screen_context* context, _screen_window* window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.context = context; + this.window = window; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateScreenSurfaceQNX(VkInstance instance, VkScreenSurfaceCreateInfoQNX* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); +[CallingConvention(VKAPI_PTR)] function VkBool32 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out _screen_window window); + +static { public const let VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION = 1; } +static { public const let VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME = "VK_EXT_color_write_enable"; } + +[CRepr] struct VkPhysicalDeviceColorWriteEnableFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 colorWriteEnable = false; + + public this(void* pNext, VkBool32 colorWriteEnable) : this() + { + this.pNext = pNext; + this.colorWriteEnable = colorWriteEnable; + } +} + +[CRepr] struct VkPipelineColorWriteCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 attachmentCount = 0; // # of pAttachments + public VkBool32* pColorWriteEnables = null; + public Span colorWriteEnables + { + get { return .(pColorWriteEnables, (.)attachmentCount); } + set mut { pColorWriteEnables = value.Ptr; attachmentCount = (.)value.Length; } + } + + public this(void* pNext = null, Span colorWriteEnables = default) : this() + { + this.pNext = pNext; + this.colorWriteEnables = colorWriteEnables; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32 attachmentCount, VkBool32* pColorWriteEnables); + +static { public const let VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION = 1; } +static { public const let VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME = "VK_EXT_primitives_generated_query"; } + +[CRepr] struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 primitivesGeneratedQuery = false; + public VkBool32 primitivesGeneratedQueryWithRasterizerDiscard = false; + public VkBool32 primitivesGeneratedQueryWithNonZeroStreams = false; + + public this(void* pNext, VkBool32 primitivesGeneratedQuery, VkBool32 primitivesGeneratedQueryWithRasterizerDiscard, VkBool32 primitivesGeneratedQueryWithNonZeroStreams) : this() + { + this.pNext = pNext; + this.primitivesGeneratedQuery = primitivesGeneratedQuery; + this.primitivesGeneratedQueryWithRasterizerDiscard = primitivesGeneratedQueryWithRasterizerDiscard; + this.primitivesGeneratedQueryWithNonZeroStreams = primitivesGeneratedQueryWithNonZeroStreams; + } +} + +static { public const let VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME = "VK_KHR_ray_tracing_maintenance1"; } + +[CRepr] struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingMaintenance1 = false; + public VkBool32 rayTracingPipelineTraceRaysIndirect2 = false; + + public this(void* pNext, VkBool32 rayTracingMaintenance1, VkBool32 rayTracingPipelineTraceRaysIndirect2) : this() + { + this.pNext = pNext; + this.rayTracingMaintenance1 = rayTracingMaintenance1; + this.rayTracingPipelineTraceRaysIndirect2 = rayTracingPipelineTraceRaysIndirect2; + } +} + +[CRepr] struct VkTraceRaysIndirectCommand2KHR : this() +{ + public VkDeviceAddress raygenShaderRecordAddress = default; + public VkDeviceSize raygenShaderRecordSize = default; + public VkDeviceAddress missShaderBindingTableAddress = default; + public VkDeviceSize missShaderBindingTableSize = default; + public VkDeviceSize missShaderBindingTableStride = default; + public VkDeviceAddress hitShaderBindingTableAddress = default; + public VkDeviceSize hitShaderBindingTableSize = default; + public VkDeviceSize hitShaderBindingTableStride = default; + public VkDeviceAddress callableShaderBindingTableAddress = default; + public VkDeviceSize callableShaderBindingTableSize = default; + public VkDeviceSize callableShaderBindingTableStride = default; + public uint32 width = 0; + public uint32 height = 0; + public uint32 depth = 0; + + public this(VkDeviceAddress raygenShaderRecordAddress, VkDeviceSize raygenShaderRecordSize, VkDeviceAddress missShaderBindingTableAddress, VkDeviceSize missShaderBindingTableSize, VkDeviceSize missShaderBindingTableStride, VkDeviceAddress hitShaderBindingTableAddress, VkDeviceSize hitShaderBindingTableSize, VkDeviceSize hitShaderBindingTableStride, VkDeviceAddress callableShaderBindingTableAddress, VkDeviceSize callableShaderBindingTableSize, VkDeviceSize callableShaderBindingTableStride, uint32 width, uint32 height, uint32 depth) : this() + { + this.raygenShaderRecordAddress = raygenShaderRecordAddress; + this.raygenShaderRecordSize = raygenShaderRecordSize; + this.missShaderBindingTableAddress = missShaderBindingTableAddress; + this.missShaderBindingTableSize = missShaderBindingTableSize; + this.missShaderBindingTableStride = missShaderBindingTableStride; + this.hitShaderBindingTableAddress = hitShaderBindingTableAddress; + this.hitShaderBindingTableSize = hitShaderBindingTableSize; + this.hitShaderBindingTableStride = hitShaderBindingTableStride; + this.callableShaderBindingTableAddress = callableShaderBindingTableAddress; + this.callableShaderBindingTableSize = callableShaderBindingTableSize; + this.callableShaderBindingTableStride = callableShaderBindingTableStride; + this.width = width; + this.height = height; + this.depth = depth; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); + +static { public const let VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME = "VK_KHR_shader_untyped_pointers"; } + +[CRepr] struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderUntypedPointers = false; + + public this(void* pNext, VkBool32 shaderUntypedPointers) : this() + { + this.pNext = pNext; + this.shaderUntypedPointers = shaderUntypedPointers; + } +} + +static { public const let VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION = 1; } +static { public const let VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME = "VK_EXT_global_priority_query"; } +static { public const let VK_MAX_GLOBAL_PRIORITY_SIZE_EXT = VK_MAX_GLOBAL_PRIORITY_SIZE; } + +typealias VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = VkPhysicalDeviceGlobalPriorityQueryFeatures; +typealias VkQueueFamilyGlobalPriorityPropertiesEXT = VkQueueFamilyGlobalPriorityProperties; + +static { public const let VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION = 1; } +static { public const let VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME = "VK_VALVE_video_encode_rgb_conversion"; } + +[CRepr] struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoEncodeRgbConversion = false; + + public this(void* pNext, VkBool32 videoEncodeRgbConversion) : this() + { + this.pNext = pNext; + this.videoEncodeRgbConversion = videoEncodeRgbConversion; + } +} + +[CRepr] struct VkVideoEncodeRgbConversionCapabilitiesVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels = default; + public VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges = default; + public VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets = default; + public VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets = default; +} + +[CRepr] struct VkVideoEncodeProfileRgbConversionInfoVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 performEncodeRgbConversion = false; + + public this(void* pNext, VkBool32 performEncodeRgbConversion) : this() + { + this.pNext = pNext; + this.performEncodeRgbConversion = performEncodeRgbConversion; + } +} + +[CRepr] struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel = default; + public VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange = default; + public VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset = default; + public VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset = default; + + public this(void* pNext, VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel, VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset) : this() + { + this.pNext = pNext; + this.rgbModel = rgbModel; + this.rgbRange = rgbRange; + this.xChromaOffset = xChromaOffset; + this.yChromaOffset = yChromaOffset; + } +} + +[AllowDuplicates] enum VkVideoEncodeRgbModelConversionFlagBitsVALVE : int32 +{ + [NoShow] VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 1 << 4, + // pretty names + RgbIdentityVALVE = 1 << 0, + YcbcrIdentityVALVE = 1 << 1, + Ycbcr709VALVE = 1 << 2, + Ycbcr601VALVE = 1 << 3, + Ycbcr2020VALVE = 1 << 4, +} + +typealias VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagBitsVALVE; + +[AllowDuplicates] enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE : int32 +{ + [NoShow] VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 1 << 1, + // pretty names + FullRangeVALVE = 1 << 0, + NarrowRangeVALVE = 1 << 1, +} + +typealias VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; + +[AllowDuplicates] enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE : int32 +{ + [NoShow] VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 1 << 1, + // pretty names + CositedEvenVALVE = 1 << 0, + MidpointVALVE = 1 << 1, +} + +typealias VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; + +static { public const let VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME = "VK_EXT_image_view_min_lod"; } + +[CRepr] struct VkPhysicalDeviceImageViewMinLodFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 minLod = false; + + public this(void* pNext, VkBool32 minLod) : this() + { + this.pNext = pNext; + this.minLod = minLod; + } +} + +[CRepr] struct VkImageViewMinLodCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public float minLod = 0; + + public this(void* pNext, float minLod) : this() + { + this.pNext = pNext; + this.minLod = minLod; + } +} + +static { public const let VK_EXT_MULTI_DRAW_SPEC_VERSION = 1; } +static { public const let VK_EXT_MULTI_DRAW_EXTENSION_NAME = "VK_EXT_multi_draw"; } + +[CRepr] struct VkPhysicalDeviceMultiDrawFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multiDraw = false; + + public this(void* pNext, VkBool32 multiDraw) : this() + { + this.pNext = pNext; + this.multiDraw = multiDraw; + } +} + +[CRepr] struct VkPhysicalDeviceMultiDrawPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxMultiDrawCount = 0; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32 drawCount, VkMultiDrawInfoEXT* pVertexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32 drawCount, VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32 instanceCount, uint32 firstInstance, uint32 stride, int32* pVertexOffset = null); + +[CRepr] struct VkMultiDrawInfoEXT : this() +{ + public uint32 firstVertex = 0; + public uint32 vertexCount = 0; + + public this(uint32 firstVertex, uint32 vertexCount) : this() + { + this.firstVertex = firstVertex; + this.vertexCount = vertexCount; + } +} + +[CRepr] struct VkMultiDrawIndexedInfoEXT : this() +{ + public uint32 firstIndex = 0; + public uint32 indexCount = 0; + public int32 vertexOffset = 0; + + public this(uint32 firstIndex, uint32 indexCount, int32 vertexOffset) : this() + { + this.firstIndex = firstIndex; + this.indexCount = indexCount; + this.vertexOffset = vertexOffset; + } +} + +static { public const let VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME = "VK_EXT_image_2d_view_of_3d"; } + +[CRepr] struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 image2DViewOf3D = false; + public VkBool32 sampler2DViewOf3D = false; + + public this(void* pNext, VkBool32 image2DViewOf3D, VkBool32 sampler2DViewOf3D) : this() + { + this.pNext = pNext; + this.image2DViewOf3D = image2DViewOf3D; + this.sampler2DViewOf3D = sampler2DViewOf3D; + } +} + +static { public const let VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION = 1; } +static { public const let VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME = "VK_KHR_portability_enumeration"; } +static { public const let VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME = "VK_EXT_shader_tile_image"; } + +[CRepr] struct VkPhysicalDeviceShaderTileImageFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderTileImageColorReadAccess = false; + public VkBool32 shaderTileImageDepthReadAccess = false; + public VkBool32 shaderTileImageStencilReadAccess = false; + + public this(void* pNext, VkBool32 shaderTileImageColorReadAccess, VkBool32 shaderTileImageDepthReadAccess, VkBool32 shaderTileImageStencilReadAccess) : this() + { + this.pNext = pNext; + this.shaderTileImageColorReadAccess = shaderTileImageColorReadAccess; + this.shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess; + this.shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess; + } +} + +[CRepr] struct VkPhysicalDeviceShaderTileImagePropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderTileImageCoherentReadAccelerated = false; + public VkBool32 shaderTileImageReadSampleFromPixelRateInvocation = false; + public VkBool32 shaderTileImageReadFromHelperInvocation = false; +} + +static { public const let VK_EXT_OPACITY_MICROMAP_SPEC_VERSION = 2; } +static { public const let VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME = "VK_EXT_opacity_micromap"; } + +[AllowDuplicates] enum VkMicromapTypeEXT : int32 +{ + [NoShow] VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, + [NoShow] VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV = 1000397000, + // pretty names + OpacityMicromapEXT = 0, + DisplacementMicromapNV = 1000397000, +} + +[CRepr] struct VkMicromapBuildInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMicromapTypeEXT type = default; + public VkBuildMicromapFlagsEXT flags = default; + public VkBuildMicromapModeEXT mode = default; + public VkMicromapEXT dstMicromap = null; + public uint32 usageCountsCount = 0; + public VkMicromapUsageEXT* pUsageCounts = null; + public Span usageCounts + { + get { return .(pUsageCounts, (.)usageCountsCount); } + set mut { pUsageCounts = value.Ptr; usageCountsCount = (.)value.Length; } + } + public VkMicromapUsageEXT** ppUsageCounts = null; + public VkDeviceOrHostAddressConstKHR data = default; + public VkDeviceOrHostAddressKHR scratchData = default; + public VkDeviceOrHostAddressConstKHR triangleArray = default; + public VkDeviceSize triangleArrayStride = default; + + public this(void* pNext, VkMicromapTypeEXT type, VkBuildMicromapFlagsEXT flags, VkBuildMicromapModeEXT mode, VkMicromapEXT dstMicromap, Span usageCounts, VkMicromapUsageEXT** ppUsageCounts, VkDeviceOrHostAddressConstKHR data, VkDeviceOrHostAddressKHR scratchData, VkDeviceOrHostAddressConstKHR triangleArray, VkDeviceSize triangleArrayStride) : this() + { + this.pNext = pNext; + this.type = type; + this.flags = flags; + this.mode = mode; + this.dstMicromap = dstMicromap; + this.usageCounts = usageCounts; + this.ppUsageCounts = ppUsageCounts; + this.data = data; + this.scratchData = scratchData; + this.triangleArray = triangleArray; + this.triangleArrayStride = triangleArrayStride; + } +} + +[CRepr] struct VkMicromapUsageEXT : this() +{ + public uint32 count = 0; + public uint32 subdivisionLevel = 0; + public uint32 format = 0; // Interpretation depends on parent type + + public this(uint32 count, uint32 subdivisionLevel, uint32 format) : this() + { + this.count = count; + this.subdivisionLevel = subdivisionLevel; + this.format = format; + } +} + +[CRepr] struct VkMicromapCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMicromapCreateFlagsEXT createFlags = default; + public VkBuffer buffer = null; + public VkDeviceSize offset = default; // Specified in bytes + public VkDeviceSize size = default; + public VkMicromapTypeEXT type = default; + public VkDeviceAddress deviceAddress = default; + + public this(void* pNext, VkMicromapCreateFlagsEXT createFlags, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkMicromapTypeEXT type, VkDeviceAddress deviceAddress = default) : this() + { + this.pNext = pNext; + this.createFlags = createFlags; + this.buffer = buffer; + this.offset = offset; + this.size = size; + this.type = type; + this.deviceAddress = deviceAddress; + } +} + +struct VkMicromapEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_MICROMAP_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkBuildMicromapFlagBitsEXT : int32 +{ + [NoShow] VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 1 << 0, + [NoShow] VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 1 << 1, + [NoShow] VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 1 << 2, + // pretty names + PreferFastTraceEXT = 1 << 0, + PreferFastBuildEXT = 1 << 1, + AllowCompactionEXT = 1 << 2, +} + +typealias VkBuildMicromapFlagsEXT = VkBuildMicromapFlagBitsEXT; + +[AllowDuplicates] enum VkCopyMicromapModeEXT : int32 +{ + [NoShow] VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, + [NoShow] VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, + [NoShow] VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, + [NoShow] VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, + // pretty names + CloneEXT = 0, + SerializeEXT = 1, + DeserializeEXT = 2, + CompactEXT = 3, +} + +[CRepr] struct VkPhysicalDeviceOpacityMicromapFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 micromap = false; + public VkBool32 micromapCaptureReplay = false; + public VkBool32 micromapHostCommands = false; + + public this(void* pNext, VkBool32 micromap, VkBool32 micromapCaptureReplay, VkBool32 micromapHostCommands) : this() + { + this.pNext = pNext; + this.micromap = micromap; + this.micromapCaptureReplay = micromapCaptureReplay; + this.micromapHostCommands = micromapHostCommands; + } +} + +[CRepr] struct VkPhysicalDeviceOpacityMicromapPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxOpacity2StateSubdivisionLevel = 0; + public uint32 maxOpacity4StateSubdivisionLevel = 0; +} + +[CRepr] struct VkMicromapVersionInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8* pVersionData = null; + + public this(void* pNext, uint8* pVersionData) : this() + { + this.pNext = pNext; + this.pVersionData = pVersionData; + } +} + +[CRepr] struct VkCopyMicromapToMemoryInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMicromapEXT src = null; + public VkDeviceOrHostAddressKHR dst = default; + public VkCopyMicromapModeEXT mode = default; + + public this(void* pNext, VkMicromapEXT src, VkDeviceOrHostAddressKHR dst, VkCopyMicromapModeEXT mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[CRepr] struct VkCopyMemoryToMicromapInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceOrHostAddressConstKHR src = default; + public VkMicromapEXT dst = null; + public VkCopyMicromapModeEXT mode = default; + + public this(void* pNext, VkDeviceOrHostAddressConstKHR src, VkMicromapEXT dst, VkCopyMicromapModeEXT mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[CRepr] struct VkCopyMicromapInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMicromapEXT src = null; + public VkMicromapEXT dst = null; + public VkCopyMicromapModeEXT mode = default; + + public this(void* pNext, VkMicromapEXT src, VkMicromapEXT dst, VkCopyMicromapModeEXT mode) : this() + { + this.pNext = pNext; + this.src = src; + this.dst = dst; + this.mode = mode; + } +} + +[AllowDuplicates] enum VkMicromapCreateFlagBitsEXT : int32 +{ + [NoShow] VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 1 << 0, + // pretty names + DeviceAddressCaptureReplayEXT = 1 << 0, +} + +typealias VkMicromapCreateFlagsEXT = VkMicromapCreateFlagBitsEXT; + +[AllowDuplicates] enum VkBuildMicromapModeEXT : int32 +{ + [NoShow] VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, + // pretty names + BuildEXT = 0, +} + +[CRepr] struct VkMicromapBuildSizesInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize micromapSize = default; + public VkDeviceSize buildScratchSize = default; + public VkBool32 discardable = false; + + public this(void* pNext, VkDeviceSize micromapSize, VkDeviceSize buildScratchSize, VkBool32 discardable) : this() + { + this.pNext = pNext; + this.micromapSize = micromapSize; + this.buildScratchSize = buildScratchSize; + this.discardable = discardable; + } +} + +[AllowDuplicates] enum VkOpacityMicromapFormatEXT : int32 +{ + [NoShow] VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, + [NoShow] VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, + // pretty names + _2_StateEXT = 1, + _4_StateEXT = 2, +} + +[CRepr] struct VkAccelerationStructureTrianglesOpacityMicromapEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndexType indexType = default; + public VkDeviceOrHostAddressConstKHR indexBuffer = default; + public VkDeviceSize indexStride = default; + public uint32 baseTriangle = 0; + public uint32 usageCountsCount = 0; + public VkMicromapUsageEXT* pUsageCounts = null; + public Span usageCounts + { + get { return .(pUsageCounts, (.)usageCountsCount); } + set mut { pUsageCounts = value.Ptr; usageCountsCount = (.)value.Length; } + } + public VkMicromapUsageEXT** ppUsageCounts = null; + public VkMicromapEXT micromap = null; + + public this(void* pNext, VkIndexType indexType, VkDeviceOrHostAddressConstKHR indexBuffer, VkDeviceSize indexStride, uint32 baseTriangle, Span usageCounts, VkMicromapUsageEXT** ppUsageCounts, VkMicromapEXT micromap = null) : this() + { + this.pNext = pNext; + this.indexType = indexType; + this.indexBuffer = indexBuffer; + this.indexStride = indexStride; + this.baseTriangle = baseTriangle; + this.usageCounts = usageCounts; + this.ppUsageCounts = ppUsageCounts; + this.micromap = micromap; + } +} + +[CRepr] struct VkMicromapTriangleEXT : this() +{ + public uint32 dataOffset = 0; // Specified in bytes + public uint16 subdivisionLevel = 0; + public uint16 format = 0; + + public this(uint32 dataOffset, uint16 subdivisionLevel, uint16 format) : this() + { + this.dataOffset = dataOffset; + this.subdivisionLevel = subdivisionLevel; + this.format = format; + } +} + +[AllowDuplicates] enum VkOpacityMicromapSpecialIndexEXT : int32 +{ + [NoShow] VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, + [NoShow] VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, + [NoShow] VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, + [NoShow] VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, + [NoShow] VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, + // pretty names + FullyTransparentEXT = -1, + FullyOpaqueEXT = -2, + FullyUnknownTransparentEXT = -3, + FullyUnknownOpaqueEXT = -4, + ClusterGeometryDisableOpacityMicromapNV = -5, +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateMicromapEXT(VkDevice device, VkMicromapCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkMicromapEXT pMicromap); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32 infoCount, VkMicromapBuildInfoEXT* pInfos); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32 infoCount, VkMicromapBuildInfoEXT* pInfos); +[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 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); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32 micromapCount, VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32 firstQuery); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceMicromapCompatibilityEXT(VkDevice device, VkMicromapVersionInfoEXT* pVersionInfo, out VkAccelerationStructureCompatibilityKHR pCompatibility); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, VkMicromapBuildInfoEXT* pBuildInfo, out VkMicromapBuildSizesInfoEXT pSizeInfo); + +static { public const let VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION = 2; } +static { public const let VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME = "VK_NV_displacement_micromap"; } + +[CRepr] struct VkPhysicalDeviceDisplacementMicromapFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 displacementMicromap = false; + + public this(void* pNext, VkBool32 displacementMicromap) : this() + { + this.pNext = pNext; + this.displacementMicromap = displacementMicromap; + } +} + +[CRepr] struct VkPhysicalDeviceDisplacementMicromapPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxDisplacementMicromapSubdivisionLevel = 0; +} + +[CRepr] struct VkAccelerationStructureTrianglesDisplacementMicromapNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat displacementBiasAndScaleFormat = default; + public VkFormat displacementVectorFormat = default; + public VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer = default; + public VkDeviceSize displacementBiasAndScaleStride = default; + public VkDeviceOrHostAddressConstKHR displacementVectorBuffer = default; + public VkDeviceSize displacementVectorStride = default; + public VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags = default; + public VkDeviceSize displacedMicromapPrimitiveFlagsStride = default; + public VkIndexType indexType = default; + public VkDeviceOrHostAddressConstKHR indexBuffer = default; + public VkDeviceSize indexStride = default; + public uint32 baseTriangle = 0; + public uint32 usageCountsCount = 0; + public VkMicromapUsageEXT* pUsageCounts = null; + public Span usageCounts + { + get { return .(pUsageCounts, (.)usageCountsCount); } + set mut { pUsageCounts = value.Ptr; usageCountsCount = (.)value.Length; } + } + public VkMicromapUsageEXT** ppUsageCounts = null; + public VkMicromapEXT micromap = null; + + public this(void* pNext, VkFormat displacementBiasAndScaleFormat, VkFormat displacementVectorFormat, VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer, VkDeviceSize displacementBiasAndScaleStride, VkDeviceOrHostAddressConstKHR displacementVectorBuffer, VkDeviceSize displacementVectorStride, VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags, VkDeviceSize displacedMicromapPrimitiveFlagsStride, VkIndexType indexType, VkDeviceOrHostAddressConstKHR indexBuffer, VkDeviceSize indexStride, uint32 baseTriangle, Span usageCounts, VkMicromapUsageEXT** ppUsageCounts, VkMicromapEXT micromap = null) : this() + { + this.pNext = pNext; + this.displacementBiasAndScaleFormat = displacementBiasAndScaleFormat; + this.displacementVectorFormat = displacementVectorFormat; + this.displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer; + this.displacementBiasAndScaleStride = displacementBiasAndScaleStride; + this.displacementVectorBuffer = displacementVectorBuffer; + this.displacementVectorStride = displacementVectorStride; + this.displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags; + this.displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride; + this.indexType = indexType; + this.indexBuffer = indexBuffer; + this.indexStride = indexStride; + this.baseTriangle = baseTriangle; + this.usageCounts = usageCounts; + this.ppUsageCounts = ppUsageCounts; + this.micromap = micromap; + } +} + +[AllowDuplicates] enum VkDisplacementMicromapFormatNV : int32 +{ + [NoShow] VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, + [NoShow] VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, + [NoShow] VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, + // pretty names + _64_Triangles64_BytesNV = 1, + _256_Triangles128_BytesNV = 2, + _1024_Triangles128_BytesNV = 3, +} + +static { public const let VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION = 1; } +static { public const let VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME = "VK_EXT_load_store_op_none"; } +static { public const let VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION = 3; } +static { public const let VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME = "VK_HUAWEI_cluster_culling_shader"; } + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32 groupCountX, uint32 groupCountY, uint32 groupCountZ); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); + +[CRepr] struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 clustercullingShader = false; + public VkBool32 multiviewClusterCullingShader = false; + + public this(void* pNext, VkBool32 clustercullingShader, VkBool32 multiviewClusterCullingShader) : this() + { + this.pNext = pNext; + this.clustercullingShader = clustercullingShader; + this.multiviewClusterCullingShader = multiviewClusterCullingShader; + } +} + +[CRepr] struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32[3] maxWorkGroupCount = .(); + public uint32[3] maxWorkGroupSize = .(); + public uint32 maxOutputClusterCount = 0; + public VkDeviceSize indirectBufferOffsetAlignment = default; +} + +[CRepr] struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 clusterShadingRate = false; + + public this(void* pNext, VkBool32 clusterShadingRate) : this() + { + this.pNext = pNext; + this.clusterShadingRate = clusterShadingRate; + } +} + +static { public const let VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION = 1; } +static { public const let VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME = "VK_EXT_border_color_swizzle"; } + +[CRepr] struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 borderColorSwizzle = false; + public VkBool32 borderColorSwizzleFromImage = false; + + public this(void* pNext, VkBool32 borderColorSwizzle, VkBool32 borderColorSwizzleFromImage) : this() + { + this.pNext = pNext; + this.borderColorSwizzle = borderColorSwizzle; + this.borderColorSwizzleFromImage = borderColorSwizzleFromImage; + } +} + +[CRepr] struct VkSamplerBorderColorComponentMappingCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkComponentMapping components = default; + public VkBool32 srgb = false; + + public this(void* pNext, VkComponentMapping components, VkBool32 srgb) : this() + { + this.pNext = pNext; + this.components = components; + this.srgb = srgb; + } +} + +static { public const let VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME = "VK_EXT_pageable_device_local_memory"; } + +[CRepr] struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pageableDeviceLocalMemory = false; + + public this(void* pNext, VkBool32 pageableDeviceLocalMemory) : this() + { + this.pNext = pNext; + this.pageableDeviceLocalMemory = pageableDeviceLocalMemory; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority); + +static { public const let VK_KHR_MAINTENANCE_4_SPEC_VERSION = 2; } +static { public const let VK_KHR_MAINTENANCE_4_EXTENSION_NAME = "VK_KHR_maintenance4"; } + +typealias VkPhysicalDeviceMaintenance4FeaturesKHR = VkPhysicalDeviceMaintenance4Features; +typealias VkPhysicalDeviceMaintenance4PropertiesKHR = VkPhysicalDeviceMaintenance4Properties; +typealias VkDeviceBufferMemoryRequirementsKHR = VkDeviceBufferMemoryRequirements; +typealias VkDeviceImageMemoryRequirementsKHR = VkDeviceImageMemoryRequirements; + +typealias PFN_vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirements; +typealias PFN_vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirements; +typealias PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirements; + +static { public const let VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION = 1; } +static { public const let VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME = "VK_ARM_shader_core_properties"; } + +[CRepr] struct VkPhysicalDeviceShaderCorePropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 pixelRate = 0; + public uint32 texelRate = 0; + public uint32 fmaRate = 0; +} + +static { public const let VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION = 2; } +static { public const let VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME = "VK_KHR_shader_subgroup_rotate"; } + +typealias VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR = VkPhysicalDeviceShaderSubgroupRotateFeatures; + +static { public const let VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION = 1; } +static { public const let VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME = "VK_ARM_scheduling_controls"; } + +[CRepr] struct VkDeviceQueueShaderCoreControlCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderCoreCount = 0; + + public this(void* pNext, uint32 shaderCoreCount) : this() + { + this.pNext = pNext; + this.shaderCoreCount = shaderCoreCount; + } +} + +[CRepr] struct VkPhysicalDeviceSchedulingControlsFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 schedulingControls = false; + + public this(void* pNext, VkBool32 schedulingControls) : this() + { + this.pNext = pNext; + this.schedulingControls = schedulingControls; + } +} + +[CRepr] struct VkPhysicalDeviceSchedulingControlsPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags = default; +} + +typealias VkPhysicalDeviceSchedulingControlsFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkPhysicalDeviceSchedulingControlsFlagBitsARM : int32 +{ + [NoShow] VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 1 << 0, + // pretty names + ShaderCoreCountARM = 1 << 0, +} + +static { public const let VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME = "VK_EXT_image_sliced_view_of_3d"; } +static { public const uint32 VK_REMAINING_3D_SLICES_EXT = (~0U); } + +[CRepr] struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imageSlicedViewOf3D = false; + + public this(void* pNext, VkBool32 imageSlicedViewOf3D) : this() + { + this.pNext = pNext; + this.imageSlicedViewOf3D = imageSlicedViewOf3D; + } +} + +[CRepr] struct VkImageViewSlicedCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 sliceOffset = 0; + public uint32 sliceCount = 0; + + public this(void* pNext, uint32 sliceOffset, uint32 sliceCount) : this() + { + this.pNext = pNext; + this.sliceOffset = sliceOffset; + this.sliceCount = sliceCount; + } +} + +static { public const let VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION = 1; } +static { public const let VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME = "VK_VALVE_descriptor_set_host_mapping"; } + +[CRepr] struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 descriptorSetHostMapping = false; + + public this(void* pNext, VkBool32 descriptorSetHostMapping) : this() + { + this.pNext = pNext; + this.descriptorSetHostMapping = descriptorSetHostMapping; + } +} + +[CRepr] struct VkDescriptorSetBindingReferenceVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDescriptorSetLayout descriptorSetLayout = null; + public uint32 binding = 0; + + public this(void* pNext, VkDescriptorSetLayout descriptorSetLayout, uint32 binding) : this() + { + this.pNext = pNext; + this.descriptorSetLayout = descriptorSetLayout; + this.binding = binding; + } +} + +[CRepr] struct VkDescriptorSetLayoutHostMappingInfoVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size descriptorOffset = 0; + public uint32 descriptorSize = 0; + + public this(void* pNext, c_size descriptorOffset, uint32 descriptorSize) : this() + { + this.pNext = pNext; + this.descriptorOffset = descriptorOffset; + this.descriptorSize = descriptorSize; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, VkDescriptorSetBindingReferenceVALVE* pBindingReference, out VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, out void* ppData); + +static { public const let VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME = "VK_EXT_depth_clamp_zero_one"; } + +typealias VkPhysicalDeviceDepthClampZeroOneFeaturesEXT = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; + +static { public const let VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION = 1; } +static { public const let VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME = "VK_EXT_non_seamless_cube_map"; } + +[CRepr] struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 nonSeamlessCubeMap = false; + + public this(void* pNext, VkBool32 nonSeamlessCubeMap) : this() + { + this.pNext = pNext; + this.nonSeamlessCubeMap = nonSeamlessCubeMap; + } +} + +static { public const let VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION = 1; } +static { public const let VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME = "VK_ARM_render_pass_striped"; } + +[CRepr] struct VkPhysicalDeviceRenderPassStripedFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 renderPassStriped = false; + + public this(void* pNext, VkBool32 renderPassStriped) : this() + { + this.pNext = pNext; + this.renderPassStriped = renderPassStriped; + } +} + +[CRepr] struct VkPhysicalDeviceRenderPassStripedPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D renderPassStripeGranularity = default; + public uint32 maxRenderPassStripes = 0; +} + +[CRepr] struct VkRenderPassStripeBeginInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stripeInfoCount = 0; + public VkRenderPassStripeInfoARM* pStripeInfos = null; + public Span stripeInfos + { + get { return .(pStripeInfos, (.)stripeInfoCount); } + set mut { pStripeInfos = value.Ptr; stripeInfoCount = (.)value.Length; } + } + + public this(void* pNext, Span stripeInfos) : this() + { + this.pNext = pNext; + this.stripeInfos = stripeInfos; + } +} + +[CRepr] struct VkRenderPassStripeInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRect2D stripeArea = default; + + public this(void* pNext, VkRect2D stripeArea) : this() + { + this.pNext = pNext; + this.stripeArea = stripeArea; + } +} + +[CRepr] struct VkRenderPassStripeSubmitInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 stripeSemaphoreInfoCount = 0; + public VkSemaphoreSubmitInfo* pStripeSemaphoreInfos = null; + public Span stripeSemaphoreInfos + { + get { return .(pStripeSemaphoreInfos, (.)stripeSemaphoreInfoCount); } + set mut { pStripeSemaphoreInfos = value.Ptr; stripeSemaphoreInfoCount = (.)value.Length; } + } + + public this(void* pNext, Span stripeSemaphoreInfos) : this() + { + this.pNext = pNext; + this.stripeSemaphoreInfos = stripeSemaphoreInfos; + } +} + +static { public const let VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION = 3; } +static { public const let VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME = "VK_QCOM_fragment_density_map_offset"; } + +typealias VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; +typealias VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; +typealias VkSubpassFragmentDensityMapOffsetEndInfoQCOM = VkRenderPassFragmentDensityMapOffsetEndInfoEXT; + +static { public const let VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION = 1; } +static { public const let VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME = "VK_NV_copy_memory_indirect"; } + +typealias VkCopyMemoryIndirectCommandNV = VkCopyMemoryIndirectCommandKHR; +typealias VkCopyMemoryToImageIndirectCommandNV = VkCopyMemoryToImageIndirectCommandKHR; + +[CRepr] struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 indirectCopy = false; + + public this(void* pNext, VkBool32 indirectCopy) : this() + { + this.pNext = pNext; + this.indirectCopy = indirectCopy; + } +} + +typealias VkPhysicalDeviceCopyMemoryIndirectPropertiesNV = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32 copyCount, uint32 stride); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32 copyCount, uint32 stride, VkImage dstImage, VkImageLayout dstImageLayout, VkImageSubresourceLayers* pImageSubresources); + +static { public const let VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION = 1; } +static { public const let VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME = "VK_NV_memory_decompression"; } + +typealias VkMemoryDecompressionMethodFlagBitsNV = VkMemoryDecompressionMethodFlagBitsEXT; +typealias VkMemoryDecompressionMethodFlagsNV = VkMemoryDecompressionMethodFlagsEXT; + +[CRepr] struct VkDecompressMemoryRegionNV : this() +{ + public VkDeviceAddress srcAddress = default; + public VkDeviceAddress dstAddress = default; + public VkDeviceSize compressedSize = default; // Specified in bytes + public VkDeviceSize decompressedSize = default; // Specified in bytes + public VkMemoryDecompressionMethodFlagsNV decompressionMethod = default; + + public this(VkDeviceAddress srcAddress, VkDeviceAddress dstAddress, VkDeviceSize compressedSize, VkDeviceSize decompressedSize, VkMemoryDecompressionMethodFlagsNV decompressionMethod) : this() + { + this.srcAddress = srcAddress; + this.dstAddress = dstAddress; + this.compressedSize = compressedSize; + this.decompressedSize = decompressedSize; + this.decompressionMethod = decompressionMethod; + } +} + +typealias VkPhysicalDeviceMemoryDecompressionFeaturesNV = VkPhysicalDeviceMemoryDecompressionFeaturesEXT; +typealias VkPhysicalDeviceMemoryDecompressionPropertiesNV = VkPhysicalDeviceMemoryDecompressionPropertiesEXT; + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32 decompressRegionCount, VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32 stride); + +static { public const let VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION = 2; } +static { public const let VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME = "VK_NV_device_generated_commands_compute"; } + +[CRepr] struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceGeneratedCompute = false; + public VkBool32 deviceGeneratedComputePipelines = false; + public VkBool32 deviceGeneratedComputeCaptureReplay = false; + + public this(void* pNext, VkBool32 deviceGeneratedCompute, VkBool32 deviceGeneratedComputePipelines, VkBool32 deviceGeneratedComputeCaptureReplay) : this() + { + this.pNext = pNext; + this.deviceGeneratedCompute = deviceGeneratedCompute; + this.deviceGeneratedComputePipelines = deviceGeneratedComputePipelines; + this.deviceGeneratedComputeCaptureReplay = deviceGeneratedComputeCaptureReplay; + } +} + +[CRepr] struct VkComputePipelineIndirectBufferInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceAddress deviceAddress = default; + public VkDeviceSize size = default; + public VkDeviceAddress pipelineDeviceAddressCaptureReplay = default; + + public this(void* pNext, VkDeviceAddress deviceAddress, VkDeviceSize size, VkDeviceAddress pipelineDeviceAddressCaptureReplay = default) : this() + { + this.pNext = pNext; + this.deviceAddress = deviceAddress; + this.size = size; + this.pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay; + } +} + +[CRepr] struct VkPipelineIndirectDeviceAddressInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineBindPoint pipelineBindPoint = default; + public VkPipeline pipeline = null; + + public this(void* pNext, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) : this() + { + this.pNext = pNext; + this.pipelineBindPoint = pipelineBindPoint; + this.pipeline = pipeline; + } +} + +[CRepr] struct VkBindPipelineIndirectCommandNV : this() +{ + public VkDeviceAddress pipelineAddress = default; + + public this(VkDeviceAddress pipelineAddress) : this() + { + this.pipelineAddress = pipelineAddress; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, VkComputePipelineCreateInfo* pCreateInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +[CallingConvention(VKAPI_PTR)] function VkDeviceAddress PFN_vkGetPipelineIndirectDeviceAddressNV(VkDevice device, VkPipelineIndirectDeviceAddressInfoNV* pInfo); + +static { public const let VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION = 1; } +static { public const let VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME = "VK_NV_ray_tracing_linear_swept_spheres"; } + +[CRepr] struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 spheres = false; + public VkBool32 linearSweptSpheres = false; + + public this(void* pNext, VkBool32 spheres, VkBool32 linearSweptSpheres) : this() + { + this.pNext = pNext; + this.spheres = spheres; + this.linearSweptSpheres = linearSweptSpheres; + } +} + +[CRepr] struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat vertexFormat = default; + public VkDeviceOrHostAddressConstKHR vertexData = default; + public VkDeviceSize vertexStride = default; + public VkFormat radiusFormat = default; + public VkDeviceOrHostAddressConstKHR radiusData = default; + public VkDeviceSize radiusStride = default; + public VkIndexType indexType = default; + public VkDeviceOrHostAddressConstKHR indexData = default; + public VkDeviceSize indexStride = default; + public VkRayTracingLssIndexingModeNV indexingMode = default; + public VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode = default; + + public this(void* pNext, VkFormat vertexFormat, VkDeviceOrHostAddressConstKHR vertexData, VkDeviceSize vertexStride, VkFormat radiusFormat, VkDeviceOrHostAddressConstKHR radiusData, VkDeviceSize radiusStride, VkIndexType indexType, VkDeviceOrHostAddressConstKHR indexData, VkDeviceSize indexStride, VkRayTracingLssIndexingModeNV indexingMode, VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode) : this() + { + this.pNext = pNext; + this.vertexFormat = vertexFormat; + this.vertexData = vertexData; + this.vertexStride = vertexStride; + this.radiusFormat = radiusFormat; + this.radiusData = radiusData; + this.radiusStride = radiusStride; + this.indexType = indexType; + this.indexData = indexData; + this.indexStride = indexStride; + this.indexingMode = indexingMode; + this.endCapsMode = endCapsMode; + } +} + +[CRepr] struct VkAccelerationStructureGeometrySpheresDataNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat vertexFormat = default; + public VkDeviceOrHostAddressConstKHR vertexData = default; + public VkDeviceSize vertexStride = default; + public VkFormat radiusFormat = default; + public VkDeviceOrHostAddressConstKHR radiusData = default; + public VkDeviceSize radiusStride = default; + public VkIndexType indexType = default; + public VkDeviceOrHostAddressConstKHR indexData = default; + public VkDeviceSize indexStride = default; + + public this(void* pNext, VkFormat vertexFormat, VkDeviceOrHostAddressConstKHR vertexData, VkDeviceSize vertexStride, VkFormat radiusFormat, VkDeviceOrHostAddressConstKHR radiusData, VkDeviceSize radiusStride, VkIndexType indexType, VkDeviceOrHostAddressConstKHR indexData, VkDeviceSize indexStride) : this() + { + this.pNext = pNext; + this.vertexFormat = vertexFormat; + this.vertexData = vertexData; + this.vertexStride = vertexStride; + this.radiusFormat = radiusFormat; + this.radiusData = radiusData; + this.radiusStride = radiusStride; + this.indexType = indexType; + this.indexData = indexData; + this.indexStride = indexStride; + } +} + +[AllowDuplicates] enum VkRayTracingLssIndexingModeNV : int32 +{ + [NoShow] VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV = 0, + [NoShow] VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV = 1, + // pretty names + ListNV = 0, + SuccessiveNV = 1, +} + +[AllowDuplicates] enum VkRayTracingLssPrimitiveEndCapsModeNV : int32 +{ + [NoShow] VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV = 0, + [NoShow] VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV = 1, + // pretty names + NoneNV = 0, + ChainedNV = 1, +} + +static { public const let VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION = 1; } +static { public const let VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME = "VK_NV_linear_color_attachment"; } + +[CRepr] struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 linearColorAttachment = false; + + public this(void* pNext, VkBool32 linearColorAttachment) : this() + { + this.pNext = pNext; + this.linearColorAttachment = linearColorAttachment; + } +} + +static { public const let VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION = 2; } +static { public const let VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME = "VK_GOOGLE_surfaceless_query"; } +static { public const let VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME = "VK_KHR_shader_maximal_reconvergence"; } + +[CRepr] struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderMaximalReconvergence = false; + + public this(void* pNext, VkBool32 shaderMaximalReconvergence) : this() + { + this.pNext = pNext; + this.shaderMaximalReconvergence = shaderMaximalReconvergence; + } +} + +static { public const let VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION = 1; } +static { public const let VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME = "VK_EXT_image_compression_control_swapchain"; } + +[CRepr] struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imageCompressionControlSwapchain = false; + + public this(void* pNext, VkBool32 imageCompressionControlSwapchain) : this() + { + this.pNext = pNext; + this.imageCompressionControlSwapchain = imageCompressionControlSwapchain; + } +} + +static { public const let VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION = 1; } +static { public const let VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME = "VK_QCOM_image_processing"; } + +[CRepr] struct VkImageViewSampleWeightCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOffset2D filterCenter = default; + public VkExtent2D filterSize = default; + public uint32 numPhases = 0; + + public this(void* pNext, VkOffset2D filterCenter, VkExtent2D filterSize, uint32 numPhases) : this() + { + this.pNext = pNext; + this.filterCenter = filterCenter; + this.filterSize = filterSize; + this.numPhases = numPhases; + } +} + +[CRepr] struct VkPhysicalDeviceImageProcessingFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 textureSampleWeighted = false; + public VkBool32 textureBoxFilter = false; + public VkBool32 textureBlockMatch = false; + + public this(void* pNext, VkBool32 textureSampleWeighted, VkBool32 textureBoxFilter, VkBool32 textureBlockMatch) : this() + { + this.pNext = pNext; + this.textureSampleWeighted = textureSampleWeighted; + this.textureBoxFilter = textureBoxFilter; + this.textureBlockMatch = textureBlockMatch; + } +} + +[CRepr] struct VkPhysicalDeviceImageProcessingPropertiesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxWeightFilterPhases = 0; + public VkExtent2D maxWeightFilterDimension = default; + public VkExtent2D maxBlockMatchRegion = default; + public VkExtent2D maxBoxFilterBlockSize = default; +} + +static { public const let VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION = 1; } +static { public const let VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME = "VK_EXT_nested_command_buffer"; } + +[CRepr] struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 nestedCommandBuffer = false; + public VkBool32 nestedCommandBufferRendering = false; + public VkBool32 nestedCommandBufferSimultaneousUse = false; + + public this(void* pNext, VkBool32 nestedCommandBuffer, VkBool32 nestedCommandBufferRendering, VkBool32 nestedCommandBufferSimultaneousUse) : this() + { + this.pNext = pNext; + this.nestedCommandBuffer = nestedCommandBuffer; + this.nestedCommandBufferRendering = nestedCommandBufferRendering; + this.nestedCommandBufferSimultaneousUse = nestedCommandBufferSimultaneousUse; + } +} + +[CRepr] struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxCommandBufferNestingLevel = 0; +} + +static { public const let VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_OHOS_external_memory"; } + +[CRepr] struct VkNativeBufferUsageOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 OHOSNativeBufferUsage = 0; +} + +[CRepr] struct VkNativeBufferPropertiesOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize allocationSize = default; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkNativeBufferFormatPropertiesOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public uint64 externalFormat = 0; + public VkFormatFeatureFlags formatFeatures = default; + public VkComponentMapping samplerYcbcrConversionComponents = default; + public VkSamplerYcbcrModelConversion suggestedYcbcrModel = default; + public VkSamplerYcbcrRange suggestedYcbcrRange = default; + public VkChromaLocation suggestedXChromaOffset = default; + public VkChromaLocation suggestedYChromaOffset = default; +} + +[CRepr] struct VkImportNativeBufferInfoOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public OH_NativeBuffer* buffer = null; + + public this(void* pNext, OH_NativeBuffer* buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkMemoryGetNativeBufferInfoOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + + public this(void* pNext, VkDeviceMemory memory) : this() + { + this.pNext = pNext; + this.memory = memory; + } +} + +[CRepr] struct VkExternalFormatOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 externalFormat = 0; + + public this(void* pNext, uint64 externalFormat) : this() + { + this.pNext = pNext; + this.externalFormat = externalFormat; + } +} + +struct OH_NativeBuffer; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetNativeBufferPropertiesOHOS(VkDevice device, out OH_NativeBuffer buffer, out VkNativeBufferPropertiesOHOS pProperties); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryNativeBufferOHOS(VkDevice device, VkMemoryGetNativeBufferInfoOHOS* pInfo, out OH_NativeBuffer* pBuffer); + +// Note that VK_OHOS_native_buffer uses VkStructureType enum values from this range, with permission +static { public const let VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME = "VK_EXT_external_memory_acquire_unmodified"; } + +[CRepr] struct VkExternalMemoryAcquireUnmodifiedEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 acquireUnmodifiedMemory = false; + + public this(void* pNext, VkBool32 acquireUnmodifiedMemory) : this() + { + this.pNext = pNext; + this.acquireUnmodifiedMemory = acquireUnmodifiedMemory; + } +} + +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION = 2; } +static { public const let VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME = "VK_EXT_extended_dynamic_state3"; } + +[CRepr] struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 extendedDynamicState3TessellationDomainOrigin = false; + public VkBool32 extendedDynamicState3DepthClampEnable = false; + public VkBool32 extendedDynamicState3PolygonMode = false; + public VkBool32 extendedDynamicState3RasterizationSamples = false; + public VkBool32 extendedDynamicState3SampleMask = false; + public VkBool32 extendedDynamicState3AlphaToCoverageEnable = false; + public VkBool32 extendedDynamicState3AlphaToOneEnable = false; + public VkBool32 extendedDynamicState3LogicOpEnable = false; + public VkBool32 extendedDynamicState3ColorBlendEnable = false; + public VkBool32 extendedDynamicState3ColorBlendEquation = false; + public VkBool32 extendedDynamicState3ColorWriteMask = false; + public VkBool32 extendedDynamicState3RasterizationStream = false; + public VkBool32 extendedDynamicState3ConservativeRasterizationMode = false; + public VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize = false; + public VkBool32 extendedDynamicState3DepthClipEnable = false; + public VkBool32 extendedDynamicState3SampleLocationsEnable = false; + public VkBool32 extendedDynamicState3ColorBlendAdvanced = false; + public VkBool32 extendedDynamicState3ProvokingVertexMode = false; + public VkBool32 extendedDynamicState3LineRasterizationMode = false; + public VkBool32 extendedDynamicState3LineStippleEnable = false; + public VkBool32 extendedDynamicState3DepthClipNegativeOneToOne = false; + public VkBool32 extendedDynamicState3ViewportWScalingEnable = false; + public VkBool32 extendedDynamicState3ViewportSwizzle = false; + public VkBool32 extendedDynamicState3CoverageToColorEnable = false; + public VkBool32 extendedDynamicState3CoverageToColorLocation = false; + public VkBool32 extendedDynamicState3CoverageModulationMode = false; + public VkBool32 extendedDynamicState3CoverageModulationTableEnable = false; + public VkBool32 extendedDynamicState3CoverageModulationTable = false; + public VkBool32 extendedDynamicState3CoverageReductionMode = false; + public VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable = false; + public VkBool32 extendedDynamicState3ShadingRateImageEnable = false; + + public this(void* pNext, VkBool32 extendedDynamicState3TessellationDomainOrigin, VkBool32 extendedDynamicState3DepthClampEnable, VkBool32 extendedDynamicState3PolygonMode, VkBool32 extendedDynamicState3RasterizationSamples, VkBool32 extendedDynamicState3SampleMask, VkBool32 extendedDynamicState3AlphaToCoverageEnable, VkBool32 extendedDynamicState3AlphaToOneEnable, VkBool32 extendedDynamicState3LogicOpEnable, VkBool32 extendedDynamicState3ColorBlendEnable, VkBool32 extendedDynamicState3ColorBlendEquation, VkBool32 extendedDynamicState3ColorWriteMask, VkBool32 extendedDynamicState3RasterizationStream, VkBool32 extendedDynamicState3ConservativeRasterizationMode, VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize, VkBool32 extendedDynamicState3DepthClipEnable, VkBool32 extendedDynamicState3SampleLocationsEnable, VkBool32 extendedDynamicState3ColorBlendAdvanced, VkBool32 extendedDynamicState3ProvokingVertexMode, VkBool32 extendedDynamicState3LineRasterizationMode, VkBool32 extendedDynamicState3LineStippleEnable, VkBool32 extendedDynamicState3DepthClipNegativeOneToOne, VkBool32 extendedDynamicState3ViewportWScalingEnable, VkBool32 extendedDynamicState3ViewportSwizzle, VkBool32 extendedDynamicState3CoverageToColorEnable, VkBool32 extendedDynamicState3CoverageToColorLocation, VkBool32 extendedDynamicState3CoverageModulationMode, VkBool32 extendedDynamicState3CoverageModulationTableEnable, VkBool32 extendedDynamicState3CoverageModulationTable, VkBool32 extendedDynamicState3CoverageReductionMode, VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable, VkBool32 extendedDynamicState3ShadingRateImageEnable) : this() + { + this.pNext = pNext; + this.extendedDynamicState3TessellationDomainOrigin = extendedDynamicState3TessellationDomainOrigin; + this.extendedDynamicState3DepthClampEnable = extendedDynamicState3DepthClampEnable; + this.extendedDynamicState3PolygonMode = extendedDynamicState3PolygonMode; + this.extendedDynamicState3RasterizationSamples = extendedDynamicState3RasterizationSamples; + this.extendedDynamicState3SampleMask = extendedDynamicState3SampleMask; + this.extendedDynamicState3AlphaToCoverageEnable = extendedDynamicState3AlphaToCoverageEnable; + this.extendedDynamicState3AlphaToOneEnable = extendedDynamicState3AlphaToOneEnable; + this.extendedDynamicState3LogicOpEnable = extendedDynamicState3LogicOpEnable; + this.extendedDynamicState3ColorBlendEnable = extendedDynamicState3ColorBlendEnable; + this.extendedDynamicState3ColorBlendEquation = extendedDynamicState3ColorBlendEquation; + this.extendedDynamicState3ColorWriteMask = extendedDynamicState3ColorWriteMask; + this.extendedDynamicState3RasterizationStream = extendedDynamicState3RasterizationStream; + this.extendedDynamicState3ConservativeRasterizationMode = extendedDynamicState3ConservativeRasterizationMode; + this.extendedDynamicState3ExtraPrimitiveOverestimationSize = extendedDynamicState3ExtraPrimitiveOverestimationSize; + this.extendedDynamicState3DepthClipEnable = extendedDynamicState3DepthClipEnable; + this.extendedDynamicState3SampleLocationsEnable = extendedDynamicState3SampleLocationsEnable; + this.extendedDynamicState3ColorBlendAdvanced = extendedDynamicState3ColorBlendAdvanced; + this.extendedDynamicState3ProvokingVertexMode = extendedDynamicState3ProvokingVertexMode; + this.extendedDynamicState3LineRasterizationMode = extendedDynamicState3LineRasterizationMode; + this.extendedDynamicState3LineStippleEnable = extendedDynamicState3LineStippleEnable; + this.extendedDynamicState3DepthClipNegativeOneToOne = extendedDynamicState3DepthClipNegativeOneToOne; + this.extendedDynamicState3ViewportWScalingEnable = extendedDynamicState3ViewportWScalingEnable; + this.extendedDynamicState3ViewportSwizzle = extendedDynamicState3ViewportSwizzle; + this.extendedDynamicState3CoverageToColorEnable = extendedDynamicState3CoverageToColorEnable; + this.extendedDynamicState3CoverageToColorLocation = extendedDynamicState3CoverageToColorLocation; + this.extendedDynamicState3CoverageModulationMode = extendedDynamicState3CoverageModulationMode; + this.extendedDynamicState3CoverageModulationTableEnable = extendedDynamicState3CoverageModulationTableEnable; + this.extendedDynamicState3CoverageModulationTable = extendedDynamicState3CoverageModulationTable; + this.extendedDynamicState3CoverageReductionMode = extendedDynamicState3CoverageReductionMode; + this.extendedDynamicState3RepresentativeFragmentTestEnable = extendedDynamicState3RepresentativeFragmentTestEnable; + this.extendedDynamicState3ShadingRateImageEnable = extendedDynamicState3ShadingRateImageEnable; + } +} + +[CRepr] struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dynamicPrimitiveTopologyUnrestricted = false; +} + +[CRepr] struct VkColorBlendEquationEXT : this() +{ + public VkBlendFactor srcColorBlendFactor = default; + public VkBlendFactor dstColorBlendFactor = default; + public VkBlendOp colorBlendOp = default; + public VkBlendFactor srcAlphaBlendFactor = default; + public VkBlendFactor dstAlphaBlendFactor = default; + public VkBlendOp alphaBlendOp = default; + + public this(VkBlendFactor srcColorBlendFactor, VkBlendFactor dstColorBlendFactor, VkBlendOp colorBlendOp, VkBlendFactor srcAlphaBlendFactor, VkBlendFactor dstAlphaBlendFactor, VkBlendOp alphaBlendOp) : this() + { + this.srcColorBlendFactor = srcColorBlendFactor; + this.dstColorBlendFactor = dstColorBlendFactor; + this.colorBlendOp = colorBlendOp; + this.srcAlphaBlendFactor = srcAlphaBlendFactor; + this.dstAlphaBlendFactor = dstAlphaBlendFactor; + this.alphaBlendOp = alphaBlendOp; + } +} + +[CRepr] struct VkColorBlendAdvancedEXT : this() +{ + public VkBlendOp advancedBlendOp = default; + public VkBool32 srcPremultiplied = false; + public VkBool32 dstPremultiplied = false; + public VkBlendOverlapEXT blendOverlap = default; + public VkBool32 clampResults = false; + + public this(VkBlendOp advancedBlendOp, VkBool32 srcPremultiplied, VkBool32 dstPremultiplied, VkBlendOverlapEXT blendOverlap, VkBool32 clampResults) : this() + { + this.advancedBlendOp = advancedBlendOp; + this.srcPremultiplied = srcPremultiplied; + this.dstPremultiplied = dstPremultiplied; + this.blendOverlap = blendOverlap; + this.clampResults = clampResults; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, VkSampleMask* pSampleMask = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkBool32* pColorBlendEnables); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorBlendEquationEXT* pColorBlendEquations); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorComponentFlags* pColorWriteMasks); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32 rasterizationStream); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32 firstAttachment, uint32 attachmentCount, VkColorBlendAdvancedEXT* pColorBlendAdvanced); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32 firstViewport, uint32 viewportCount, VkViewportSwizzleNV* pViewportSwizzles); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32 coverageToColorLocation); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32 coverageModulationTableCount, float* pCoverageModulationTable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); + +static { public const let VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION = 2; } +static { public const let VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME = "VK_EXT_subpass_merge_feedback"; } + +[CRepr] struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 subpassMergeFeedback = false; + + public this(void* pNext, VkBool32 subpassMergeFeedback) : this() + { + this.pNext = pNext; + this.subpassMergeFeedback = subpassMergeFeedback; + } +} + +[CRepr] struct VkRenderPassCreationControlEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 disallowMerging = false; + + public this(void* pNext, VkBool32 disallowMerging) : this() + { + this.pNext = pNext; + this.disallowMerging = disallowMerging; + } +} + +[CRepr] struct VkRenderPassCreationFeedbackInfoEXT : this() +{ + public uint32 postMergeSubpassCount = 0; +} + +[CRepr] struct VkRenderPassCreationFeedbackCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback = null; + + public this(void* pNext, VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback) : this() + { + this.pNext = pNext; + this.pRenderPassFeedback = pRenderPassFeedback; + } +} + +[CRepr] struct VkRenderPassSubpassFeedbackInfoEXT : this() +{ + public VkSubpassMergeStatusEXT subpassMergeStatus = default; + public char8[VK_MAX_DESCRIPTION_SIZE] description = .(); + public uint32 postMergeIndex = 0; +} + +[CRepr] struct VkRenderPassSubpassFeedbackCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback = null; + + public this(void* pNext, VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback) : this() + { + this.pNext = pNext; + this.pSubpassFeedback = pSubpassFeedback; + } +} + +[AllowDuplicates] enum VkSubpassMergeStatusEXT : int32 +{ + [NoShow] VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, + [NoShow] VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, + [NoShow] VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, + // pretty names + MergedEXT = 0, + DisallowedEXT = 1, + NotMergedSideEffectsEXT = 2, + NotMergedSamplesMismatchEXT = 3, + NotMergedViewsMismatchEXT = 4, + NotMergedAliasingEXT = 5, + NotMergedDependenciesEXT = 6, + NotMergedIncompatibleInputAttachmentEXT = 7, + NotMergedTooManyAttachmentsEXT = 8, + NotMergedInsufficientStorageEXT = 9, + NotMergedDepthStencilCountEXT = 10, + NotMergedResolveAttachmentReuseEXT = 11, + NotMergedSingleSubpassEXT = 12, + NotMergedUnspecifiedEXT = 13, +} + +static { public const let VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION = 1; } +static { public const let VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME = "VK_LUNARG_direct_driver_loading"; } + +typealias VkDirectDriverLoadingFlagsLUNARG = VkFlags; + +[AllowDuplicates] enum VkDirectDriverLoadingModeLUNARG : int32 +{ + [NoShow] VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + [NoShow] VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, + // pretty names + ExclusiveLUNARG = 0, + InclusiveLUNARG = 1, +} + +[CRepr] struct VkDirectDriverLoadingInfoLUNARG : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDirectDriverLoadingFlagsLUNARG flags = default; + public PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = default; + + public this(void* pNext, VkDirectDriverLoadingFlagsLUNARG flags, PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pfnGetInstanceProcAddr = pfnGetInstanceProcAddr; + } +} + +[CRepr] struct VkDirectDriverLoadingListLUNARG : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDirectDriverLoadingModeLUNARG mode = default; + public uint32 driverCount = 0; + public VkDirectDriverLoadingInfoLUNARG* pDrivers = null; + public Span drivers + { + get { return .(pDrivers, (.)driverCount); } + set mut { pDrivers = value.Ptr; driverCount = (.)value.Length; } + } + + public this(void* pNext, VkDirectDriverLoadingModeLUNARG mode, Span drivers) : this() + { + this.pNext = pNext; + this.mode = mode; + this.drivers = drivers; + } +} + +[CallingConvention(VKAPI_PTR)] function PFN_vkVoidFunction PFN_vkGetInstanceProcAddrLUNARG( + 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"; } + +struct VkTensorARM : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_TENSOR_ARM; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +struct VkTensorViewARM : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_TENSOR_VIEW_ARM; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +typealias VkTensorCreateFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkTensorCreateFlagBitsARM : int32 +{ + [NoShow] VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM = 1 << 0, + [NoShow] VK_TENSOR_CREATE_PROTECTED_BIT_ARM = 1 << 1, + [NoShow] VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 1 << 2, + // pretty names + MutableFormatARM = 1 << 0, + ProtectedARM = 1 << 1, + DescriptorBufferCaptureReplayARM = 1 << 2, +} + +typealias VkTensorViewCreateFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkTensorViewCreateFlagBitsARM : int32 +{ + [NoShow] VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 1 << 0, + // pretty names + DescriptorBufferCaptureReplayARM = 1 << 0, +} + +typealias VkTensorUsageFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkTensorUsageFlagBitsARM : int32 +{ + [NoShow] VK_TENSOR_USAGE_SHADER_BIT_ARM = 1 << 1, // Tensor written/read through shader descriptor + [NoShow] VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM = 1 << 2, // Tensor can be src of a transfer operation + [NoShow] VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM = 1 << 3, // Tensor can be dst of a transfer operation + [NoShow] VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM = 1 << 4, // Tensor can be aliased with an image + [NoShow] VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM = 1 << 5, + // pretty names + ShaderARM = 1 << 1, // Tensor written/read through shader descriptor + TransferSrcARM = 1 << 2, // Tensor can be src of a transfer operation + TransferDstARM = 1 << 3, // Tensor can be dst of a transfer operation + ImageAliasingARM = 1 << 4, // Tensor can be aliased with an image + DataGraphARM = 1 << 5, +} + +[CRepr] struct VkTensorDescriptionARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorTilingARM tiling = default; + public VkFormat format = default; + public uint32 dimensionCount = 0; + public int64* pDimensions = null; + public int64* pStrides = null; + public VkTensorUsageFlagsARM usage = default; + + public this(void* pNext, VkTensorTilingARM tiling, VkFormat format, uint32 dimensionCount, int64* pDimensions, int64* pStrides, VkTensorUsageFlagsARM usage) : this() + { + this.pNext = pNext; + this.tiling = tiling; + this.format = format; + this.dimensionCount = dimensionCount; + this.pDimensions = pDimensions; + this.pStrides = pStrides; + this.usage = usage; + } +} + +[AllowDuplicates] enum VkTensorTilingARM : int32 +{ + [NoShow] VK_TENSOR_TILING_OPTIMAL_ARM = 0, + [NoShow] VK_TENSOR_TILING_LINEAR_ARM = 1, + // pretty names + OptimalARM = 0, + LinearARM = 1, +} + +[CRepr] struct VkTensorCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorCreateFlagsARM flags = default; + public VkTensorDescriptionARM* pDescription = null; + public VkSharingMode sharingMode = default; + public uint32 queueFamilyIndexCount = 0; + public uint32* pQueueFamilyIndices = null; + public Span queueFamilyIndices + { + get { return .(pQueueFamilyIndices, (.)queueFamilyIndexCount); } + set mut { pQueueFamilyIndices = value.Ptr; queueFamilyIndexCount = (.)value.Length; } + } + + public this(void* pNext, VkTensorCreateFlagsARM flags, VkTensorDescriptionARM* pDescription, VkSharingMode sharingMode, Span queueFamilyIndices = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pDescription = pDescription; + this.sharingMode = sharingMode; + this.queueFamilyIndices = queueFamilyIndices; + } +} + +[CRepr] struct VkTensorViewCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorViewCreateFlagsARM flags = default; + public VkTensorARM tensor = null; + public VkFormat format = default; + + public this(void* pNext, VkTensorViewCreateFlagsARM flags, VkTensorARM tensor, VkFormat format) : this() + { + this.pNext = pNext; + this.flags = flags; + this.tensor = tensor; + this.format = format; + } +} + +[CRepr] struct VkTensorMemoryRequirementsInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorARM tensor = null; + + public this(void* pNext, VkTensorARM tensor) : this() + { + this.pNext = pNext; + this.tensor = tensor; + } +} + +[CRepr] struct VkBindTensorMemoryInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorARM tensor = null; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + + public this(void* pNext, VkTensorARM tensor, VkDeviceMemory memory, VkDeviceSize memoryOffset) : this() + { + this.pNext = pNext; + this.tensor = tensor; + this.memory = memory; + this.memoryOffset = memoryOffset; + } +} + +[CRepr] struct VkWriteDescriptorSetTensorARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 tensorViewCount = 0; + public VkTensorViewARM* pTensorViews = null; + public Span tensorViews + { + get { return .(pTensorViews, (.)tensorViewCount); } + set mut { pTensorViews = value.Ptr; tensorViewCount = (.)value.Length; } + } + + public this(void* pNext, Span tensorViews) : this() + { + this.pNext = pNext; + this.tensorViews = tensorViews; + } +} + +[CRepr] struct VkTensorFormatPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormatFeatureFlags2 optimalTilingTensorFeatures = default; + public VkFormatFeatureFlags2 linearTilingTensorFeatures = default; +} + +[CRepr] struct VkPhysicalDeviceTensorPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxTensorDimensionCount = 0; + public uint64 maxTensorElements = 0; + public uint64 maxPerDimensionTensorElements = 0; + public int64 maxTensorStride = 0; + public uint64 maxTensorSize = 0; + public uint32 maxTensorShaderAccessArrayLength = 0; + public uint32 maxTensorShaderAccessSize = 0; + public uint32 maxDescriptorSetStorageTensors = 0; + public uint32 maxPerStageDescriptorSetStorageTensors = 0; + public uint32 maxDescriptorSetUpdateAfterBindStorageTensors = 0; + public uint32 maxPerStageDescriptorUpdateAfterBindStorageTensors = 0; + public VkBool32 shaderStorageTensorArrayNonUniformIndexingNative = false; + public VkShaderStageFlags shaderTensorSupportedStages = default; +} + +[CRepr] struct VkTensorMemoryBarrierARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineStageFlags2 srcStageMask = default; + public VkAccessFlags2 srcAccessMask = default; + public VkPipelineStageFlags2 dstStageMask = default; + public VkAccessFlags2 dstAccessMask = default; + public uint32 srcQueueFamilyIndex = 0; + public uint32 dstQueueFamilyIndex = 0; + public VkTensorARM tensor = null; + + public this(void* pNext, VkPipelineStageFlags2 srcStageMask, VkAccessFlags2 srcAccessMask, VkPipelineStageFlags2 dstStageMask, VkAccessFlags2 dstAccessMask, uint32 srcQueueFamilyIndex, uint32 dstQueueFamilyIndex, VkTensorARM tensor) : this() + { + this.pNext = pNext; + this.srcStageMask = srcStageMask; + this.srcAccessMask = srcAccessMask; + this.dstStageMask = dstStageMask; + this.dstAccessMask = dstAccessMask; + this.srcQueueFamilyIndex = srcQueueFamilyIndex; + this.dstQueueFamilyIndex = dstQueueFamilyIndex; + this.tensor = tensor; + } +} + +[CRepr] struct VkTensorDependencyInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 tensorMemoryBarrierCount = 0; + public VkTensorMemoryBarrierARM* pTensorMemoryBarriers = null; + + public this(void* pNext, uint32 tensorMemoryBarrierCount, VkTensorMemoryBarrierARM* pTensorMemoryBarriers) : this() + { + this.pNext = pNext; + this.tensorMemoryBarrierCount = tensorMemoryBarrierCount; + this.pTensorMemoryBarriers = pTensorMemoryBarriers; + } +} + +[CRepr] struct VkPhysicalDeviceTensorFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 tensorNonPacked = false; + public VkBool32 shaderTensorAccess = false; + public VkBool32 shaderStorageTensorArrayDynamicIndexing = false; + public VkBool32 shaderStorageTensorArrayNonUniformIndexing = false; + public VkBool32 descriptorBindingStorageTensorUpdateAfterBind = false; + public VkBool32 tensors = false; + + public this(void* pNext, VkBool32 tensorNonPacked, VkBool32 shaderTensorAccess, VkBool32 shaderStorageTensorArrayDynamicIndexing, VkBool32 shaderStorageTensorArrayNonUniformIndexing, VkBool32 descriptorBindingStorageTensorUpdateAfterBind, VkBool32 tensors) : this() + { + this.pNext = pNext; + this.tensorNonPacked = tensorNonPacked; + this.shaderTensorAccess = shaderTensorAccess; + this.shaderStorageTensorArrayDynamicIndexing = shaderStorageTensorArrayDynamicIndexing; + this.shaderStorageTensorArrayNonUniformIndexing = shaderStorageTensorArrayNonUniformIndexing; + this.descriptorBindingStorageTensorUpdateAfterBind = descriptorBindingStorageTensorUpdateAfterBind; + this.tensors = tensors; + } +} + +[CRepr] struct VkDeviceTensorMemoryRequirementsARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorCreateInfoARM* pCreateInfo = null; + + public this(void* pNext, VkTensorCreateInfoARM* pCreateInfo) : this() + { + this.pNext = pNext; + this.pCreateInfo = pCreateInfo; + } +} + +[CRepr] struct VkCopyTensorInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorARM srcTensor = null; + public VkTensorARM dstTensor = null; + public uint32 regionCount = 0; + public VkTensorCopyARM* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkTensorARM srcTensor, VkTensorARM dstTensor, Span regions) : this() + { + this.pNext = pNext; + this.srcTensor = srcTensor; + this.dstTensor = dstTensor; + this.regions = regions; + } +} + +[CRepr] struct VkTensorCopyARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 dimensionCount = 0; + public uint64* pSrcOffset = null; + public uint64* pDstOffset = null; + public uint64* pExtent = null; + + public this(void* pNext = null, uint32 dimensionCount = 0, uint64* pSrcOffset = null, uint64* pDstOffset = null, uint64* pExtent = null) : this() + { + this.pNext = pNext; + this.dimensionCount = dimensionCount; + this.pSrcOffset = pSrcOffset; + this.pDstOffset = pDstOffset; + this.pExtent = pExtent; + } +} + +[CRepr] struct VkMemoryDedicatedAllocateInfoTensorARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorARM tensor = null; // Tensor that this allocation will be bound to + + public this(void* pNext, VkTensorARM tensor) : this() + { + this.pNext = pNext; + this.tensor = tensor; + } +} + +[CRepr] struct VkPhysicalDeviceExternalTensorInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorCreateFlagsARM flags = default; + public VkTensorDescriptionARM* pDescription = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkTensorCreateFlagsARM flags, VkTensorDescriptionARM* pDescription, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.flags = flags; + this.pDescription = pDescription; + this.handleType = handleType; + } +} + +[CRepr] struct VkExternalTensorPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryProperties externalMemoryProperties = default; + + public this(void* pNext, VkExternalMemoryProperties externalMemoryProperties) : this() + { + this.pNext = pNext; + this.externalMemoryProperties = externalMemoryProperties; + } +} + +[CRepr] struct VkExternalMemoryTensorCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlags handleTypes = default; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlags handleTypes = default) : this() + { + this.pNext = pNext; + this.handleTypes = handleTypes; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateTensorARM(VkDevice device, VkTensorCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkTensorARM pTensor); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateTensorViewARM(VkDevice device, VkTensorViewCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkTensorViewARM pView); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetTensorMemoryRequirementsARM(VkDevice device, VkTensorMemoryRequirementsInfoARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindTensorMemoryARM(VkDevice device, uint32 bindInfoCount, VkBindTensorMemoryInfoARM* pBindInfos); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, VkDeviceTensorMemoryRequirementsARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, VkCopyTensorInfoARM* pCopyTensorInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, out VkExternalTensorPropertiesARM pExternalTensorProperties); + +[CRepr] struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 descriptorBufferTensorDescriptors = false; + + public this(void* pNext, VkBool32 descriptorBufferTensorDescriptors) : this() + { + this.pNext = pNext; + this.descriptorBufferTensorDescriptors = descriptorBufferTensorDescriptors; + } +} + +[CRepr] struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size tensorCaptureReplayDescriptorDataSize = 0; + public c_size tensorViewCaptureReplayDescriptorDataSize = 0; + public c_size tensorDescriptorSize = 0; + + public this(void* pNext, c_size tensorCaptureReplayDescriptorDataSize, c_size tensorViewCaptureReplayDescriptorDataSize, c_size tensorDescriptorSize) : this() + { + this.pNext = pNext; + this.tensorCaptureReplayDescriptorDataSize = tensorCaptureReplayDescriptorDataSize; + this.tensorViewCaptureReplayDescriptorDataSize = tensorViewCaptureReplayDescriptorDataSize; + this.tensorDescriptorSize = tensorDescriptorSize; + } +} + +[CRepr] struct VkDescriptorGetTensorInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorViewARM tensorView = null; + + public this(void* pNext = null, VkTensorViewARM tensorView = null) : this() + { + this.pNext = pNext; + this.tensorView = tensorView; + } +} + +[CRepr] struct VkTensorCaptureDescriptorDataInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorARM tensor = null; + + public this(void* pNext, VkTensorARM tensor) : this() + { + this.pNext = pNext; + this.tensor = tensor; + } +} + +[CRepr] struct VkTensorViewCaptureDescriptorDataInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTensorViewARM tensorView = null; + + public this(void* pNext, VkTensorViewARM tensorView) : this() + { + this.pNext = pNext; + this.tensorView = tensorView; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, VkTensorCaptureDescriptorDataInfoARM* pInfo, out void pData); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, VkTensorViewCaptureDescriptorDataInfoARM* pInfo, out void pData); + +[CRepr] struct VkFrameBoundaryTensorsARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 tensorCount = 0; + public VkTensorARM* pTensors = null; + public Span tensors + { + get { return .(pTensors, (.)tensorCount); } + set mut { pTensors = value.Ptr; tensorCount = (.)value.Length; } + } + + public this(void* pNext, Span tensors) : this() + { + this.pNext = pNext; + this.tensors = tensors; + } +} + +static { public const let VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME = "VK_EXT_shader_module_identifier"; } +static { public const uint32 VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT = 32; } + +[CRepr] struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderModuleIdentifier = false; + + public this(void* pNext, VkBool32 shaderModuleIdentifier) : this() + { + this.pNext = pNext; + this.shaderModuleIdentifier = shaderModuleIdentifier; + } +} + +[CRepr] struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8[VK_UUID_SIZE] shaderModuleIdentifierAlgorithmUUID = .(); +} + +[CRepr] struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 identifierSize = 0; + public uint8* pIdentifier = null; + public Span identifier + { + get { return .(pIdentifier, (.)identifierSize); } + set mut { pIdentifier = value.Ptr; identifierSize = (.)value.Length; } + } + + public this(void* pNext = null, Span identifier = default) : this() + { + this.pNext = pNext; + this.identifier = identifier; + } +} + +[CRepr] struct VkShaderModuleIdentifierEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 identifierSize = 0; + public uint8[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT] identifier = .(); + public Span identifierSpan + { + get mut { return .(&identifier, (.)identifierSize); } + set mut { value.CopyTo(identifier); identifierSize = (.)value.Length; } + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, out VkShaderModuleIdentifierEXT pIdentifier); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, out VkShaderModuleIdentifierEXT pIdentifier); + +static { public const let VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION = 1; } +static { public const let VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME = "VK_EXT_rasterization_order_attachment_access"; } + +[CRepr] struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rasterizationOrderColorAttachmentAccess = false; + public VkBool32 rasterizationOrderDepthAttachmentAccess = false; + public VkBool32 rasterizationOrderStencilAttachmentAccess = false; + + public this(void* pNext, VkBool32 rasterizationOrderColorAttachmentAccess, VkBool32 rasterizationOrderDepthAttachmentAccess, VkBool32 rasterizationOrderStencilAttachmentAccess) : this() + { + this.pNext = pNext; + this.rasterizationOrderColorAttachmentAccess = rasterizationOrderColorAttachmentAccess; + this.rasterizationOrderDepthAttachmentAccess = rasterizationOrderDepthAttachmentAccess; + this.rasterizationOrderStencilAttachmentAccess = rasterizationOrderStencilAttachmentAccess; + } +} + +[AllowDuplicates] enum VkPipelineColorBlendStateCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, + [NoShow] VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 1 << 0, + // pretty names + RasterizationOrderAttachmentAccessARM = RasterizationOrderAttachmentAccessEXT, + RasterizationOrderAttachmentAccessEXT = 1 << 0, +} + +[AllowDuplicates] enum VkPipelineDepthStencilStateCreateFlagBits : int32 +{ + [NoShow] VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + [NoShow] VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + [NoShow] VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 1 << 0, + [NoShow] VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 1 << 1, + // pretty names + RasterizationOrderAttachmentDepthAccessARM = RasterizationOrderAttachmentDepthAccessEXT, + RasterizationOrderAttachmentStencilAccessARM = RasterizationOrderAttachmentStencilAccessEXT, + RasterizationOrderAttachmentDepthAccessEXT = 1 << 0, + RasterizationOrderAttachmentStencilAccessEXT = 1 << 1, +} + +static { public const let VK_NV_OPTICAL_FLOW_SPEC_VERSION = 1; } +static { public const let VK_NV_OPTICAL_FLOW_EXTENSION_NAME = "VK_NV_optical_flow"; } + +[CRepr] struct VkPhysicalDeviceOpticalFlowFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 opticalFlow = false; + + public this(void* pNext, VkBool32 opticalFlow) : this() + { + this.pNext = pNext; + this.opticalFlow = opticalFlow; + } +} + +[CRepr] struct VkPhysicalDeviceOpticalFlowPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes = default; + public VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes = default; + public VkBool32 hintSupported = false; + public VkBool32 costSupported = false; + public VkBool32 bidirectionalFlowSupported = false; + public VkBool32 globalFlowSupported = false; + public uint32 minWidth = 0; + public uint32 minHeight = 0; + public uint32 maxWidth = 0; + public uint32 maxHeight = 0; + public uint32 maxNumRegionsOfInterest = 0; +} + +[AllowDuplicates] enum VkOpticalFlowUsageFlagBitsNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, + [NoShow] VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 1 << 0, + [NoShow] VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 1 << 1, + [NoShow] VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 1 << 2, + [NoShow] VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 1 << 3, + [NoShow] VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 1 << 4, + // pretty names + UnknownNV = 0, + InputNV = 1 << 0, + OutputNV = 1 << 1, + HintNV = 1 << 2, + CostNV = 1 << 3, + GlobalFlowNV = 1 << 4, +} + +typealias VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagBitsNV; + +[CRepr] struct VkOpticalFlowImageFormatInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOpticalFlowUsageFlagsNV usage = default; + + public this(void* pNext, VkOpticalFlowUsageFlagsNV usage) : this() + { + this.pNext = pNext; + this.usage = usage; + } +} + +[CRepr] struct VkOpticalFlowImageFormatPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; +} + +[AllowDuplicates] enum VkOpticalFlowGridSizeFlagBitsNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, + [NoShow] VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 1 << 0, + [NoShow] VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 1 << 1, + [NoShow] VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 1 << 2, + [NoShow] VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 1 << 3, + // pretty names + UnknownNV = 0, + _1x1NV = 1 << 0, + _2x2NV = 1 << 1, + _4x4NV = 1 << 2, + _8x8NV = 1 << 3, +} + +typealias VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagBitsNV; + +[AllowDuplicates] enum VkOpticalFlowPerformanceLevelNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, + [NoShow] VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, + [NoShow] VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, + [NoShow] VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, + // pretty names + UnknownNV = 0, + SlowNV = 1, + MediumNV = 2, + FastNV = 3, +} + +[AllowDuplicates] enum VkOpticalFlowSessionBindingPointNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, + [NoShow] VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, + // pretty names + UnknownNV = 0, + InputNV = 1, + ReferenceNV = 2, + HintNV = 3, + FlowVectorNV = 4, + BackwardFlowVectorNV = 5, + CostNV = 6, + BackwardCostNV = 7, + GlobalFlowNV = 8, +} + +[AllowDuplicates] enum VkOpticalFlowSessionCreateFlagBitsNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 1 << 0, + [NoShow] VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 1 << 1, + [NoShow] VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 1 << 2, + [NoShow] VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 1 << 3, + [NoShow] VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 1 << 4, + // pretty names + EnableHintNV = 1 << 0, + EnableCostNV = 1 << 1, + EnableGlobalFlowNV = 1 << 2, + AllowRegionsNV = 1 << 3, + BothDirectionsNV = 1 << 4, +} + +typealias VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagBitsNV; + +[AllowDuplicates] enum VkOpticalFlowExecuteFlagBitsNV : int32 +{ + [NoShow] VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 1 << 0, + // pretty names + DisableTemporalHintsNV = 1 << 0, +} + +typealias VkOpticalFlowExecuteFlagsNV = VkOpticalFlowExecuteFlagBitsNV; +struct VkOpticalFlowSessionNV : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkOpticalFlowSessionCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 width = 0; + public uint32 height = 0; + public VkFormat imageFormat = default; + public VkFormat flowVectorFormat = default; + public VkFormat costFormat = default; + public VkOpticalFlowGridSizeFlagsNV outputGridSize = default; + public VkOpticalFlowGridSizeFlagsNV hintGridSize = default; + public VkOpticalFlowPerformanceLevelNV performanceLevel = default; + public VkOpticalFlowSessionCreateFlagsNV flags = default; + + public this(void* pNext, uint32 width, uint32 height, VkFormat imageFormat, VkFormat flowVectorFormat, VkFormat costFormat, VkOpticalFlowGridSizeFlagsNV outputGridSize, VkOpticalFlowGridSizeFlagsNV hintGridSize = default, VkOpticalFlowPerformanceLevelNV performanceLevel = default, VkOpticalFlowSessionCreateFlagsNV flags = default) : this() + { + this.pNext = pNext; + this.width = width; + this.height = height; + this.imageFormat = imageFormat; + this.flowVectorFormat = flowVectorFormat; + this.costFormat = costFormat; + this.outputGridSize = outputGridSize; + this.hintGridSize = hintGridSize; + this.performanceLevel = performanceLevel; + this.flags = flags; + } +} + +[CRepr] struct VkOpticalFlowSessionCreatePrivateDataInfoNV : this() +{ + + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 id = 0; + public uint32 size = 0; + public void* pPrivateData = null; + + public this(void* pNext, uint32 id, uint32 size, void* pPrivateData) : this() + { + this.pNext = pNext; + this.id = id; + this.size = size; + this.pPrivateData = pPrivateData; + } +} + +[CRepr] struct VkOpticalFlowExecuteInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOpticalFlowExecuteFlagsNV flags = default; + public uint32 regionCount = 0; + public VkRect2D* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext = null, VkOpticalFlowExecuteFlagsNV flags = default, Span regions = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.regions = regions; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, out uint32 pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkOpticalFlowSessionNV pSession); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, VkOpticalFlowExecuteInfoNV* pExecuteInfo); + +static { public const let VK_EXT_LEGACY_DITHERING_SPEC_VERSION = 2; } +static { public const let VK_EXT_LEGACY_DITHERING_EXTENSION_NAME = "VK_EXT_legacy_dithering"; } + +[CRepr] struct VkPhysicalDeviceLegacyDitheringFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 legacyDithering = false; + + public this(void* pNext, VkBool32 legacyDithering) : this() + { + this.pNext = pNext; + this.legacyDithering = legacyDithering; + } +} + +static { public const let VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION = 1; } +static { public const let VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME = "VK_EXT_pipeline_protected_access"; } + +typealias VkPhysicalDevicePipelineProtectedAccessFeaturesEXT = VkPhysicalDevicePipelineProtectedAccessFeatures; + +static { public const let VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION = 1; } +static { public const let VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME = "VK_ANDROID_external_format_resolve"; } + +[CRepr] struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 externalFormatResolve = false; + + public this(void* pNext, VkBool32 externalFormatResolve) : this() + { + this.pNext = pNext; + this.externalFormatResolve = externalFormatResolve; + } +} + +[CRepr] struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 nullColorAttachmentWithExternalFormatResolve = false; + public VkChromaLocation externalFormatResolveChromaOffsetX = default; + public VkChromaLocation externalFormatResolveChromaOffsetY = default; +} + +[CRepr] struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat colorAttachmentFormat = default; +} + +static { public const let VK_KHR_MAINTENANCE_5_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_5_EXTENSION_NAME = "VK_KHR_maintenance5"; } + +typealias VkPhysicalDeviceMaintenance5FeaturesKHR = VkPhysicalDeviceMaintenance5Features; +typealias VkPhysicalDeviceMaintenance5PropertiesKHR = VkPhysicalDeviceMaintenance5Properties; + +typealias PFN_vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2; +typealias PFN_vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularity; + +typealias VkRenderingAreaInfoKHR = VkRenderingAreaInfo; + +typealias PFN_vkGetDeviceImageSubresourceLayoutKHR = PFN_vkGetDeviceImageSubresourceLayout; +typealias PFN_vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2; + +typealias VkDeviceImageSubresourceInfoKHR = VkDeviceImageSubresourceInfo; +typealias VkImageSubresource2KHR = VkImageSubresource2; +typealias VkSubresourceLayout2KHR = VkSubresourceLayout2; + +// Split off new 64-bit flags separately, for the moment +typealias VkPipelineCreateFlags2KHR = VkPipelineCreateFlags2; +typealias VkPipelineCreateFlagBits2KHR = VkPipelineCreateFlagBits2; +typealias VkPipelineCreateFlags2CreateInfoKHR = VkPipelineCreateFlags2CreateInfo; +typealias VkBufferUsageFlags2KHR = VkBufferUsageFlags2; +typealias VkBufferUsageFlagBits2KHR = VkBufferUsageFlagBits2; +typealias VkBufferUsageFlags2CreateInfoKHR = VkBufferUsageFlags2CreateInfo; + +static { public const let VK_AMD_ANTI_LAG_SPEC_VERSION = 1; } +static { public const let VK_AMD_ANTI_LAG_EXTENSION_NAME = "VK_AMD_anti_lag"; } + +[CRepr] struct VkPhysicalDeviceAntiLagFeaturesAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 antiLag = false; + + public this(void* pNext, VkBool32 antiLag) : this() + { + this.pNext = pNext; + this.antiLag = antiLag; + } +} + +[CRepr] struct VkAntiLagDataAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAntiLagModeAMD mode = default; + public uint32 maxFPS = 0; + public VkAntiLagPresentationInfoAMD* pPresentationInfo = null; + + public this(void* pNext, VkAntiLagModeAMD mode, uint32 maxFPS, VkAntiLagPresentationInfoAMD* pPresentationInfo = null) : this() + { + this.pNext = pNext; + this.mode = mode; + this.maxFPS = maxFPS; + this.pPresentationInfo = pPresentationInfo; + } +} + +[CRepr] struct VkAntiLagPresentationInfoAMD : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAntiLagStageAMD stage = default; + public uint64 frameIndex = 0; + + public this(void* pNext, VkAntiLagStageAMD stage, uint64 frameIndex) : this() + { + this.pNext = pNext; + this.stage = stage; + this.frameIndex = frameIndex; + } +} + +[AllowDuplicates] enum VkAntiLagModeAMD : int32 +{ + [NoShow] VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD = 0, + [NoShow] VK_ANTI_LAG_MODE_ON_AMD = 1, + [NoShow] VK_ANTI_LAG_MODE_OFF_AMD = 2, + // pretty names + DriverControlAMD = 0, + OnAMD = 1, + OffAMD = 2, +} + +[AllowDuplicates] enum VkAntiLagStageAMD : int32 +{ + [NoShow] VK_ANTI_LAG_STAGE_INPUT_AMD = 0, + [NoShow] VK_ANTI_LAG_STAGE_PRESENT_AMD = 1, + // pretty names + InputAMD = 0, + PresentAMD = 1, +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkAntiLagUpdateAMD(VkDevice device, VkAntiLagDataAMD* pData); + +static { public const let VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION = 1; } +static { public const let VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME = "VK_AMDX_dense_geometry_format"; } + +[CRepr] struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 denseGeometryFormat = false; + + public this(void* pNext, VkBool32 denseGeometryFormat) : this() + { + this.pNext = pNext; + this.denseGeometryFormat = denseGeometryFormat; + } +} + +[CRepr] struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceOrHostAddressConstKHR compressedData = default; + public VkDeviceSize dataSize = default; + public uint32 numTriangles = 0; + public uint32 numVertices = 0; + public uint32 maxPrimitiveIndex = 0; + public uint32 maxGeometryIndex = 0; + public VkCompressedTriangleFormatAMDX format = default; + + public this(void* pNext, VkDeviceOrHostAddressConstKHR compressedData, VkDeviceSize dataSize, uint32 numTriangles, uint32 numVertices, uint32 maxPrimitiveIndex, uint32 maxGeometryIndex, VkCompressedTriangleFormatAMDX format) : this() + { + this.pNext = pNext; + this.compressedData = compressedData; + this.dataSize = dataSize; + this.numTriangles = numTriangles; + this.numVertices = numVertices; + this.maxPrimitiveIndex = maxPrimitiveIndex; + this.maxGeometryIndex = maxGeometryIndex; + this.format = format; + } +} + +[AllowDuplicates] enum VkCompressedTriangleFormatAMDX : int32 +{ + [NoShow] VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0, + // pretty names + Dgf1AMDX = 0, +} + +static { public const uint32 VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX = 128; } +static { public const uint32 VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX = 128; } +static { public const let VK_KHR_PRESENT_ID_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_PRESENT_ID_2_EXTENSION_NAME = "VK_KHR_present_id2"; } + +[CRepr] struct VkSurfaceCapabilitiesPresentId2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentId2Supported = false; + + public this(void* pNext, VkBool32 presentId2Supported) : this() + { + this.pNext = pNext; + this.presentId2Supported = presentId2Supported; + } +} + +[CRepr] struct VkPresentId2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public uint64* pPresentIds = null; // Present ID values for each swapchain + public Span presentIds + { + get { return .(pPresentIds, (.)swapchainCount); } + set mut { pPresentIds = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span presentIds = default) : this() + { + this.pNext = pNext; + this.presentIds = presentIds; + } +} + +[CRepr] struct VkPhysicalDevicePresentId2FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentId2 = false; // Present ID2 in VkPresentInfoKHR + + public this(void* pNext, VkBool32 presentId2) : this() + { + this.pNext = pNext; + this.presentId2 = presentId2; + } +} + +static { public const let VK_KHR_PRESENT_WAIT_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME = "VK_KHR_present_wait2"; } + +[CRepr] struct VkSurfaceCapabilitiesPresentWait2KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentWait2Supported = false; + + public this(void* pNext, VkBool32 presentWait2Supported) : this() + { + this.pNext = pNext; + this.presentWait2Supported = presentWait2Supported; + } +} + +[CRepr] struct VkPhysicalDevicePresentWait2FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentWait2 = false; // vkWaitForPresent2KHR is supported + + public this(void* pNext, VkBool32 presentWait2) : this() + { + this.pNext = pNext; + this.presentWait2 = presentWait2; + } +} + +[CRepr] struct VkPresentWait2InfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 presentId = 0; + public uint64 timeout = 0; + + public this(void* pNext, uint64 presentId, uint64 timeout) : this() + { + this.pNext = pNext; + this.presentId = presentId; + this.timeout = timeout; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, VkPresentWait2InfoKHR* pPresentWait2Info); + +static { public const let VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION = 1; } +static { public const let VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME = "VK_KHR_ray_tracing_position_fetch"; } + +[CRepr] struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingPositionFetch = false; + + public this(void* pNext, VkBool32 rayTracingPositionFetch) : this() + { + this.pNext = pNext; + this.rayTracingPositionFetch = rayTracingPositionFetch; + } +} + +static { public const let VK_EXT_SHADER_OBJECT_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_OBJECT_EXTENSION_NAME = "VK_EXT_shader_object"; } + +struct VkShaderEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_SHADER_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkShaderCreateFlagBitsEXT : int32 +{ + [NoShow] VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 1 << 0, + [NoShow] VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 1 << 1, + [NoShow] VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 1 << 2, + [NoShow] VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 1 << 3, + [NoShow] VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 1 << 4, + [NoShow] VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 1 << 5, + [NoShow] VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 1 << 6, + [NoShow] VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 1 << 7, + [NoShow] VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 1 << 15, + // pretty names + LinkStageEXT = 1 << 0, + AllowVaryingSubgroupSizeEXT = 1 << 1, + RequireFullSubgroupsEXT = 1 << 2, + NoTaskShaderEXT = 1 << 3, + DispatchBaseEXT = 1 << 4, + FragmentShadingRateAttachmentEXT = 1 << 5, + FragmentDensityMapAttachmentEXT = 1 << 6, + IndirectBindableEXT = 1 << 7, + _64_BitIndexingEXT = 1 << 15, +} + +typealias VkShaderCreateFlagsEXT = VkShaderCreateFlagBitsEXT; + +[AllowDuplicates] enum VkShaderCodeTypeEXT : int32 +{ + [NoShow] VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + [NoShow] VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + // pretty names + BinaryEXT = 0, + SpirvEXT = 1, +} + +[CRepr] struct VkPhysicalDeviceShaderObjectFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderObject = false; + + public this(void* pNext, VkBool32 shaderObject) : this() + { + this.pNext = pNext; + this.shaderObject = shaderObject; + } +} + +[CRepr] struct VkPhysicalDeviceShaderObjectPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint8[VK_UUID_SIZE] shaderBinaryUUID = .(); + public uint32 shaderBinaryVersion = 0; +} + +[CRepr] struct VkShaderCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderCreateFlagsEXT flags = default; + public VkShaderStageFlagBits stage = default; + public VkShaderStageFlags nextStage = default; + public VkShaderCodeTypeEXT codeType = default; + public c_size codeSize = 0; + public void* pCode = null; + public Span code + { + get { return .(pCode, (.)codeSize); } + set mut { pCode = value.Ptr; codeSize = (.)value.Length; } + } + public char8* pName = null; + public uint32 setLayoutCount = 0; + public VkDescriptorSetLayout* pSetLayouts = null; + public Span setLayouts + { + get { return .(pSetLayouts, (.)setLayoutCount); } + set mut { pSetLayouts = value.Ptr; setLayoutCount = (.)value.Length; } + } + public uint32 pushConstantRangeCount = 0; + public VkPushConstantRange* pPushConstantRanges = null; + public Span pushConstantRanges + { + get { return .(pPushConstantRanges, (.)pushConstantRangeCount); } + set mut { pPushConstantRanges = value.Ptr; pushConstantRangeCount = (.)value.Length; } + } + public VkSpecializationInfo* pSpecializationInfo = null; + + public this(void* pNext, VkShaderCreateFlagsEXT flags, VkShaderStageFlagBits stage, VkShaderStageFlags nextStage, VkShaderCodeTypeEXT codeType, Span code, char8* pName = null, Span setLayouts = default, Span pushConstantRanges = default, VkSpecializationInfo* pSpecializationInfo = null) : this() + { + this.pNext = pNext; + this.flags = flags; + this.stage = stage; + this.nextStage = nextStage; + this.codeType = codeType; + this.code = code; + this.pName = pName; + this.setLayouts = setLayouts; + this.pushConstantRanges = pushConstantRanges; + this.pSpecializationInfo = pSpecializationInfo; + } +} + +typealias VkShaderRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateShadersEXT(VkDevice device, uint32 createInfoCount, VkShaderCreateInfoEXT* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkShaderEXT pShaders); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, out c_size pDataSize, void* pData = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32 stageCount, VkShaderStageFlagBits* pStages, VkShaderEXT* pShaders); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, VkDepthClampRangeEXT* pDepthClampRange = null); + +static { public const let VK_KHR_PIPELINE_BINARY_SPEC_VERSION = 1; } +static { public const let VK_KHR_PIPELINE_BINARY_EXTENSION_NAME = "VK_KHR_pipeline_binary"; } +static { public const uint32 VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR = 32; } + +[CRepr] struct VkPhysicalDevicePipelineBinaryFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineBinaries = false; + + public this(void* pNext, VkBool32 pipelineBinaries) : this() + { + this.pNext = pNext; + this.pipelineBinaries = pipelineBinaries; + } +} + +[CRepr] struct VkPhysicalDevicePipelineBinaryPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineBinaryInternalCache = false; + public VkBool32 pipelineBinaryInternalCacheControl = false; + public VkBool32 pipelineBinaryPrefersInternalCache = false; + public VkBool32 pipelineBinaryPrecompiledInternalCache = false; + public VkBool32 pipelineBinaryCompressedData = false; +} + +[CRepr] struct VkDevicePipelineBinaryInternalCacheControlKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 disableInternalCache = false; + + public this(void* pNext, VkBool32 disableInternalCache) : this() + { + this.pNext = pNext; + this.disableInternalCache = disableInternalCache; + } +} + +struct VkPipelineBinaryKHR : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkPipelineBinaryKeyKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 keySize = 0; + public uint8[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR] key = .(); + + public this(void* pNext, uint32 keySize, uint8[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR] key) : this() + { + this.pNext = pNext; + this.keySize = keySize; + this.key = key; + } +} + +[CRepr] struct VkPipelineBinaryDataKHR : this() +{ + public c_size dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(Span data) : this() + { + this.data = data; + } +} + +[CRepr] struct VkPipelineBinaryKeysAndDataKHR : this() +{ + public uint32 binaryCount = 0; + public VkPipelineBinaryKeyKHR* pPipelineBinaryKeys = null; + public VkPipelineBinaryDataKHR* pPipelineBinaryData = null; + + public this(uint32 binaryCount, VkPipelineBinaryKeyKHR* pPipelineBinaryKeys, VkPipelineBinaryDataKHR* pPipelineBinaryData) : this() + { + this.binaryCount = binaryCount; + this.pPipelineBinaryKeys = pPipelineBinaryKeys; + this.pPipelineBinaryData = pPipelineBinaryData; + } +} + +[CRepr] struct VkPipelineBinaryCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo = null; + public VkPipeline pipeline = null; + public VkPipelineCreateInfoKHR* pPipelineCreateInfo = null; + + public this(void* pNext = null, VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo = null, VkPipeline pipeline = null, VkPipelineCreateInfoKHR* pPipelineCreateInfo = null) : this() + { + this.pNext = pNext; + this.pKeysAndDataInfo = pKeysAndDataInfo; + this.pipeline = pipeline; + this.pPipelineCreateInfo = pPipelineCreateInfo; + } +} + +[CRepr] struct VkPipelineBinaryInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 binaryCount = 0; + public VkPipelineBinaryKHR* pPipelineBinaries = null; + public Span pipelineBinaries + { + get { return .(pPipelineBinaries, (.)binaryCount); } + set mut { pPipelineBinaries = value.Ptr; binaryCount = (.)value.Length; } + } + + public this(void* pNext = null, Span pipelineBinaries = default) : this() + { + this.pNext = pNext; + this.pipelineBinaries = pipelineBinaries; + } +} + +[CRepr] struct VkReleaseCapturedPipelineDataInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline pipeline = null; + + public this(void* pNext, VkPipeline pipeline) : this() + { + this.pNext = pNext; + this.pipeline = pipeline; + } +} + +[CRepr] struct VkPipelineBinaryDataInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineBinaryKHR pipelineBinary = null; + + public this(void* pNext, VkPipelineBinaryKHR pipelineBinary) : this() + { + this.pNext = pNext; + this.pipelineBinary = pipelineBinary; + } +} + +[CRepr] struct VkPipelineCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CRepr] struct VkPipelineBinaryHandlesInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 pipelineBinaryCount = 0; + public VkPipelineBinaryKHR* pPipelineBinaries = null; + public Span pipelineBinaries + { + get { return .(pPipelineBinaries, (.)pipelineBinaryCount); } + set mut { pPipelineBinaries = value.Ptr; pipelineBinaryCount = (.)value.Length; } + } + + public this(void* pNext, Span pipelineBinaries = default) : this() + { + this.pNext = pNext; + this.pipelineBinaries = pipelineBinaries; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreatePipelineBinariesKHR(VkDevice device, VkPipelineBinaryCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkPipelineBinaryHandlesInfoKHR pBinaries); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineKeyKHR(VkDevice device, VkPipelineCreateInfoKHR* pPipelineCreateInfo, out VkPipelineBinaryKeyKHR pPipelineKey); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPipelineBinaryDataKHR(VkDevice device, VkPipelineBinaryDataInfoKHR* pInfo, out VkPipelineBinaryKeyKHR pPipelineBinaryKey, out c_size pPipelineBinaryDataSize, void* pPipelineBinaryData = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkReleaseCapturedPipelineDataKHR(VkDevice device, VkReleaseCapturedPipelineDataInfoKHR* pInfo, VkAllocationCallbacks* pAllocator = null); + +static { public const let VK_QCOM_TILE_PROPERTIES_SPEC_VERSION = 1; } +static { public const let VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME = "VK_QCOM_tile_properties"; } + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, out uint32 pPropertiesCount, VkTilePropertiesQCOM* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, VkRenderingInfo* pRenderingInfo, out VkTilePropertiesQCOM pProperties); + +[CRepr] struct VkPhysicalDeviceTilePropertiesFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 tileProperties = false; + + public this(void* pNext, VkBool32 tileProperties) : this() + { + this.pNext = pNext; + this.tileProperties = tileProperties; + } +} + +[CRepr] struct VkTilePropertiesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent3D tileSize = default; + public VkExtent2D apronSize = default; + public VkOffset2D origin = default; + + public this(void* pNext, VkExtent3D tileSize, VkExtent2D apronSize, VkOffset2D origin) : this() + { + this.pNext = pNext; + this.tileSize = tileSize; + this.apronSize = apronSize; + this.origin = origin; + } +} + +static { public const let VK_SEC_AMIGO_PROFILING_SPEC_VERSION = 1; } +static { public const let VK_SEC_AMIGO_PROFILING_EXTENSION_NAME = "VK_SEC_amigo_profiling"; } + +[CRepr] struct VkPhysicalDeviceAmigoProfilingFeaturesSEC : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 amigoProfiling = false; + + public this(void* pNext, VkBool32 amigoProfiling) : this() + { + this.pNext = pNext; + this.amigoProfiling = amigoProfiling; + } +} + +[CRepr] struct VkAmigoProfilingSubmitInfoSEC : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 firstDrawTimestamp = 0; + public uint64 swapBufferTimestamp = 0; + + public this(void* pNext, uint64 firstDrawTimestamp, uint64 swapBufferTimestamp) : this() + { + this.pNext = pNext; + this.firstDrawTimestamp = firstDrawTimestamp; + this.swapBufferTimestamp = swapBufferTimestamp; + } +} + +static { public const let VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME = "VK_KHR_surface_maintenance1"; } + +[CRepr] struct VkSurfacePresentModeKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPresentModeKHR presentMode = default; + + public this(void* pNext, VkPresentModeKHR presentMode) : this() + { + this.pNext = pNext; + this.presentMode = presentMode; + } +} + +[AllowDuplicates] enum VkPresentScalingFlagBitsKHR : int32 +{ + [NoShow] VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 1 << 0, + [NoShow] VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, + [NoShow] VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 1 << 1, + [NoShow] VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, + [NoShow] VK_PRESENT_SCALING_STRETCH_BIT_KHR = 1 << 2, + [NoShow] VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR, + // pretty names + OneToOneKHR = 1 << 0, + OneToOneEXT = OneToOneKHR, + AspectRatioStretchKHR = 1 << 1, + AspectRatioStretchEXT = AspectRatioStretchKHR, + StretchKHR = 1 << 2, + StretchEXT = StretchKHR, +} + +typealias VkPresentScalingFlagsKHR = VkPresentScalingFlagBitsKHR; + +[AllowDuplicates] enum VkPresentGravityFlagBitsKHR : int32 +{ + [NoShow] VK_PRESENT_GRAVITY_MIN_BIT_KHR = 1 << 0, + [NoShow] VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR, + [NoShow] VK_PRESENT_GRAVITY_MAX_BIT_KHR = 1 << 1, + [NoShow] VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR, + [NoShow] VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 1 << 2, + [NoShow] VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, + // pretty names + MinKHR = 1 << 0, + MinEXT = MinKHR, + MaxKHR = 1 << 1, + MaxEXT = MaxKHR, + CenteredKHR = 1 << 2, + CenteredEXT = CenteredKHR, +} + +typealias VkPresentGravityFlagsKHR = VkPresentGravityFlagBitsKHR; + +[CRepr] struct VkSurfacePresentScalingCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPresentScalingFlagsKHR supportedPresentScaling = default; + public VkPresentGravityFlagsKHR supportedPresentGravityX = default; + public VkPresentGravityFlagsKHR supportedPresentGravityY = default; + public VkExtent2D minScaledImageExtent = default; // Supported minimum image width and height for the surface when scaling is used + public VkExtent2D maxScaledImageExtent = default; // Supported maximum image width and height for the surface when scaling is used + + public this(void* pNext = null, VkPresentScalingFlagsKHR supportedPresentScaling = default, VkPresentGravityFlagsKHR supportedPresentGravityX = default, VkPresentGravityFlagsKHR supportedPresentGravityY = default, VkExtent2D minScaledImageExtent = default, VkExtent2D maxScaledImageExtent = default) : this() + { + this.pNext = pNext; + this.supportedPresentScaling = supportedPresentScaling; + this.supportedPresentGravityX = supportedPresentGravityX; + this.supportedPresentGravityY = supportedPresentGravityY; + this.minScaledImageExtent = minScaledImageExtent; + this.maxScaledImageExtent = maxScaledImageExtent; + } +} + +[CRepr] struct VkSurfacePresentModeCompatibilityKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 presentModeCount = 0; + public VkPresentModeKHR* pPresentModes = null; // Output list of present modes compatible with the one specified in VkSurfacePresentModeKHR + public Span presentModes + { + get { return .(pPresentModes, (.)presentModeCount); } + set mut { pPresentModes = value.Ptr; presentModeCount = (.)value.Length; } + } + + public this(void* pNext = null, Span presentModes = default) : this() + { + this.pNext = pNext; + this.presentModes = presentModes; + } +} + +static { public const let VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME = "VK_KHR_swapchain_maintenance1"; } + +[CRepr] struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 swapchainMaintenance1 = false; + + public this(void* pNext, VkBool32 swapchainMaintenance1) : this() + { + this.pNext = pNext; + this.swapchainMaintenance1 = swapchainMaintenance1; + } +} + +[CRepr] struct VkSwapchainPresentFenceInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public VkFence* pFences = null; // Fence to signal for each swapchain + public Span fences + { + get { return .(pFences, (.)swapchainCount); } + set mut { pFences = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span fences) : this() + { + this.pNext = pNext; + this.fences = fences; + } +} + +[CRepr] struct VkSwapchainPresentModesCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 presentModeCount = 0; + + public VkPresentModeKHR* pPresentModes = null; + public Span presentModes + { + get { return .(pPresentModes, (.)presentModeCount); } + set mut { pPresentModes = value.Ptr; presentModeCount = (.)value.Length; } + } + + + public this(void* pNext, Span presentModes) : this() + { + this.pNext = pNext; + this.presentModes = presentModes; + } +} + +[CRepr] struct VkSwapchainPresentModeInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 swapchainCount = 0; // Copy of VkPresentInfoKHR::swapchainCount + public VkPresentModeKHR* pPresentModes = null; // Presentation mode for each swapchain + public Span presentModes + { + get { return .(pPresentModes, (.)swapchainCount); } + set mut { pPresentModes = value.Ptr; swapchainCount = (.)value.Length; } + } + + public this(void* pNext, Span presentModes) : this() + { + this.pNext = pNext; + this.presentModes = presentModes; + } +} + +[CRepr] struct VkSwapchainPresentScalingCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPresentScalingFlagsKHR scalingBehavior = default; + public VkPresentGravityFlagsKHR presentGravityX = default; + public VkPresentGravityFlagsKHR presentGravityY = default; + + public this(void* pNext = null, VkPresentScalingFlagsKHR scalingBehavior = default, VkPresentGravityFlagsKHR presentGravityX = default, VkPresentGravityFlagsKHR presentGravityY = default) : this() + { + this.pNext = pNext; + this.scalingBehavior = scalingBehavior; + this.presentGravityX = presentGravityX; + this.presentGravityY = presentGravityY; + } +} + +[CRepr] struct VkReleaseSwapchainImagesInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainKHR swapchain = null; // Swapchain for which images are being released + public uint32 imageIndexCount = 0; // Number of indices to release + public uint32* pImageIndices = null; // Indices of which presentable images to release + public Span imageIndices + { + get { return .(pImageIndices, (.)imageIndexCount); } + set mut { pImageIndices = value.Ptr; imageIndexCount = (.)value.Length; } + } + + public this(void* pNext, VkSwapchainKHR swapchain, Span imageIndices) : this() + { + this.pNext = pNext; + this.swapchain = swapchain; + this.imageIndices = imageIndices; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkReleaseSwapchainImagesKHR(VkDevice device, VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); + +static { public const let VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION = 1; } +static { public const let VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME = "VK_QCOM_multiview_per_view_viewports"; } + +[CRepr] struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multiviewPerViewViewports = false; + + public this(void* pNext, VkBool32 multiviewPerViewViewports) : this() + { + this.pNext = pNext; + this.multiviewPerViewViewports = multiviewPerViewViewports; + } +} + +static { public const let VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION = 1; } +static { public const let VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME = "VK_NV_ray_tracing_invocation_reorder"; } + +typealias VkRayTracingInvocationReorderModeNV = VkRayTracingInvocationReorderModeEXT; + +[CRepr] struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = default; +} + +[CRepr] struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingInvocationReorder = false; + + public this(void* pNext, VkBool32 rayTracingInvocationReorder) : this() + { + this.pNext = pNext; + this.rayTracingInvocationReorder = rayTracingInvocationReorder; + } +} + +static { public const let VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION = 4; } +static { public const let VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME = "VK_NV_cooperative_vector"; } + +[CRepr] struct VkPhysicalDeviceCooperativeVectorPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags cooperativeVectorSupportedStages = default; + public VkBool32 cooperativeVectorTrainingFloat16Accumulation = false; + public VkBool32 cooperativeVectorTrainingFloat32Accumulation = false; + public uint32 maxCooperativeVectorComponents = 0; +} + +[CRepr] struct VkPhysicalDeviceCooperativeVectorFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cooperativeVector = false; + public VkBool32 cooperativeVectorTraining = false; + + public this(void* pNext, VkBool32 cooperativeVector, VkBool32 cooperativeVectorTraining) : this() + { + this.pNext = pNext; + this.cooperativeVector = cooperativeVector; + this.cooperativeVectorTraining = cooperativeVectorTraining; + } +} + +[CRepr] struct VkCooperativeVectorPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkComponentTypeKHR inputType = default; + public VkComponentTypeKHR inputInterpretation = default; + public VkComponentTypeKHR matrixInterpretation = default; + public VkComponentTypeKHR biasInterpretation = default; + public VkComponentTypeKHR resultType = default; + public VkBool32 transpose = false; + + public this(void* pNext, VkComponentTypeKHR inputType, VkComponentTypeKHR inputInterpretation, VkComponentTypeKHR matrixInterpretation, VkComponentTypeKHR biasInterpretation, VkComponentTypeKHR resultType, VkBool32 transpose) : this() + { + this.pNext = pNext; + this.inputType = inputType; + this.inputInterpretation = inputInterpretation; + this.matrixInterpretation = matrixInterpretation; + this.biasInterpretation = biasInterpretation; + this.resultType = resultType; + this.transpose = transpose; + } +} + +[CRepr] struct VkConvertCooperativeVectorMatrixInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size srcSize = 0; + public VkDeviceOrHostAddressConstKHR srcData = default; + public c_size* pDstSize = null; + public VkDeviceOrHostAddressKHR dstData = default; + public VkComponentTypeKHR srcComponentType = default; + public VkComponentTypeKHR dstComponentType = default; + public uint32 numRows = 0; + public uint32 numColumns = 0; + public VkCooperativeVectorMatrixLayoutNV srcLayout = default; + public c_size srcStride = 0; + public VkCooperativeVectorMatrixLayoutNV dstLayout = default; + public c_size dstStride = 0; + + public this(void* pNext, c_size srcSize, VkDeviceOrHostAddressConstKHR srcData, c_size* pDstSize, VkDeviceOrHostAddressKHR dstData, VkComponentTypeKHR srcComponentType, VkComponentTypeKHR dstComponentType, uint32 numRows, uint32 numColumns, VkCooperativeVectorMatrixLayoutNV srcLayout, c_size srcStride, VkCooperativeVectorMatrixLayoutNV dstLayout, c_size dstStride) : this() + { + this.pNext = pNext; + this.srcSize = srcSize; + this.srcData = srcData; + this.pDstSize = pDstSize; + this.dstData = dstData; + this.srcComponentType = srcComponentType; + this.dstComponentType = dstComponentType; + this.numRows = numRows; + this.numColumns = numColumns; + this.srcLayout = srcLayout; + this.srcStride = srcStride; + this.dstLayout = dstLayout; + this.dstStride = dstStride; + } +} + +[AllowDuplicates] enum VkCooperativeVectorMatrixLayoutNV : int32 +{ + [NoShow] VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV = 0, + [NoShow] VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV = 1, + [NoShow] VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV = 2, + [NoShow] VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV = 3, + // pretty names + RowMajorNV = 0, + ColumnMajorNV = 1, + InferencingOptimalNV = 2, + TrainingOptimalNV = 3, +} + +[AllowDuplicates] enum VkComponentTypeKHR : int32 +{ + [NoShow] VK_COMPONENT_TYPE_FLOAT16_KHR = 0, + [NoShow] VK_COMPONENT_TYPE_FLOAT32_KHR = 1, + [NoShow] VK_COMPONENT_TYPE_FLOAT64_KHR = 2, + [NoShow] VK_COMPONENT_TYPE_SINT8_KHR = 3, + [NoShow] VK_COMPONENT_TYPE_SINT16_KHR = 4, + [NoShow] VK_COMPONENT_TYPE_SINT32_KHR = 5, + [NoShow] VK_COMPONENT_TYPE_SINT64_KHR = 6, + [NoShow] VK_COMPONENT_TYPE_UINT8_KHR = 7, + [NoShow] VK_COMPONENT_TYPE_UINT16_KHR = 8, + [NoShow] VK_COMPONENT_TYPE_UINT32_KHR = 9, + [NoShow] VK_COMPONENT_TYPE_UINT64_KHR = 10, + [NoShow] VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000, + [NoShow] VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, + [NoShow] VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, + [NoShow] VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, + [NoShow] VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, + [NoShow] VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, + [NoShow] VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, + [NoShow] VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, + [NoShow] VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, + [NoShow] VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, + [NoShow] VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, + [NoShow] VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + [NoShow] VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000, + [NoShow] VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, + [NoShow] VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, + [NoShow] VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, + [NoShow] VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, + [NoShow] VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, + // pretty names + Float16KHR = 0, + Float32KHR = 1, + Float64KHR = 2, + Sint8KHR = 3, + Sint16KHR = 4, + Sint32KHR = 5, + Sint64KHR = 6, + Uint8KHR = 7, + Uint16KHR = 8, + Uint32KHR = 9, + Uint64KHR = 10, + Bfloat16KHR = 1000141000, + Float16NV = Float16KHR, + Float32NV = Float32KHR, + Float64NV = Float64KHR, + Sint8NV = Sint8KHR, + Sint16NV = Sint16KHR, + Sint32NV = Sint32KHR, + Sint64NV = Sint64KHR, + Uint8NV = Uint8KHR, + Uint16NV = Uint16KHR, + Uint32NV = Uint32KHR, + Uint64NV = Uint64KHR, + Sint8_PackedNV = 1000491000, + Uint8_PackedNV = 1000491001, + FloatE4m3NV = Float8_E4m3EXT, + FloatE5m2NV = Float8_E5m2EXT, + Float8_E4m3EXT = 1000491002, + Float8_E5m2EXT = 1000491003, +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkConvertCooperativeVectorMatrixNV(VkDevice device, VkConvertCooperativeVectorMatrixInfoNV* pInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32 infoCount, VkConvertCooperativeVectorMatrixInfoNV* pInfos); + +static { public const let VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME = "VK_NV_extended_sparse_address_space"; } + +[CRepr] struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 extendedSparseAddressSpace = false; + + public this(void* pNext, VkBool32 extendedSparseAddressSpace) : this() + { + this.pNext = pNext; + this.extendedSparseAddressSpace = extendedSparseAddressSpace; + } +} + +[CRepr] struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize extendedSparseAddressSpaceSize = default; // Total address space available for extended sparse allocations (bytes) + public VkImageUsageFlags extendedSparseImageUsageFlags = default; // Bitfield of which image usages are supported for extended sparse allocations + public VkBufferUsageFlags extendedSparseBufferUsageFlags = default; // Bitfield of which buffer usages are supported for extended sparse allocations +} + +static { public const let VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION = 1; } +static { public const let VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME = "VK_EXT_mutable_descriptor_type"; } + +[CRepr] struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 mutableDescriptorType = false; + + public this(void* pNext, VkBool32 mutableDescriptorType) : this() + { + this.pNext = pNext; + this.mutableDescriptorType = mutableDescriptorType; + } +} + +[CRepr] struct VkMutableDescriptorTypeListEXT : this() +{ + public uint32 descriptorTypeCount = 0; + public VkDescriptorType* pDescriptorTypes = null; + public Span descriptorTypes + { + get { return .(pDescriptorTypes, (.)descriptorTypeCount); } + set mut { pDescriptorTypes = value.Ptr; descriptorTypeCount = (.)value.Length; } + } + + public this(Span descriptorTypes = default) : this() + { + this.descriptorTypes = descriptorTypes; + } +} + +[CRepr] struct VkMutableDescriptorTypeCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 mutableDescriptorTypeListCount = 0; + public VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists = null; + public Span mutableDescriptorTypeLists + { + get { return .(pMutableDescriptorTypeLists, (.)mutableDescriptorTypeListCount); } + set mut { pMutableDescriptorTypeLists = value.Ptr; mutableDescriptorTypeListCount = (.)value.Length; } + } + + public this(void* pNext = null, Span mutableDescriptorTypeLists = default) : this() + { + this.pNext = pNext; + this.mutableDescriptorTypeLists = mutableDescriptorTypeLists; + } +} + +static { public const let VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION = 1; } +static { public const let VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME = "VK_EXT_legacy_vertex_attributes"; } + +[CRepr] struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 legacyVertexAttributes = false; + + public this(void* pNext, VkBool32 legacyVertexAttributes) : this() + { + this.pNext = pNext; + this.legacyVertexAttributes = legacyVertexAttributes; + } +} + +[CRepr] struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 nativeUnalignedPerformance = false; +} + +static { public const let VK_EXT_LAYER_SETTINGS_SPEC_VERSION = 2; } +static { public const let VK_EXT_LAYER_SETTINGS_EXTENSION_NAME = "VK_EXT_layer_settings"; } + +[CRepr] struct VkLayerSettingsCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + public VkStructureType sType = SType; // Must be VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT + public void* pNext = null; + public uint32 settingCount = 0; // Number of settings to configure + public VkLayerSettingEXT* pSettings = null; // Validation features to enable + public Span settings + { + get { return .(pSettings, (.)settingCount); } + set mut { pSettings = value.Ptr; settingCount = (.)value.Length; } + } + + public this(void* pNext = null, Span settings = default) : this() + { + this.pNext = pNext; + this.settings = settings; + } +} + +[CRepr] struct VkLayerSettingEXT : this() +{ + public char8* pLayerName = null; + public char8* pSettingName = null; + public VkLayerSettingTypeEXT type = default; // The type of the object + public uint32 valueCount = 0; // Number of values of the setting + public void* pValues = null; // Values to pass for a setting + public Span values + { + get { return .(pValues, (.)valueCount); } + set mut { pValues = value.Ptr; valueCount = (.)value.Length; } + } + + public this(char8* pLayerName, char8* pSettingName, VkLayerSettingTypeEXT type, Span values = default) : this() + { + this.pLayerName = pLayerName; + this.pSettingName = pSettingName; + this.type = type; + this.values = values; + } +} + +[AllowDuplicates] enum VkLayerSettingTypeEXT : int32 +{ + [NoShow] VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0, + [NoShow] VK_LAYER_SETTING_TYPE_INT32_EXT = 1, + [NoShow] VK_LAYER_SETTING_TYPE_INT64_EXT = 2, + [NoShow] VK_LAYER_SETTING_TYPE_UINT32_EXT = 3, + [NoShow] VK_LAYER_SETTING_TYPE_UINT64_EXT = 4, + [NoShow] VK_LAYER_SETTING_TYPE_FLOAT32_EXT = 5, + [NoShow] VK_LAYER_SETTING_TYPE_FLOAT64_EXT = 6, + [NoShow] VK_LAYER_SETTING_TYPE_STRING_EXT = 7, + // pretty names + Bool32EXT = 0, + Int32EXT = 1, + Int64EXT = 2, + Uint32EXT = 3, + Uint64EXT = 4, + Float32EXT = 5, + Float64EXT = 6, + StringEXT = 7, +} + +static { public const let VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION = 2; } +static { public const let VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME = "VK_ARM_shader_core_builtins"; } + +[CRepr] struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderCoreBuiltins = false; + + public this(void* pNext, VkBool32 shaderCoreBuiltins) : this() + { + this.pNext = pNext; + this.shaderCoreBuiltins = shaderCoreBuiltins; + } +} + +[CRepr] struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 shaderCoreMask = 0; + public uint32 shaderCoreCount = 0; + public uint32 shaderWarpsPerCore = 0; +} + +static { public const let VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION = 1; } +static { public const let VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME = "VK_EXT_pipeline_library_group_handles"; } + +[CRepr] struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineLibraryGroupHandles = false; + + public this(void* pNext, VkBool32 pipelineLibraryGroupHandles) : this() + { + this.pNext = pNext; + this.pipelineLibraryGroupHandles = pipelineLibraryGroupHandles; + } +} + +static { public const let VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION = 1; } +static { public const let VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME = "VK_EXT_dynamic_rendering_unused_attachments"; } + +[CRepr] struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dynamicRenderingUnusedAttachments = false; + + public this(void* pNext, VkBool32 dynamicRenderingUnusedAttachments) : this() + { + this.pNext = pNext; + this.dynamicRenderingUnusedAttachments = dynamicRenderingUnusedAttachments; + } +} + +static { public const let VK_NV_LOW_LATENCY_2_SPEC_VERSION = 2; } +static { public const let VK_NV_LOW_LATENCY_2_EXTENSION_NAME = "VK_NV_low_latency2"; } + +[CRepr] struct VkLatencySleepModeInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 lowLatencyMode = false; + public VkBool32 lowLatencyBoost = false; + public uint32 minimumIntervalUs = 0; + + public this(void* pNext, VkBool32 lowLatencyMode, VkBool32 lowLatencyBoost, uint32 minimumIntervalUs) : this() + { + this.pNext = pNext; + this.lowLatencyMode = lowLatencyMode; + this.lowLatencyBoost = lowLatencyBoost; + this.minimumIntervalUs = minimumIntervalUs; + } +} + +[CRepr] struct VkLatencySleepInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSemaphore signalSemaphore = null; + public uint64 value = 0; + + public this(void* pNext, VkSemaphore signalSemaphore, uint64 value) : this() + { + this.pNext = pNext; + this.signalSemaphore = signalSemaphore; + this.value = value; + } +} + +[CRepr] struct VkSetLatencyMarkerInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 presentID = 0; + public VkLatencyMarkerNV marker = default; + + public this(void* pNext, uint64 presentID, VkLatencyMarkerNV marker) : this() + { + this.pNext = pNext; + this.presentID = presentID; + this.marker = marker; + } +} + +[CRepr] struct VkGetLatencyMarkerInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 timingCount = 0; + public VkLatencyTimingsFrameReportNV* pTimings = null; + public Span timings + { + get { return .(pTimings, (.)timingCount); } + set mut { pTimings = value.Ptr; timingCount = (.)value.Length; } + } + + public this(void* pNext = null, Span timings = default) : this() + { + this.pNext = pNext; + this.timings = timings; + } +} + +[CRepr] struct VkLatencyTimingsFrameReportNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 presentID = 0; + public uint64 inputSampleTimeUs = 0; + public uint64 simStartTimeUs = 0; + public uint64 simEndTimeUs = 0; + public uint64 renderSubmitStartTimeUs = 0; + public uint64 renderSubmitEndTimeUs = 0; + public uint64 presentStartTimeUs = 0; + public uint64 presentEndTimeUs = 0; + public uint64 driverStartTimeUs = 0; + public uint64 driverEndTimeUs = 0; + public uint64 osRenderQueueStartTimeUs = 0; + public uint64 osRenderQueueEndTimeUs = 0; + public uint64 gpuRenderStartTimeUs = 0; + public uint64 gpuRenderEndTimeUs = 0; +} + +[AllowDuplicates] enum VkLatencyMarkerNV : int32 +{ + [NoShow] VK_LATENCY_MARKER_SIMULATION_START_NV = 0, + [NoShow] VK_LATENCY_MARKER_SIMULATION_END_NV = 1, + [NoShow] VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2, + [NoShow] VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3, + [NoShow] VK_LATENCY_MARKER_PRESENT_START_NV = 4, + [NoShow] VK_LATENCY_MARKER_PRESENT_END_NV = 5, + [NoShow] VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6, + [NoShow] VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7, + [NoShow] VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8, + [NoShow] VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9, + [NoShow] VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10, + [NoShow] VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11, + // pretty names + SimulationStartNV = 0, + SimulationEndNV = 1, + RendersubmitStartNV = 2, + RendersubmitEndNV = 3, + PresentStartNV = 4, + PresentEndNV = 5, + InputSampleNV = 6, + TriggerFlashNV = 7, + OutOfBandRendersubmitStartNV = 8, + OutOfBandRendersubmitEndNV = 9, + OutOfBandPresentStartNV = 10, + OutOfBandPresentEndNV = 11, +} + +[CRepr] struct VkLatencySubmissionPresentIdNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 presentID = 0; + + public this(void* pNext, uint64 presentID) : this() + { + this.pNext = pNext; + this.presentID = presentID; + } +} + +[CRepr] struct VkSwapchainLatencyCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 latencyModeEnable = false; + + public this(void* pNext = null, VkBool32 latencyModeEnable = false) : this() + { + this.pNext = pNext; + this.latencyModeEnable = latencyModeEnable; + } +} + +[CRepr] struct VkOutOfBandQueueTypeInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkOutOfBandQueueTypeNV queueType = default; + + public this(void* pNext, VkOutOfBandQueueTypeNV queueType) : this() + { + this.pNext = pNext; + this.queueType = queueType; + } +} + +[AllowDuplicates] enum VkOutOfBandQueueTypeNV : int32 +{ + [NoShow] VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0, + [NoShow] VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1, + // pretty names + RenderNV = 0, + PresentNV = 1, +} + +[CRepr] struct VkLatencySurfaceCapabilitiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 presentModeCount = 0; + public VkPresentModeKHR* pPresentModes = null; + public Span presentModes + { + get { return .(pPresentModes, (.)presentModeCount); } + set mut { pPresentModes = value.Ptr; presentModeCount = (.)value.Length; } + } + + public this(void* pNext = null, Span presentModes = default) : this() + { + this.pNext = pNext; + this.presentModes = presentModes; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, out VkGetLatencyMarkerInfoNV pLatencyMarkerInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkQueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); + +static { public const let VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION = 2; } +static { public const let VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME = "VK_KHR_cooperative_matrix"; } + +[CRepr] struct VkCooperativeMatrixPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 MSize = 0; + public uint32 NSize = 0; + public uint32 KSize = 0; + public VkComponentTypeKHR AType = default; + public VkComponentTypeKHR BType = default; + public VkComponentTypeKHR CType = default; + public VkComponentTypeKHR ResultType = default; + public VkBool32 saturatingAccumulation = false; + public VkScopeKHR @scope = default; +} + +[AllowDuplicates] enum VkScopeKHR : int32 +{ + [NoShow] VK_SCOPE_DEVICE_KHR = 1, + [NoShow] VK_SCOPE_WORKGROUP_KHR = 2, + [NoShow] VK_SCOPE_SUBGROUP_KHR = 3, + [NoShow] VK_SCOPE_QUEUE_FAMILY_KHR = 5, + [NoShow] VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, + [NoShow] VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, + [NoShow] VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, + [NoShow] VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, + // pretty names + DeviceKHR = 1, + WorkgroupKHR = 2, + SubgroupKHR = 3, + QueueFamilyKHR = 5, + DeviceNV = DeviceKHR, + WorkgroupNV = WorkgroupKHR, + SubgroupNV = SubgroupKHR, + QueueFamilyNV = QueueFamilyKHR, +} + +[CRepr] struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cooperativeMatrix = false; + public VkBool32 cooperativeMatrixRobustBufferAccess = false; + + public this(void* pNext, VkBool32 cooperativeMatrix, VkBool32 cooperativeMatrixRobustBufferAccess) : this() + { + this.pNext = pNext; + this.cooperativeMatrix = cooperativeMatrix; + this.cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess; + } +} + +[CRepr] struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags cooperativeMatrixSupportedStages = default; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties = null); + +static { public const let VK_ARM_DATA_GRAPH_SPEC_VERSION = 1; } +static { public const let VK_ARM_DATA_GRAPH_EXTENSION_NAME = "VK_ARM_data_graph"; } +static { public const uint32 VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM = 128; } + +[CRepr] struct VkPhysicalDeviceDataGraphFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dataGraph = false; + public VkBool32 dataGraphUpdateAfterBind = false; + public VkBool32 dataGraphSpecializationConstants = false; + public VkBool32 dataGraphDescriptorBuffer = false; + public VkBool32 dataGraphShaderModule = false; + + public this(void* pNext, VkBool32 dataGraph, VkBool32 dataGraphUpdateAfterBind, VkBool32 dataGraphSpecializationConstants, VkBool32 dataGraphDescriptorBuffer, VkBool32 dataGraphShaderModule) : this() + { + this.pNext = pNext; + this.dataGraph = dataGraph; + this.dataGraphUpdateAfterBind = dataGraphUpdateAfterBind; + this.dataGraphSpecializationConstants = dataGraphSpecializationConstants; + this.dataGraphDescriptorBuffer = dataGraphDescriptorBuffer; + this.dataGraphShaderModule = dataGraphShaderModule; + } +} + +struct VkDataGraphPipelineSessionARM : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkDataGraphPipelineSessionBindPointARM : int32 +{ + [NoShow] VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + // pretty names + TransientARM = 0, +} + +[AllowDuplicates] enum VkDataGraphPipelineSessionBindPointTypeARM : int32 +{ + [NoShow] VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0, + // pretty names + MemoryARM = 0, +} + +[CRepr] struct VkDataGraphPipelineConstantARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 id = 0; + public void* pConstantData = null; + + public this(void* pNext, uint32 id, void* pConstantData) : this() + { + this.pNext = pNext; + this.id = id; + this.pConstantData = pConstantData; + } +} + +[CRepr] struct VkDataGraphPipelineResourceInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 descriptorSet = 0; + public uint32 binding = 0; + public uint32 arrayElement = 0; + + public this(void* pNext, uint32 descriptorSet, uint32 binding, uint32 arrayElement = 0) : this() + { + this.pNext = pNext; + this.descriptorSet = descriptorSet; + this.binding = binding; + this.arrayElement = arrayElement; + } +} + +[CRepr] struct VkDataGraphPipelineCompilerControlCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public char8* pVendorOptions = null; + + public this(void* pNext, char8* pVendorOptions) : this() + { + this.pNext = pNext; + this.pVendorOptions = pVendorOptions; + } +} + +[CRepr] struct VkDataGraphPipelineCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipelineCreateFlags2KHR flags = default; + public VkPipelineLayout layout = null; + public uint32 resourceInfoCount = 0; + public VkDataGraphPipelineResourceInfoARM* pResourceInfos = null; + public Span resourceInfos + { + get { return .(pResourceInfos, (.)resourceInfoCount); } + set mut { pResourceInfos = value.Ptr; resourceInfoCount = (.)value.Length; } + } + + public this(void* pNext, VkPipelineCreateFlags2KHR flags, VkPipelineLayout layout, Span resourceInfos) : this() + { + this.pNext = pNext; + this.flags = flags; + this.layout = layout; + this.resourceInfos = resourceInfos; + } +} + +[CRepr] struct VkDataGraphPipelineShaderModuleCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderModule module = null; + public char8* pName = null; + public VkSpecializationInfo* pSpecializationInfo = null; + public uint32 constantCount = 0; + public VkDataGraphPipelineConstantARM* pConstants = null; + public Span constants + { + get { return .(pConstants, (.)constantCount); } + set mut { pConstants = value.Ptr; constantCount = (.)value.Length; } + } + + public this(void* pNext, VkShaderModule module, char8* pName, VkSpecializationInfo* pSpecializationInfo = null, Span constants = default) : this() + { + this.pNext = pNext; + this.module = module; + this.pName = pName; + this.pSpecializationInfo = pSpecializationInfo; + this.constants = constants; + } +} + +[CRepr] struct VkDataGraphPipelineSessionCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineSessionCreateFlagsARM flags = default; + public VkPipeline dataGraphPipeline = null; + + public this(void* pNext, VkDataGraphPipelineSessionCreateFlagsARM flags, VkPipeline dataGraphPipeline) : this() + { + this.pNext = pNext; + this.flags = flags; + this.dataGraphPipeline = dataGraphPipeline; + } +} + +typealias VkDataGraphPipelineSessionCreateFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkDataGraphPipelineSessionCreateFlagBitsARM : int32 +{ + [NoShow] VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 1 << 0, + // pretty names + ProtectedARM = 1 << 0, +} + +[CRepr] struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineSessionARM session = null; + + public this(void* pNext, VkDataGraphPipelineSessionARM session) : this() + { + this.pNext = pNext; + this.session = session; + } +} + +[CRepr] struct VkDataGraphPipelineSessionBindPointRequirementARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineSessionBindPointARM bindPoint = default; + public VkDataGraphPipelineSessionBindPointTypeARM bindPointType = default; + public uint32 numObjects = 0; + + public this(void* pNext, VkDataGraphPipelineSessionBindPointARM bindPoint, VkDataGraphPipelineSessionBindPointTypeARM bindPointType, uint32 numObjects) : this() + { + this.pNext = pNext; + this.bindPoint = bindPoint; + this.bindPointType = bindPointType; + this.numObjects = numObjects; + } +} + +[CRepr] struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineSessionARM session = null; + public VkDataGraphPipelineSessionBindPointARM bindPoint = default; + public uint32 objectIndex = 0; + + public this(void* pNext, VkDataGraphPipelineSessionARM session, VkDataGraphPipelineSessionBindPointARM bindPoint, uint32 objectIndex) : this() + { + this.pNext = pNext; + this.session = session; + this.bindPoint = bindPoint; + this.objectIndex = objectIndex; + } +} + +[CRepr] struct VkBindDataGraphPipelineSessionMemoryInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineSessionARM session = null; + public VkDataGraphPipelineSessionBindPointARM bindPoint = default; + public uint32 objectIndex = 0; + public VkDeviceMemory memory = null; + public VkDeviceSize memoryOffset = default; + + public this(void* pNext, VkDataGraphPipelineSessionARM session, VkDataGraphPipelineSessionBindPointARM bindPoint, uint32 objectIndex, VkDeviceMemory memory, VkDeviceSize memoryOffset) : this() + { + this.pNext = pNext; + this.session = session; + this.bindPoint = bindPoint; + this.objectIndex = objectIndex; + this.memory = memory; + this.memoryOffset = memoryOffset; + } +} + +[CRepr] struct VkDataGraphPipelineInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline dataGraphPipeline = null; + + public this(void* pNext, VkPipeline dataGraphPipeline) : this() + { + this.pNext = pNext; + this.dataGraphPipeline = dataGraphPipeline; + } +} + +[CRepr] struct VkDataGraphPipelinePropertyQueryResultARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelinePropertyARM property = default; + public VkBool32 isText = false; + public c_size dataSize = 0; + public void* pData = null; + public Span data + { + get { return .(pData, (.)dataSize); } + set mut { pData = value.Ptr; dataSize = (.)value.Length; } + } + + public this(void* pNext, VkDataGraphPipelinePropertyARM property, VkBool32 isText, Span data = default) : this() + { + this.pNext = pNext; + this.property = property; + this.isText = isText; + this.data = data; + } +} + +[AllowDuplicates] enum VkDataGraphPipelinePropertyARM : int32 +{ + [NoShow] VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, + [NoShow] VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + // pretty names + CreationLogARM = 0, + IdentifierARM = 1, +} + +[CRepr] struct VkDataGraphPipelineIdentifierCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 identifierSize = 0; + public uint8* pIdentifier = null; + public Span identifier + { + get { return .(pIdentifier, (.)identifierSize); } + set mut { pIdentifier = value.Ptr; identifierSize = (.)value.Length; } + } + + public this(void* pNext, Span identifier) : this() + { + this.pNext = pNext; + this.identifier = identifier; + } +} + +typealias VkDataGraphPipelineDispatchFlagsARM = VkFlags64; + +[AllowDuplicates] enum VkDataGraphPipelineDispatchFlagBitsARM : int32 +{ + // pretty names +} + +[CRepr] struct VkDataGraphPipelineDispatchInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDataGraphPipelineDispatchFlagsARM flags = default; + + public this(void* pNext = null, VkDataGraphPipelineDispatchFlagsARM flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +[AllowDuplicates] enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM : int32 +{ + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0, + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000, + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001, + // pretty names + DefaultARM = 0, + NeuralQCOM = 1000629000, + ComputeQCOM = 1000629001, +} + +[AllowDuplicates] enum VkPhysicalDeviceDataGraphOperationTypeARM : int32 +{ + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000, + [NoShow] VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001, + // pretty names + SpirvExtendedInstructionSetARM = 0, + NeuralModelQCOM = 1000629000, + BuiltinModelQCOM = 1000629001, +} + +[CRepr] struct VkPhysicalDeviceDataGraphProcessingEngineARM : this() +{ + public VkPhysicalDeviceDataGraphProcessingEngineTypeARM type = default; + public VkBool32 isForeign = false; + + public this(VkPhysicalDeviceDataGraphProcessingEngineTypeARM type, VkBool32 isForeign) : this() + { + this.type = type; + this.isForeign = isForeign; + } +} + +[CRepr] struct VkQueueFamilyDataGraphPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceDataGraphProcessingEngineARM engine = default; + public VkPhysicalDeviceDataGraphOperationSupportARM operation = default; + + public this(void* pNext, VkPhysicalDeviceDataGraphProcessingEngineARM engine, VkPhysicalDeviceDataGraphOperationSupportARM operation) : this() + { + this.pNext = pNext; + this.engine = engine; + this.operation = operation; + } +} + +[CRepr] struct VkDataGraphProcessingEngineCreateInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 processingEngineCount = 0; + public VkPhysicalDeviceDataGraphProcessingEngineARM* pProcessingEngines = null; + public Span processingEngines + { + get { return .(pProcessingEngines, (.)processingEngineCount); } + set mut { pProcessingEngines = value.Ptr; processingEngineCount = (.)value.Length; } + } + + public this(void* pNext, Span processingEngines) : this() + { + this.pNext = pNext; + this.processingEngines = processingEngines; + } +} + +[CRepr] struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 queueFamilyIndex = 0; + public VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType = default; + + public this(void* pNext, uint32 queueFamilyIndex, VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType) : this() + { + this.pNext = pNext; + this.queueFamilyIndex = queueFamilyIndex; + this.engineType = engineType; + } +} + +[CRepr] struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes = default; + public VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes = default; + + public this(void* pNext, VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes, VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes) : this() + { + this.pNext = pNext; + this.foreignSemaphoreHandleTypes = foreignSemaphoreHandleTypes; + this.foreignMemoryHandleTypes = foreignMemoryHandleTypes; + } +} + +[CRepr] struct VkPhysicalDeviceDataGraphOperationSupportARM : this() +{ + public VkPhysicalDeviceDataGraphOperationTypeARM operationType = default; + public char8[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM] name = .(); + public uint32 version = 0; + + public this(VkPhysicalDeviceDataGraphOperationTypeARM operationType, char8[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM] name, uint32 version) : this() + { + this.operationType = operationType; + this.name = name; + this.version = version; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32 createInfoCount, VkDataGraphPipelineCreateInfoARM* pCreateInfos, VkAllocationCallbacks* pAllocator, out VkPipeline pPipelines); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkDataGraphPipelineSessionARM pSession); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, out uint32 pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32 bindInfoCount, VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +[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_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); + +[CRepr] struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 dimension = 0; + public uint32 zeroCount = 0; + public uint32 groupSize = 0; + + public this(void* pNext, uint32 dimension, uint32 zeroCount, uint32 groupSize) : this() + { + this.pNext = pNext; + this.dimension = dimension; + this.zeroCount = zeroCount; + this.groupSize = groupSize; + } +} + +static { public const let VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION = 1; } +static { public const let VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME = "VK_QCOM_multiview_per_view_render_areas"; } + +[CRepr] struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 multiviewPerViewRenderAreas = false; + + public this(void* pNext, VkBool32 multiviewPerViewRenderAreas) : this() + { + this.pNext = pNext; + this.multiviewPerViewRenderAreas = multiviewPerViewRenderAreas; + } +} + +[CRepr] struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 perViewRenderAreaCount = 0; + public VkRect2D* pPerViewRenderAreas = null; + public Span perViewRenderAreas + { + get { return .(pPerViewRenderAreas, (.)perViewRenderAreaCount); } + set mut { pPerViewRenderAreas = value.Ptr; perViewRenderAreaCount = (.)value.Length; } + } + + public this(void* pNext = null, Span perViewRenderAreas = default) : this() + { + this.pNext = pNext; + this.perViewRenderAreas = perViewRenderAreas; + } +} + +static { public const let VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION = 1; } +static { public const let VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME = "VK_KHR_compute_shader_derivatives"; } + +[CRepr] struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 computeDerivativeGroupQuads = false; + public VkBool32 computeDerivativeGroupLinear = false; + + public this(void* pNext, VkBool32 computeDerivativeGroupQuads, VkBool32 computeDerivativeGroupLinear) : this() + { + this.pNext = pNext; + this.computeDerivativeGroupQuads = computeDerivativeGroupQuads; + this.computeDerivativeGroupLinear = computeDerivativeGroupLinear; + } +} + +[CRepr] struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 meshAndTaskShaderDerivatives = false; +} + +static { public const let VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME = "VK_KHR_video_decode_av1"; } +static { public const uint32 VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR = 7; } + +[CRepr] struct VkVideoDecodeAV1ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1Profile stdProfile = default; + public VkBool32 filmGrainSupport = false; + + public this(void* pNext, StdVideoAV1Profile stdProfile, VkBool32 filmGrainSupport) : this() + { + this.pNext = pNext; + this.stdProfile = stdProfile; + this.filmGrainSupport = filmGrainSupport; + } +} + +[CRepr] struct VkVideoDecodeAV1CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1Level maxLevel = default; +} + +[CRepr] struct VkVideoDecodeAV1SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1SequenceHeader* pStdSequenceHeader = null; + + public this(void* pNext, StdVideoAV1SequenceHeader* pStdSequenceHeader) : this() + { + this.pNext = pNext; + this.pStdSequenceHeader = pStdSequenceHeader; + } +} + +[CRepr] struct VkVideoDecodeAV1PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeAV1PictureInfo* pStdPictureInfo = null; + public int32[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices = .(); + public uint32 frameHeaderOffset = 0; + public uint32 tileCount = 0; + public uint32* pTileOffsets = null; + public uint32* pTileSizes = null; + + public this(void* pNext, StdVideoDecodeAV1PictureInfo* pStdPictureInfo, int32[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices, uint32 frameHeaderOffset, uint32 tileCount, uint32* pTileOffsets, uint32* pTileSizes) : this() + { + this.pNext = pNext; + this.pStdPictureInfo = pStdPictureInfo; + this.referenceNameSlotIndices = referenceNameSlotIndices; + this.frameHeaderOffset = frameHeaderOffset; + this.tileCount = tileCount; + this.pTileOffsets = pTileOffsets; + this.pTileSizes = pTileSizes; + } +} + +[CRepr] struct VkVideoDecodeAV1DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +static { public const let VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME = "VK_KHR_video_encode_av1"; } + +[CRepr] struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoEncodeAV1 = false; + + public this(void* pNext, VkBool32 videoEncodeAV1) : this() + { + this.pNext = pNext; + this.videoEncodeAV1 = videoEncodeAV1; + } +} + +[AllowDuplicates] enum VkVideoEncodeAV1PredictionModeKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR = 1, + [NoShow] VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR = 2, + [NoShow] VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR = 3, + // pretty names + VkVideoEncodeAv1_PredictionModeIntraOnlyKHR = 0, + VkVideoEncodeAv1_PredictionModeSingleReferenceKHR = 1, + VkVideoEncodeAv1_PredictionModeUnidirectionalCompoundKHR = 2, + VkVideoEncodeAv1_PredictionModeBidirectionalCompoundKHR = 3, +} + +[AllowDuplicates] enum VkVideoEncodeAV1RateControlGroupKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR = 1, + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR = 2, + // pretty names + VkVideoEncodeAv1_RateControlGroupIntraKHR = 0, + VkVideoEncodeAv1_RateControlGroupPredictiveKHR = 1, + VkVideoEncodeAv1_RateControlGroupBipredictiveKHR = 2, +} + +[AllowDuplicates] enum VkVideoEncodeAV1CapabilityFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 1 << 3, + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 1 << 4, + [NoShow] VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR = 1 << 5, + // pretty names + VkVideoEncodeAv1_CapabilityPerRateControlGroupMinMaxQIndexKHR = 1 << 0, + VkVideoEncodeAv1_CapabilityGenerateObuExtensionHeaderKHR = 1 << 1, + VkVideoEncodeAv1_CapabilityPrimaryReferenceCdfOnlyKHR = 1 << 2, + VkVideoEncodeAv1_CapabilityFrameSizeOverrideKHR = 1 << 3, + VkVideoEncodeAv1_CapabilityMotionVectorScalingKHR = 1 << 4, + VkVideoEncodeAv1_CapabilityCompoundPredictionIntraRefreshKHR = 1 << 5, +} + +typealias VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeAV1StdFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR = 1 << 3, + // pretty names + VkVideoEncodeAv1_StdUniformTileSpacingFlagSetKHR = 1 << 0, + VkVideoEncodeAv1_StdSkipModePresentUnsetKHR = 1 << 1, + VkVideoEncodeAv1_StdPrimaryRefFrameKHR = 1 << 2, + VkVideoEncodeAv1_StdDeltaQKHR = 1 << 3, +} + +typealias VkVideoEncodeAV1StdFlagsKHR = VkVideoEncodeAV1StdFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR = 1 << 1, + // pretty names + VkVideoEncodeAv1_SuperblockSize64KHR = 1 << 0, + VkVideoEncodeAv1_SuperblockSize128KHR = 1 << 1, +} + +typealias VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; + +[CRepr] struct VkVideoEncodeAV1CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeAV1CapabilityFlagsKHR flags = default; + public StdVideoAV1Level maxLevel = default; + public VkExtent2D codedPictureAlignment = default; + public VkExtent2D maxTiles = default; + public VkExtent2D minTileSize = default; + public VkExtent2D maxTileSize = default; + public VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes = default; + public uint32 maxSingleReferenceCount = 0; + public uint32 singleReferenceNameMask = 0; + public uint32 maxUnidirectionalCompoundReferenceCount = 0; + public uint32 maxUnidirectionalCompoundGroup1ReferenceCount = 0; + public uint32 unidirectionalCompoundReferenceNameMask = 0; + public uint32 maxBidirectionalCompoundReferenceCount = 0; + public uint32 maxBidirectionalCompoundGroup1ReferenceCount = 0; + public uint32 maxBidirectionalCompoundGroup2ReferenceCount = 0; + public uint32 bidirectionalCompoundReferenceNameMask = 0; + public uint32 maxTemporalLayerCount = 0; + public uint32 maxSpatialLayerCount = 0; + public uint32 maxOperatingPoints = 0; + public uint32 minQIndex = 0; + public uint32 maxQIndex = 0; + public VkBool32 prefersGopRemainingFrames = false; + public VkBool32 requiresGopRemainingFrames = false; + public VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags = default; +} + +[CRepr] struct VkVideoEncodeAV1QualityLevelPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags = default; + public uint32 preferredGopFrameCount = 0; + public uint32 preferredKeyFramePeriod = 0; + public uint32 preferredConsecutiveBipredictiveFrameCount = 0; + public uint32 preferredTemporalLayerCount = 0; + public VkVideoEncodeAV1QIndexKHR preferredConstantQIndex = default; + public uint32 preferredMaxSingleReferenceCount = 0; + public uint32 preferredSingleReferenceNameMask = 0; + public uint32 preferredMaxUnidirectionalCompoundReferenceCount = 0; + public uint32 preferredMaxUnidirectionalCompoundGroup1ReferenceCount = 0; + public uint32 preferredUnidirectionalCompoundReferenceNameMask = 0; + public uint32 preferredMaxBidirectionalCompoundReferenceCount = 0; + public uint32 preferredMaxBidirectionalCompoundGroup1ReferenceCount = 0; + public uint32 preferredMaxBidirectionalCompoundGroup2ReferenceCount = 0; + public uint32 preferredBidirectionalCompoundReferenceNameMask = 0; +} + +[CRepr] struct VkVideoEncodeAV1SessionCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMaxLevel = false; + public StdVideoAV1Level maxLevel = default; + + public this(void* pNext, VkBool32 useMaxLevel, StdVideoAV1Level maxLevel) : this() + { + this.pNext = pNext; + this.useMaxLevel = useMaxLevel; + this.maxLevel = maxLevel; + } +} + +[CRepr] struct VkVideoEncodeAV1SessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1SequenceHeader* pStdSequenceHeader = null; + public StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo = null; + public uint32 stdOperatingPointCount = 0; + public StdVideoEncodeAV1OperatingPointInfo* pStdOperatingPoints = null; + public Span stdOperatingPoints + { + get { return .(pStdOperatingPoints, (.)stdOperatingPointCount); } + set mut { pStdOperatingPoints = value.Ptr; stdOperatingPointCount = (.)value.Length; } + } + + public this(void* pNext, StdVideoAV1SequenceHeader* pStdSequenceHeader, StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo = null, Span stdOperatingPoints = default) : this() + { + this.pNext = pNext; + this.pStdSequenceHeader = pStdSequenceHeader; + this.pStdDecoderModelInfo = pStdDecoderModelInfo; + this.stdOperatingPoints = stdOperatingPoints; + } +} + +[CRepr] struct VkVideoEncodeAV1PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeAV1PredictionModeKHR predictionMode = default; + public VkVideoEncodeAV1RateControlGroupKHR rateControlGroup = default; + public uint32 constantQIndex = 0; + public StdVideoEncodeAV1PictureInfo* pStdPictureInfo = null; + public int32[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices = .(); + public VkBool32 primaryReferenceCdfOnly = false; + public VkBool32 generateObuExtensionHeader = false; + + public this(void* pNext, VkVideoEncodeAV1PredictionModeKHR predictionMode, VkVideoEncodeAV1RateControlGroupKHR rateControlGroup, uint32 constantQIndex, StdVideoEncodeAV1PictureInfo* pStdPictureInfo, int32[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices, VkBool32 primaryReferenceCdfOnly, VkBool32 generateObuExtensionHeader) : this() + { + this.pNext = pNext; + this.predictionMode = predictionMode; + this.rateControlGroup = rateControlGroup; + this.constantQIndex = constantQIndex; + this.pStdPictureInfo = pStdPictureInfo; + this.referenceNameSlotIndices = referenceNameSlotIndices; + this.primaryReferenceCdfOnly = primaryReferenceCdfOnly; + this.generateObuExtensionHeader = generateObuExtensionHeader; + } +} + +[CRepr] struct VkVideoEncodeAV1DpbSlotInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo = null; + + public this(void* pNext, StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo) : this() + { + this.pNext = pNext; + this.pStdReferenceInfo = pStdReferenceInfo; + } +} + +[CRepr] struct VkVideoEncodeAV1ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1Profile stdProfile = default; + + public this(void* pNext, StdVideoAV1Profile stdProfile) : this() + { + this.pNext = pNext; + this.stdProfile = stdProfile; + } +} + +[CRepr] struct VkVideoEncodeAV1QIndexKHR : this() +{ + public uint32 intraQIndex = 0; + public uint32 predictiveQIndex = 0; + public uint32 bipredictiveQIndex = 0; + + public this(uint32 intraQIndex, uint32 predictiveQIndex, uint32 bipredictiveQIndex) : this() + { + this.intraQIndex = intraQIndex; + this.predictiveQIndex = predictiveQIndex; + this.bipredictiveQIndex = bipredictiveQIndex; + } +} + +[CRepr] struct VkVideoEncodeAV1FrameSizeKHR : this() +{ + public uint32 intraFrameSize = 0; + public uint32 predictiveFrameSize = 0; + public uint32 bipredictiveFrameSize = 0; + + public this(uint32 intraFrameSize, uint32 predictiveFrameSize, uint32 bipredictiveFrameSize) : this() + { + this.intraFrameSize = intraFrameSize; + this.predictiveFrameSize = predictiveFrameSize; + this.bipredictiveFrameSize = bipredictiveFrameSize; + } +} + +[CRepr] struct VkVideoEncodeAV1GopRemainingFrameInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useGopRemainingFrames = false; + public uint32 gopRemainingIntra = 0; + public uint32 gopRemainingPredictive = 0; + public uint32 gopRemainingBipredictive = 0; + + public this(void* pNext, VkBool32 useGopRemainingFrames, uint32 gopRemainingIntra, uint32 gopRemainingPredictive, uint32 gopRemainingBipredictive) : this() + { + this.pNext = pNext; + this.useGopRemainingFrames = useGopRemainingFrames; + this.gopRemainingIntra = gopRemainingIntra; + this.gopRemainingPredictive = gopRemainingPredictive; + this.gopRemainingBipredictive = gopRemainingBipredictive; + } +} + +[CRepr] struct VkVideoEncodeAV1RateControlInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeAV1RateControlFlagsKHR flags = default; + public uint32 gopFrameCount = 0; + public uint32 keyFramePeriod = 0; + public uint32 consecutiveBipredictiveFrameCount = 0; + public uint32 temporalLayerCount = 0; + + public this(void* pNext, VkVideoEncodeAV1RateControlFlagsKHR flags, uint32 gopFrameCount, uint32 keyFramePeriod, uint32 consecutiveBipredictiveFrameCount, uint32 temporalLayerCount) : this() + { + this.pNext = pNext; + this.flags = flags; + this.gopFrameCount = gopFrameCount; + this.keyFramePeriod = keyFramePeriod; + this.consecutiveBipredictiveFrameCount = consecutiveBipredictiveFrameCount; + this.temporalLayerCount = temporalLayerCount; + } +} + +[AllowDuplicates] enum VkVideoEncodeAV1RateControlFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 1 << 3, + // pretty names + VkVideoEncodeAv1_RateControlRegularGopKHR = 1 << 0, + VkVideoEncodeAv1_RateControlTemporalLayerPatternDyadicKHR = 1 << 1, + VkVideoEncodeAv1_RateControlReferencePatternFlatKHR = 1 << 2, + VkVideoEncodeAv1_RateControlReferencePatternDyadicKHR = 1 << 3, +} + +typealias VkVideoEncodeAV1RateControlFlagsKHR = VkVideoEncodeAV1RateControlFlagBitsKHR; + +[CRepr] struct VkVideoEncodeAV1RateControlLayerInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 useMinQIndex = false; + public VkVideoEncodeAV1QIndexKHR minQIndex = default; + public VkBool32 useMaxQIndex = false; + public VkVideoEncodeAV1QIndexKHR maxQIndex = default; + public VkBool32 useMaxFrameSize = false; + public VkVideoEncodeAV1FrameSizeKHR maxFrameSize = default; + + public this(void* pNext, VkBool32 useMinQIndex, VkVideoEncodeAV1QIndexKHR minQIndex, VkBool32 useMaxQIndex, VkVideoEncodeAV1QIndexKHR maxQIndex, VkBool32 useMaxFrameSize, VkVideoEncodeAV1FrameSizeKHR maxFrameSize) : this() + { + this.pNext = pNext; + this.useMinQIndex = useMinQIndex; + this.minQIndex = minQIndex; + this.useMaxQIndex = useMaxQIndex; + this.maxQIndex = maxQIndex; + this.useMaxFrameSize = useMaxFrameSize; + this.maxFrameSize = maxFrameSize; + } +} + +static { public const let VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME = "VK_KHR_video_decode_vp9"; } +static { public const uint32 VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR = 3; } + +[CRepr] struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoDecodeVP9 = false; + + public this(void* pNext, VkBool32 videoDecodeVP9) : this() + { + this.pNext = pNext; + this.videoDecodeVP9 = videoDecodeVP9; + } +} + +[CRepr] struct VkVideoDecodeVP9ProfileInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoVP9Profile stdProfile = default; + + public this(void* pNext, StdVideoVP9Profile stdProfile) : this() + { + this.pNext = pNext; + this.stdProfile = stdProfile; + } +} + +[CRepr] struct VkVideoDecodeVP9CapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoVP9Level maxLevel = default; +} + +[CRepr] struct VkVideoDecodeVP9PictureInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoDecodeVP9PictureInfo* pStdPictureInfo = null; + public int32[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices = .(); + public uint32 uncompressedHeaderOffset = 0; + public uint32 compressedHeaderOffset = 0; + public uint32 tilesOffset = 0; + + public this(void* pNext, StdVideoDecodeVP9PictureInfo* pStdPictureInfo, int32[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR] referenceNameSlotIndices, uint32 uncompressedHeaderOffset, uint32 compressedHeaderOffset, uint32 tilesOffset) : this() + { + this.pNext = pNext; + this.pStdPictureInfo = pStdPictureInfo; + this.referenceNameSlotIndices = referenceNameSlotIndices; + this.uncompressedHeaderOffset = uncompressedHeaderOffset; + this.compressedHeaderOffset = compressedHeaderOffset; + this.tilesOffset = tilesOffset; + } +} + +static { public const let VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME = "VK_KHR_video_maintenance1"; } + +[CRepr] struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoMaintenance1 = false; + + public this(void* pNext, VkBool32 videoMaintenance1) : this() + { + this.pNext = pNext; + this.videoMaintenance1 = videoMaintenance1; + } +} + +[CRepr] struct VkVideoInlineQueryInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueryPool queryPool = null; + public uint32 firstQuery = 0; + public uint32 queryCount = 0; + + public this(void* pNext, VkQueryPool queryPool, uint32 firstQuery, uint32 queryCount) : this() + { + this.pNext = pNext; + this.queryPool = queryPool; + this.firstQuery = firstQuery; + this.queryCount = queryCount; + } +} + +static { public const let VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION = 1; } +static { public const let VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME = "VK_NV_per_stage_descriptor_set"; } + +[CRepr] struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 perStageDescriptorSet = false; + public VkBool32 dynamicPipelineLayout = false; + + public this(void* pNext, VkBool32 perStageDescriptorSet, VkBool32 dynamicPipelineLayout) : this() + { + this.pNext = pNext; + this.perStageDescriptorSet = perStageDescriptorSet; + this.dynamicPipelineLayout = dynamicPipelineLayout; + } +} + +static { public const let VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION = 1; } +static { public const let VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME = "VK_QCOM_image_processing2"; } + +[CRepr] struct VkPhysicalDeviceImageProcessing2FeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 textureBlockMatch2 = false; + + public this(void* pNext, VkBool32 textureBlockMatch2) : this() + { + this.pNext = pNext; + this.textureBlockMatch2 = textureBlockMatch2; + } +} + +[CRepr] struct VkPhysicalDeviceImageProcessing2PropertiesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D maxBlockMatchWindow = default; +} + +[CRepr] struct VkSamplerBlockMatchWindowCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D windowExtent = default; + public VkBlockMatchWindowCompareModeQCOM windowCompareMode = default; + + public this(void* pNext, VkExtent2D windowExtent, VkBlockMatchWindowCompareModeQCOM windowCompareMode) : this() + { + this.pNext = pNext; + this.windowExtent = windowExtent; + this.windowCompareMode = windowCompareMode; + } +} + +[AllowDuplicates] enum VkBlockMatchWindowCompareModeQCOM : int32 +{ + [NoShow] VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0, + [NoShow] VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1, + // pretty names + MinQCOM = 0, + MaxQCOM = 1, +} + +static { public const let VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION = 1; } +static { public const let VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME = "VK_QCOM_filter_cubic_weights"; } + +[CRepr] struct VkPhysicalDeviceCubicWeightsFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 selectableCubicWeights = false; + + public this(void* pNext, VkBool32 selectableCubicWeights) : this() + { + this.pNext = pNext; + this.selectableCubicWeights = selectableCubicWeights; + } +} + +[CRepr] struct VkSamplerCubicWeightsCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCubicFilterWeightsQCOM cubicWeights = default; + + public this(void* pNext, VkCubicFilterWeightsQCOM cubicWeights) : this() + { + this.pNext = pNext; + this.cubicWeights = cubicWeights; + } +} + +[CRepr] struct VkBlitImageCubicWeightsInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkCubicFilterWeightsQCOM cubicWeights = default; + + public this(void* pNext, VkCubicFilterWeightsQCOM cubicWeights) : this() + { + this.pNext = pNext; + this.cubicWeights = cubicWeights; + } +} + +[AllowDuplicates] enum VkCubicFilterWeightsQCOM : int32 +{ + [NoShow] VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0, + [NoShow] VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1, + [NoShow] VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2, + [NoShow] VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3, + // pretty names + CatmullRomQCOM = 0, + ZeroTangentCardinalQCOM = 1, + BSplineQCOM = 2, + MitchellNetravaliQCOM = 3, +} + +static { public const let VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION = 1; } +static { public const let VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME = "VK_QCOM_ycbcr_degamma"; } + +[CRepr] struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 ycbcrDegamma = false; + + public this(void* pNext, VkBool32 ycbcrDegamma) : this() + { + this.pNext = pNext; + this.ycbcrDegamma = ycbcrDegamma; + } +} + +[CRepr] struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 enableYDegamma = false; + public VkBool32 enableCbCrDegamma = false; + + public this(void* pNext, VkBool32 enableYDegamma, VkBool32 enableCbCrDegamma) : this() + { + this.pNext = pNext; + this.enableYDegamma = enableYDegamma; + this.enableCbCrDegamma = enableCbCrDegamma; + } +} + +static { public const let VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION = 1; } +static { public const let VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME = "VK_QCOM_filter_cubic_clamp"; } + +[CRepr] struct VkPhysicalDeviceCubicClampFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cubicRangeClamp = false; + + public this(void* pNext, VkBool32 cubicRangeClamp) : this() + { + this.pNext = pNext; + this.cubicRangeClamp = cubicRangeClamp; + } +} + +static { public const let VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION = 1; } +static { public const let VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME = "VK_EXT_attachment_feedback_loop_dynamic_state"; } + +[CRepr] struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 attachmentFeedbackLoopDynamicState = false; + + public this(void* pNext, VkBool32 attachmentFeedbackLoopDynamicState) : this() + { + this.pNext = pNext; + this.attachmentFeedbackLoopDynamicState = attachmentFeedbackLoopDynamicState; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask = default); + +static { public const let VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION = 1; } +static { public const let VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME = "VK_KHR_vertex_attribute_divisor"; } + +typealias VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR = VkPhysicalDeviceVertexAttributeDivisorProperties; +typealias VkVertexInputBindingDivisorDescriptionKHR = VkVertexInputBindingDivisorDescription; +typealias VkPipelineVertexInputDivisorStateCreateInfoKHR = VkPipelineVertexInputDivisorStateCreateInfo; +typealias VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = VkPhysicalDeviceVertexAttributeDivisorFeatures; + +static { public const let VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION = 1; } +static { public const let VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME = "VK_KHR_load_store_op_none"; } +static { public const let VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION = 1; } +static { public const let VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME = "VK_KHR_unified_image_layouts"; } + +[CRepr] struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 unifiedImageLayouts = false; + public VkBool32 unifiedImageLayoutsVideo = false; + + public this(void* pNext, VkBool32 unifiedImageLayouts, VkBool32 unifiedImageLayoutsVideo) : this() + { + this.pNext = pNext; + this.unifiedImageLayouts = unifiedImageLayouts; + this.unifiedImageLayoutsVideo = unifiedImageLayoutsVideo; + } +} + +[CRepr] struct VkAttachmentFeedbackLoopInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 feedbackLoopEnable = false; + + public this(void* pNext, VkBool32 feedbackLoopEnable) : this() + { + this.pNext = pNext; + this.feedbackLoopEnable = feedbackLoopEnable; + } +} + +static { public const let VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME = "VK_KHR_shader_float_controls2"; } + +typealias VkPhysicalDeviceShaderFloatControls2FeaturesKHR = VkPhysicalDeviceShaderFloatControls2Features; + +static { public const let VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION = 1; } +static { public const let VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME = "VK_QNX_external_memory_screen_buffer"; } + +[CRepr] struct VkScreenBufferPropertiesQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize allocationSize = default; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkScreenBufferFormatPropertiesQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat format = default; + public uint64 externalFormat = 0; + public uint64 screenUsage = 0; + public VkFormatFeatureFlags formatFeatures = default; + public VkComponentMapping samplerYcbcrConversionComponents = default; + public VkSamplerYcbcrModelConversion suggestedYcbcrModel = default; + public VkSamplerYcbcrRange suggestedYcbcrRange = default; + public VkChromaLocation suggestedXChromaOffset = default; + public VkChromaLocation suggestedYChromaOffset = default; +} + +[CRepr] struct VkImportScreenBufferInfoQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public _screen_buffer* buffer = null; + + public this(void* pNext, _screen_buffer* buffer) : this() + { + this.pNext = pNext; + this.buffer = buffer; + } +} + +[CRepr] struct VkExternalFormatQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public uint64 externalFormat = 0; + + public this(void* pNext, uint64 externalFormat) : this() + { + this.pNext = pNext; + this.externalFormat = externalFormat; + } +} + +[CRepr] struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 screenBufferImport = false; + + public this(void* pNext, VkBool32 screenBufferImport) : this() + { + this.pNext = pNext; + this.screenBufferImport = screenBufferImport; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetScreenBufferPropertiesQNX(VkDevice device, out _screen_buffer buffer, out VkScreenBufferPropertiesQNX pProperties); + +static { public const let VK_MSFT_LAYERED_DRIVER_SPEC_VERSION = 1; } +static { public const let VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME = "VK_MSFT_layered_driver"; } + +[AllowDuplicates] enum VkLayeredDriverUnderlyingApiMSFT : int32 +{ + [NoShow] VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, + [NoShow] VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1, + // pretty names + NoneMSFT = 0, + D3d12MSFT = 1, +} + +[CRepr] struct VkPhysicalDeviceLayeredDriverPropertiesMSFT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkLayeredDriverUnderlyingApiMSFT underlyingAPI = default; +} + +static { public const let VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION = 1; } +static { public const let VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME = "VK_KHR_index_type_uint8"; } + +typealias VkPhysicalDeviceIndexTypeUint8FeaturesKHR = VkPhysicalDeviceIndexTypeUint8Features; + +static { public const let VK_KHR_LINE_RASTERIZATION_SPEC_VERSION = 1; } +static { public const let VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME = "VK_KHR_line_rasterization"; } + +typealias VkPhysicalDeviceLineRasterizationFeaturesKHR = VkPhysicalDeviceLineRasterizationFeatures; +typealias VkPhysicalDeviceLineRasterizationPropertiesKHR = VkPhysicalDeviceLineRasterizationProperties; +typealias VkPipelineRasterizationLineStateCreateInfoKHR = VkPipelineRasterizationLineStateCreateInfo; +typealias VkLineRasterizationModeKHR = VkLineRasterizationMode; + +typealias PFN_vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStipple; + +static { public const let VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION = 1; } +static { public const let VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME = "VK_KHR_calibrated_timestamps"; } + +[AllowDuplicates] enum VkTimeDomainKHR : int32 +{ + [NoShow] VK_TIME_DOMAIN_DEVICE_KHR = 0, + [NoShow] VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1, + [NoShow] VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2, + [NoShow] VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3, + [NoShow] VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, + [NoShow] VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, + [NoShow] VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, + [NoShow] VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, + [NoShow] VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT = 1000208000, + [NoShow] VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT = 1000208001, + // pretty names + DeviceKHR = 0, + ClockMonotonicKHR = 1, + ClockMonotonicRawKHR = 2, + QueryPerformanceCounterKHR = 3, + DeviceEXT = DeviceKHR, + ClockMonotonicEXT = ClockMonotonicKHR, + ClockMonotonicRawEXT = ClockMonotonicRawKHR, + QueryPerformanceCounterEXT = QueryPerformanceCounterKHR, + PresentStageLocalEXT = 1000208000, + SwapchainLocalEXT = 1000208001, +} + +[CRepr] struct VkCalibratedTimestampInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkTimeDomainKHR timeDomain = default; + + public this(void* pNext, VkTimeDomainKHR timeDomain) : this() + { + this.pNext = pNext; + this.timeDomain = timeDomain; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, out uint32 pTimeDomainCount, VkTimeDomainKHR* pTimeDomains = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetCalibratedTimestampsKHR(VkDevice device, uint32 timestampCount, VkCalibratedTimestampInfoKHR* pTimestampInfos, out uint64 pTimestamps, out uint64 pMaxDeviation); + +static { public const let VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME = "VK_KHR_shader_expect_assume"; } + +typealias VkPhysicalDeviceShaderExpectAssumeFeaturesKHR = VkPhysicalDeviceShaderExpectAssumeFeatures; + +static { public const let VK_KHR_MAINTENANCE_6_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_6_EXTENSION_NAME = "VK_KHR_maintenance6"; } + +typealias VkPhysicalDeviceMaintenance6FeaturesKHR = VkPhysicalDeviceMaintenance6Features; +typealias VkPhysicalDeviceMaintenance6PropertiesKHR = VkPhysicalDeviceMaintenance6Properties; +typealias VkBindMemoryStatusKHR = VkBindMemoryStatus; +typealias VkBindDescriptorSetsInfoKHR = VkBindDescriptorSetsInfo; +typealias VkPushConstantsInfoKHR = VkPushConstantsInfo; + +typealias PFN_vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2; +typealias PFN_vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2; + +typealias VkPushDescriptorSetInfoKHR = VkPushDescriptorSetInfo; +typealias VkPushDescriptorSetWithTemplateInfoKHR = VkPushDescriptorSetWithTemplateInfo; + +typealias PFN_vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2; +typealias PFN_vkCmdPushDescriptorSetWithTemplate2KHR = PFN_vkCmdPushDescriptorSetWithTemplate2; + +[CRepr] struct VkSetDescriptorBufferOffsetsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags stageFlags = default; + public VkPipelineLayout layout = null; + public uint32 firstSet = 0; + public uint32 setCount = 0; + public uint32* pBufferIndices = null; + public VkDeviceSize* pOffsets = null; + + public this(void* pNext, VkShaderStageFlags stageFlags, VkPipelineLayout layout, uint32 firstSet, uint32 setCount, uint32* pBufferIndices, VkDeviceSize* pOffsets) : this() + { + this.pNext = pNext; + this.stageFlags = stageFlags; + this.layout = layout; + this.firstSet = firstSet; + this.setCount = setCount; + this.pBufferIndices = pBufferIndices; + this.pOffsets = pOffsets; + } +} + +[CRepr] struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags stageFlags = default; + public VkPipelineLayout layout = null; + public uint32 set = 0; + + public this(void* pNext, VkShaderStageFlags stageFlags, VkPipelineLayout layout = null, uint32 set = 0) : this() + { + this.pNext = pNext; + this.stageFlags = stageFlags; + this.layout = layout; + this.set = set; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + +// Individual APIs with dependencies on specific versions/extensions should get their own require blocks with depends= attribute set appropriately +static { public const let VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION = 1; } +static { public const let VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME = "VK_NV_descriptor_pool_overallocation"; } + +[CRepr] struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 descriptorPoolOverallocation = false; + + public this(void* pNext, VkBool32 descriptorPoolOverallocation) : this() + { + this.pNext = pNext; + this.descriptorPoolOverallocation = descriptorPoolOverallocation; + } +} + +static { public const let VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION = 1; } +static { public const let VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME = "VK_QCOM_tile_memory_heap"; } + +[CRepr] struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 tileMemoryHeap = false; + + public this(void* pNext, VkBool32 tileMemoryHeap) : this() + { + this.pNext = pNext; + this.tileMemoryHeap = tileMemoryHeap; + } +} + +[CRepr] struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 queueSubmitBoundary = false; + public VkBool32 tileBufferTransfers = false; + + public this(void* pNext, VkBool32 queueSubmitBoundary, VkBool32 tileBufferTransfers) : this() + { + this.pNext = pNext; + this.queueSubmitBoundary = queueSubmitBoundary; + this.tileBufferTransfers = tileBufferTransfers; + } +} + +[CRepr] struct VkTileMemoryRequirementsQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize size = default; + public VkDeviceSize alignment = default; + + public this(void* pNext, VkDeviceSize size, VkDeviceSize alignment) : this() + { + this.pNext = pNext; + this.size = size; + this.alignment = alignment; + } +} + +[CRepr] struct VkTileMemoryBindInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + + public this(void* pNext, VkDeviceMemory memory) : this() + { + this.pNext = pNext; + this.memory = memory; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo = null); + +[CRepr] struct VkTileMemorySizeInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize size = default; + + public this(void* pNext, VkDeviceSize size) : this() + { + this.pNext = pNext; + this.size = size; + } +} + +static { public const let VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION = 1; } +static { public const let VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME = "VK_KHR_copy_memory_indirect"; } + +[CRepr] struct VkStridedDeviceAddressRangeKHR : this() +{ + public VkDeviceAddress address = default; + public VkDeviceSize size = default; + public VkDeviceSize stride = default; + + public this(VkDeviceAddress address, VkDeviceSize size, VkDeviceSize stride) : this() + { + this.address = address; + this.size = size; + this.stride = stride; + } +} + +[AllowDuplicates] enum VkAddressCopyFlagBitsKHR : int32 +{ + [NoShow] VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 1 << 0, + [NoShow] VK_ADDRESS_COPY_SPARSE_BIT_KHR = 1 << 1, + [NoShow] VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 1 << 2, + // pretty names + DeviceLocalKHR = 1 << 0, + SparseKHR = 1 << 1, + ProtectedKHR = 1 << 2, +} + +typealias VkAddressCopyFlagsKHR = VkAddressCopyFlagBitsKHR; + +[CRepr] struct VkCopyMemoryIndirectCommandKHR : this() +{ + public VkDeviceAddress srcAddress = default; + public VkDeviceAddress dstAddress = default; + public VkDeviceSize size = default; + + public this(VkDeviceAddress srcAddress, VkDeviceAddress dstAddress, VkDeviceSize size) : this() + { + this.srcAddress = srcAddress; + this.dstAddress = dstAddress; + this.size = size; + } +} + +[CRepr] struct VkCopyMemoryIndirectInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAddressCopyFlagsKHR srcCopyFlags = default; + public VkAddressCopyFlagsKHR dstCopyFlags = default; + public uint32 copyCount = 0; + public VkStridedDeviceAddressRangeKHR copyAddressRange = default; + + public this(void* pNext, VkAddressCopyFlagsKHR srcCopyFlags, VkAddressCopyFlagsKHR dstCopyFlags, uint32 copyCount, VkStridedDeviceAddressRangeKHR copyAddressRange) : this() + { + this.pNext = pNext; + this.srcCopyFlags = srcCopyFlags; + this.dstCopyFlags = dstCopyFlags; + this.copyCount = copyCount; + this.copyAddressRange = copyAddressRange; + } +} + +[CRepr] struct VkCopyMemoryToImageIndirectCommandKHR : this() +{ + public VkDeviceAddress srcAddress = default; + public uint32 bufferRowLength = 0; + public uint32 bufferImageHeight = 0; + public VkImageSubresourceLayers imageSubresource = default; + public VkOffset3D imageOffset = default; + public VkExtent3D imageExtent = default; + + public this(VkDeviceAddress srcAddress, uint32 bufferRowLength, uint32 bufferImageHeight, VkImageSubresourceLayers imageSubresource, VkOffset3D imageOffset, VkExtent3D imageExtent) : this() + { + this.srcAddress = srcAddress; + this.bufferRowLength = bufferRowLength; + this.bufferImageHeight = bufferImageHeight; + this.imageSubresource = imageSubresource; + this.imageOffset = imageOffset; + this.imageExtent = imageExtent; + } +} + +[CRepr] struct VkCopyMemoryToImageIndirectInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAddressCopyFlagsKHR srcCopyFlags = default; + public uint32 copyCount = 0; + public VkStridedDeviceAddressRangeKHR copyAddressRange = default; + public VkImage dstImage = null; + public VkImageLayout dstImageLayout = default; + public VkImageSubresourceLayers* pImageSubresources = null; + public Span imageSubresources + { + get { return .(pImageSubresources, (.)copyCount); } + set mut { pImageSubresources = value.Ptr; copyCount = (.)value.Length; } + } + + public this(void* pNext, VkAddressCopyFlagsKHR srcCopyFlags, VkStridedDeviceAddressRangeKHR copyAddressRange, VkImage dstImage, VkImageLayout dstImageLayout, Span imageSubresources) : this() + { + this.pNext = pNext; + this.srcCopyFlags = srcCopyFlags; + this.copyAddressRange = copyAddressRange; + this.dstImage = dstImage; + this.dstImageLayout = dstImageLayout; + this.imageSubresources = imageSubresources; + } +} + +[CRepr] struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 indirectMemoryCopy = false; + public VkBool32 indirectMemoryToImageCopy = false; + + public this(void* pNext, VkBool32 indirectMemoryCopy, VkBool32 indirectMemoryToImageCopy) : this() + { + this.pNext = pNext; + this.indirectMemoryCopy = indirectMemoryCopy; + this.indirectMemoryToImageCopy = indirectMemoryToImageCopy; + } +} + +[CRepr] struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueueFlags supportedQueues = default; // Bitmask of VkQueueFlagBits indicating the family of queues that support indirect copy +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); + +static { public const let VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION = 1; } +static { public const let VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME = "VK_EXT_memory_decompression"; } + +[AllowDuplicates] enum VkMemoryDecompressionMethodFlagBitsEXT : int32 +{ + [NoShow] VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT = 1 << 0, + [NoShow] VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT, + // pretty names + Gdeflate1_0EXT = 1 << 0, + Gdeflate1_0NV = Gdeflate1_0EXT, +} + +typealias VkMemoryDecompressionMethodFlagsEXT = VkFlags64; + +[CRepr] struct VkDecompressMemoryInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryDecompressionMethodFlagsEXT decompressionMethod = default; + public uint32 regionCount = 0; + public VkDecompressMemoryRegionEXT* pRegions = null; + public Span regions + { + get { return .(pRegions, (.)regionCount); } + set mut { pRegions = value.Ptr; regionCount = (.)value.Length; } + } + + public this(void* pNext, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, Span regions) : this() + { + this.pNext = pNext; + this.decompressionMethod = decompressionMethod; + this.regions = regions; + } +} + +[CRepr] struct VkDecompressMemoryRegionEXT : this() +{ + public VkDeviceAddress srcAddress = default; + public VkDeviceAddress dstAddress = default; + public VkDeviceSize compressedSize = default; // Specified in bytes + public VkDeviceSize decompressedSize = default; // Specified in bytes + + public this(VkDeviceAddress srcAddress, VkDeviceAddress dstAddress, VkDeviceSize compressedSize, VkDeviceSize decompressedSize) : this() + { + this.srcAddress = srcAddress; + this.dstAddress = dstAddress; + this.compressedSize = compressedSize; + this.decompressedSize = decompressedSize; + } +} + +[CRepr] struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 memoryDecompression = false; + + public this(void* pNext, VkBool32 memoryDecompression) : this() + { + this.pNext = pNext; + this.memoryDecompression = memoryDecompression; + } +} + +[CRepr] struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkMemoryDecompressionMethodFlagsEXT decompressionMethods = default; + public uint64 maxDecompressionIndirectCount = 0; +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32 maxDecompressionCount, uint32 stride); + +static { public const let VK_NV_DISPLAY_STEREO_SPEC_VERSION = 1; } +static { public const let VK_NV_DISPLAY_STEREO_EXTENSION_NAME = "VK_NV_display_stereo"; } + +[CRepr] struct VkDisplaySurfaceStereoCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDisplaySurfaceStereoTypeNV stereoType = default; // The 3D stereo type to use when presenting this surface. + + public this(void* pNext, VkDisplaySurfaceStereoTypeNV stereoType) : this() + { + this.pNext = pNext; + this.stereoType = stereoType; + } +} + +[AllowDuplicates] enum VkDisplaySurfaceStereoTypeNV : int32 +{ + [NoShow] VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV = 0, + [NoShow] VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV = 1, + [NoShow] VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV = 2, + [NoShow] VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV = 3, + // pretty names + NoneNV = 0, + OnboardDinNV = 1, + Hdmi3dNV = 2, + InbandDisplayportNV = 3, +} + +[CRepr] struct VkDisplayModeStereoPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hdmi3DSupported = false; // Whether this mode supports HDMI 3D stereo rendering. +} + +static { public const let VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME = "VK_KHR_video_encode_intra_refresh"; } + +typealias VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagBitsKHR; + +[AllowDuplicates] enum VkVideoEncodeIntraRefreshModeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR = 0, + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR = 1 << 1, + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR = 1 << 3, + // pretty names + NoneKHR = 0, + PerPicturePartitionKHR = 1 << 0, + BlockBasedKHR = 1 << 1, + BlockRowBasedKHR = 1 << 2, + BlockColumnBasedKHR = 1 << 3, +} + +[CRepr] struct VkVideoEncodeIntraRefreshCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes = default; + public uint32 maxIntraRefreshCycleDuration = 0; + public uint32 maxIntraRefreshActiveReferencePictures = 0; + public VkBool32 partitionIndependentIntraRefreshRegions = false; + public VkBool32 nonRectangularIntraRefreshRegions = false; +} + +[CRepr] struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode = default; + + public this(void* pNext = null, VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode = default) : this() + { + this.pNext = pNext; + this.intraRefreshMode = intraRefreshMode; + } +} + +[CRepr] struct VkVideoEncodeIntraRefreshInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 intraRefreshCycleDuration = 0; + public uint32 intraRefreshIndex = 0; + + public this(void* pNext, uint32 intraRefreshCycleDuration, uint32 intraRefreshIndex) : this() + { + this.pNext = pNext; + this.intraRefreshCycleDuration = intraRefreshCycleDuration; + this.intraRefreshIndex = intraRefreshIndex; + } +} + +[CRepr] struct VkVideoReferenceIntraRefreshInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 dirtyIntraRefreshRegions = 0; + + public this(void* pNext, uint32 dirtyIntraRefreshRegions) : this() + { + this.pNext = pNext; + this.dirtyIntraRefreshRegions = dirtyIntraRefreshRegions; + } +} + +[CRepr] struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoEncodeIntraRefresh = false; + + public this(void* pNext, VkBool32 videoEncodeIntraRefresh) : this() + { + this.pNext = pNext; + this.videoEncodeIntraRefresh = videoEncodeIntraRefresh; + } +} + +static { public const let VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION = 2; } +static { public const let VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME = "VK_KHR_video_encode_quantization_map"; } + +[AllowDuplicates] enum VkVideoEncodeFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR = 1 << 2, + [NoShow] VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 1 << 0, + [NoShow] VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 1 << 1, + // pretty names + IntraRefreshKHR = 1 << 2, + WithQuantizationDeltaMapKHR = 1 << 0, + WithEmphasisMapKHR = 1 << 1, +} + +[AllowDuplicates] enum VkVideoSessionParametersCreateFlagBitsKHR : int32 +{ + [NoShow] VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR = 1 << 0, + // pretty names + QuantizationMapCompatibleKHR = 1 << 0, +} + +[CRepr] struct VkVideoEncodeQuantizationMapCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D maxQuantizationMapExtent = default; +} + +[CRepr] struct VkVideoFormatQuantizationMapPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D quantizationMapTexelSize = default; +} + +[CRepr] struct VkVideoEncodeQuantizationMapInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkImageView quantizationMap = null; + public VkExtent2D quantizationMapExtent = default; + + public this(void* pNext, VkImageView quantizationMap, VkExtent2D quantizationMapExtent) : this() + { + this.pNext = pNext; + this.quantizationMap = quantizationMap; + this.quantizationMapExtent = quantizationMapExtent; + } +} + +[CRepr] struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D quantizationMapTexelSize = default; + + public this(void* pNext, VkExtent2D quantizationMapTexelSize) : this() + { + this.pNext = pNext; + this.quantizationMapTexelSize = quantizationMapTexelSize; + } +} + +[CRepr] struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoEncodeQuantizationMap = false; + + public this(void* pNext, VkBool32 videoEncodeQuantizationMap) : this() + { + this.pNext = pNext; + this.videoEncodeQuantizationMap = videoEncodeQuantizationMap; + } +} + +[CRepr] struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 minQpDelta = 0; + public int32 maxQpDelta = 0; +} + +[CRepr] struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 minQpDelta = 0; + public int32 maxQpDelta = 0; +} + +[CRepr] struct VkVideoFormatH265QuantizationMapPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes = default; +} + +[CRepr] struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public int32 minQIndexDelta = 0; + public int32 maxQIndexDelta = 0; +} + +[CRepr] struct VkVideoFormatAV1QuantizationMapPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes = default; +} + +static { public const let VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION = 1; } +static { public const let VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME = "VK_NV_raw_access_chains"; } + +[CRepr] struct VkPhysicalDeviceRawAccessChainsFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderRawAccessChains = false; + + public this(void* pNext, VkBool32 shaderRawAccessChains) : this() + { + this.pNext = pNext; + this.shaderRawAccessChains = shaderRawAccessChains; + } +} + +static { public const let VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION = 1; } +static { public const let VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME = "VK_NV_external_compute_queue"; } + +struct VkExternalComputeQueueNV : int +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[CRepr] struct VkExternalComputeQueueDeviceCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 reservedExternalQueues = 0; + + public this(void* pNext, uint32 reservedExternalQueues) : this() + { + this.pNext = pNext; + this.reservedExternalQueues = reservedExternalQueues; + } +} + +[CRepr] struct VkExternalComputeQueueCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkQueue preferredQueue = null; + + public this(void* pNext, VkQueue preferredQueue) : this() + { + this.pNext = pNext; + this.preferredQueue = preferredQueue; + } +} + +[CRepr] struct VkExternalComputeQueueDataParamsNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 deviceIndex = 0; + + public this(void* pNext, uint32 deviceIndex) : this() + { + this.pNext = pNext; + this.deviceIndex = deviceIndex; + } +} + +[CRepr] struct VkPhysicalDeviceExternalComputeQueuePropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 externalDataSize = 0; + public uint32 maxExternalQueues = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueCreateInfoNV* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkExternalComputeQueueNV pExternalQueue); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, out VkExternalComputeQueueDataParamsNV @params, out void pData); + +static { public const let VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME = "VK_KHR_shader_relaxed_extended_instruction"; } + +[CRepr] struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderRelaxedExtendedInstruction = false; + + public this(void* pNext, VkBool32 shaderRelaxedExtendedInstruction) : this() + { + this.pNext = pNext; + this.shaderRelaxedExtendedInstruction = shaderRelaxedExtendedInstruction; + } +} + +static { public const let VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION = 1; } +static { public const let VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME = "VK_NV_command_buffer_inheritance"; } + +[CRepr] struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 commandBufferInheritance = false; + + public this(void* pNext, VkBool32 commandBufferInheritance) : this() + { + this.pNext = pNext; + this.commandBufferInheritance = commandBufferInheritance; + } +} + +static { public const let VK_KHR_MAINTENANCE_7_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_7_EXTENSION_NAME = "VK_KHR_maintenance7"; } + +[CRepr] struct VkPhysicalDeviceMaintenance7FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance7 = false; + + public this(void* pNext, VkBool32 maintenance7) : this() + { + this.pNext = pNext; + this.maintenance7 = maintenance7; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance7PropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 robustFragmentShadingRateAttachmentAccess = false; + public VkBool32 separateDepthStencilAttachmentAccess = false; + public uint32 maxDescriptorSetTotalUniformBuffersDynamic = 0; + public uint32 maxDescriptorSetTotalStorageBuffersDynamic = 0; + public uint32 maxDescriptorSetTotalBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = 0; + public uint32 maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = 0; +} + +[CRepr] struct VkPhysicalDeviceLayeredApiPropertiesListKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 layeredApiCount = 0; + public VkPhysicalDeviceLayeredApiPropertiesKHR* pLayeredApis = null; // Output list of layered implementations underneath the physical device + public Span layeredApis + { + get { return .(pLayeredApis, (.)layeredApiCount); } + set mut { pLayeredApis = value.Ptr; layeredApiCount = (.)value.Length; } + } + + public this(void* pNext = null, Span layeredApis = default) : this() + { + this.pNext = pNext; + this.layeredApis = layeredApis; + } +} + +[CRepr] struct VkPhysicalDeviceLayeredApiPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 vendorID = 0; + public uint32 deviceID = 0; + public VkPhysicalDeviceLayeredApiKHR layeredAPI = default; + public char8[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName = .(); +} + +[AllowDuplicates] enum VkPhysicalDeviceLayeredApiKHR : int32 +{ + [NoShow] VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR = 0, + [NoShow] VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR = 1, + [NoShow] VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR = 2, + [NoShow] VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR = 3, + [NoShow] VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR = 4, + // pretty names + VulkanKHR = 0, + D3d12KHR = 1, + MetalKHR = 2, + OpenglKHR = 3, + OpenglesKHR = 4, +} + +[CRepr] struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceProperties2 properties = default; +} + +static { public const let VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION = 1; } +static { public const let VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME = "VK_NV_shader_atomic_float16_vector"; } + +[CRepr] struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderFloat16VectorAtomics = false; + + public this(void* pNext, VkBool32 shaderFloat16VectorAtomics) : this() + { + this.pNext = pNext; + this.shaderFloat16VectorAtomics = shaderFloat16VectorAtomics; + } +} + +static { public const let VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME = "VK_EXT_shader_replicated_composites"; } + +[CRepr] struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderReplicatedComposites = false; + + public this(void* pNext, VkBool32 shaderReplicatedComposites) : this() + { + this.pNext = pNext; + this.shaderReplicatedComposites = shaderReplicatedComposites; + } +} + +static { public const let VK_EXT_SHADER_FLOAT8_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_FLOAT8_EXTENSION_NAME = "VK_EXT_shader_float8"; } + +[CRepr] struct VkPhysicalDeviceShaderFloat8FeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderFloat8 = false; + public VkBool32 shaderFloat8CooperativeMatrix = false; + + public this(void* pNext, VkBool32 shaderFloat8, VkBool32 shaderFloat8CooperativeMatrix) : this() + { + this.pNext = pNext; + this.shaderFloat8 = shaderFloat8; + this.shaderFloat8CooperativeMatrix = shaderFloat8CooperativeMatrix; + } +} + +static { public const let VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION = 1; } +static { public const let VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME = "VK_NV_ray_tracing_validation"; } + +[CRepr] struct VkPhysicalDeviceRayTracingValidationFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingValidation = false; + + public this(void* pNext, VkBool32 rayTracingValidation) : this() + { + this.pNext = pNext; + this.rayTracingValidation = rayTracingValidation; + } +} + +static { public const let VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION = 4; } +static { public const let VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME = "VK_NV_cluster_acceleration_structure"; } + +[CRepr] struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 clusterAccelerationStructure = false; + + public this(void* pNext, VkBool32 clusterAccelerationStructure) : this() + { + this.pNext = pNext; + this.clusterAccelerationStructure = clusterAccelerationStructure; + } +} + +[CRepr] struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxVerticesPerCluster = 0; + public uint32 maxTrianglesPerCluster = 0; + public uint32 clusterScratchByteAlignment = 0; + public uint32 clusterByteAlignment = 0; + public uint32 clusterTemplateByteAlignment = 0; + public uint32 clusterBottomLevelByteAlignment = 0; + public uint32 clusterTemplateBoundsByteAlignment = 0; + public uint32 maxClusterGeometryIndex = 0; +} + +[CRepr] struct VkClusterAccelerationStructureClustersBottomLevelInputNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxTotalClusterCount = 0; + public uint32 maxClusterCountPerAccelerationStructure = 0; + + public this(void* pNext, uint32 maxTotalClusterCount, uint32 maxClusterCountPerAccelerationStructure) : this() + { + this.pNext = pNext; + this.maxTotalClusterCount = maxTotalClusterCount; + this.maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure; + } +} + +[CRepr] struct VkClusterAccelerationStructureTriangleClusterInputNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkFormat vertexFormat = default; + public uint32 maxGeometryIndexValue = 0; + public uint32 maxClusterUniqueGeometryCount = 0; + public uint32 maxClusterTriangleCount = 0; + public uint32 maxClusterVertexCount = 0; + public uint32 maxTotalTriangleCount = 0; + public uint32 maxTotalVertexCount = 0; + public uint32 minPositionTruncateBitCount = 0; + + public this(void* pNext, VkFormat vertexFormat, uint32 maxGeometryIndexValue, uint32 maxClusterUniqueGeometryCount, uint32 maxClusterTriangleCount, uint32 maxClusterVertexCount, uint32 maxTotalTriangleCount, uint32 maxTotalVertexCount, uint32 minPositionTruncateBitCount) : this() + { + this.pNext = pNext; + this.vertexFormat = vertexFormat; + this.maxGeometryIndexValue = maxGeometryIndexValue; + this.maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount; + this.maxClusterTriangleCount = maxClusterTriangleCount; + this.maxClusterVertexCount = maxClusterVertexCount; + this.maxTotalTriangleCount = maxTotalTriangleCount; + this.maxTotalVertexCount = maxTotalVertexCount; + this.minPositionTruncateBitCount = minPositionTruncateBitCount; + } +} + +[CRepr] struct VkClusterAccelerationStructureMoveObjectsInputNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkClusterAccelerationStructureTypeNV type = default; + public VkBool32 noMoveOverlap = false; + public VkDeviceSize maxMovedBytes = default; + + public this(void* pNext, VkClusterAccelerationStructureTypeNV type, VkBool32 noMoveOverlap, VkDeviceSize maxMovedBytes) : this() + { + this.pNext = pNext; + this.type = type; + this.noMoveOverlap = noMoveOverlap; + this.maxMovedBytes = maxMovedBytes; + } +} + +[CRepr, Union] struct VkClusterAccelerationStructureOpInputNV : this() +{ + public VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel = null; + public VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters = null; + public VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects = null; + + public this(VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel, VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters, VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects) : this() + { + this.pClustersBottomLevel = pClustersBottomLevel; + this.pTriangleClusters = pTriangleClusters; + this.pMoveObjects = pMoveObjects; + } +} + +[CRepr] struct VkClusterAccelerationStructureInputInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxAccelerationStructureCount = 0; + public VkBuildAccelerationStructureFlagsKHR flags = default; + public VkClusterAccelerationStructureOpTypeNV opType = default; + public VkClusterAccelerationStructureOpModeNV opMode = default; + public VkClusterAccelerationStructureOpInputNV opInput = default; + + public this(void* pNext, uint32 maxAccelerationStructureCount, VkBuildAccelerationStructureFlagsKHR flags, VkClusterAccelerationStructureOpTypeNV opType, VkClusterAccelerationStructureOpModeNV opMode, VkClusterAccelerationStructureOpInputNV opInput) : this() + { + this.pNext = pNext; + this.maxAccelerationStructureCount = maxAccelerationStructureCount; + this.flags = flags; + this.opType = opType; + this.opMode = opMode; + this.opInput = opInput; + } +} + +[CRepr] struct VkClusterAccelerationStructureCommandsInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkClusterAccelerationStructureInputInfoNV input = default; + public VkDeviceAddress dstImplicitData = default; + public VkDeviceAddress scratchData = default; + public VkStridedDeviceAddressRegionKHR dstAddressesArray = default; + public VkStridedDeviceAddressRegionKHR dstSizesArray = default; + public VkStridedDeviceAddressRegionKHR srcInfosArray = default; + public VkDeviceAddress srcInfosCount = default; + public VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags = default; + + public this(void* pNext, VkClusterAccelerationStructureInputInfoNV input, VkDeviceAddress dstImplicitData, VkDeviceAddress scratchData, VkStridedDeviceAddressRegionKHR dstAddressesArray, VkStridedDeviceAddressRegionKHR dstSizesArray, VkStridedDeviceAddressRegionKHR srcInfosArray, VkDeviceAddress srcInfosCount, VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags = default) : this() + { + this.pNext = pNext; + this.input = input; + this.dstImplicitData = dstImplicitData; + this.scratchData = scratchData; + this.dstAddressesArray = dstAddressesArray; + this.dstSizesArray = dstSizesArray; + this.srcInfosArray = srcInfosArray; + this.srcInfosCount = srcInfosCount; + this.addressResolutionFlags = addressResolutionFlags; + } +} + +[CRepr] struct VkStridedDeviceAddressNV : this() +{ + public VkDeviceAddress startAddress = default; + public VkDeviceSize strideInBytes = default; // Specified in bytes + + public this(VkDeviceAddress startAddress, VkDeviceSize strideInBytes) : this() + { + this.startAddress = startAddress; + this.strideInBytes = strideInBytes; + } +} + +[CRepr] struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV : this() +{ + + [Bitfield(.Public, .Bits(24), "geometryIndex")] + [Bitfield(.Public, .Bits(5), "reserved")] + [Bitfield(.Public, .Bits(3), "geometryFlags")] + private uint32 __bitfields_geometryFlags = 0; + + public this(uint32 geometryIndex, uint32 reserved, uint32 geometryFlags) : this() + { + this.geometryIndex = geometryIndex; + this.reserved = reserved; + this.geometryFlags = geometryFlags; + } +} + +typealias VkClusterAccelerationStructureClusterFlagsNV = VkClusterAccelerationStructureClusterFlagBitsNV; + +[AllowDuplicates] enum VkClusterAccelerationStructureClusterFlagBitsNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV = 1 << 0, + // pretty names + AllowDisableOpacityMicromapsNV = 1 << 0, +} + +typealias VkClusterAccelerationStructureGeometryFlagsNV = VkClusterAccelerationStructureGeometryFlagBitsNV; + +[AllowDuplicates] enum VkClusterAccelerationStructureGeometryFlagBitsNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV = 1 << 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV = 1 << 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV = 1 << 2, + // pretty names + CullDisableNV = 1 << 0, + NoDuplicateAnyhitInvocationNV = 1 << 1, + OpaqueNV = 1 << 2, +} + +typealias VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagBitsNV; + +[AllowDuplicates] enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV = 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 1 << 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 1 << 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 1 << 2, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV = 1 << 3, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV = 1 << 4, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV = 1 << 5, + // pretty names + NoneNV = 0, + IndirectedDstImplicitDataNV = 1 << 0, + IndirectedScratchDataNV = 1 << 1, + IndirectedDstAddressArrayNV = 1 << 2, + IndirectedDstSizesArrayNV = 1 << 3, + IndirectedSrcInfosArrayNV = 1 << 4, + IndirectedSrcInfosCountNV = 1 << 5, +} + +[CRepr] struct VkClusterAccelerationStructureMoveObjectsInfoNV : this() +{ + public VkDeviceAddress srcAccelerationStructure = default; + + public this(VkDeviceAddress srcAccelerationStructure) : this() + { + this.srcAccelerationStructure = srcAccelerationStructure; + } +} + +[CRepr] struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV : this() +{ + public uint32 clusterReferencesCount = 0; + public uint32 clusterReferencesStride = 0; + public VkDeviceAddress clusterReferences = default; + + public this(uint32 clusterReferencesCount, uint32 clusterReferencesStride, VkDeviceAddress clusterReferences) : this() + { + this.clusterReferencesCount = clusterReferencesCount; + this.clusterReferencesStride = clusterReferencesStride; + this.clusterReferences = clusterReferences; + } +} + +[CRepr] struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV : this() +{ + + public uint32 clusterID = 0; + public VkClusterAccelerationStructureClusterFlagsNV clusterFlags = default; + [Bitfield(.Public, .Bits(9), "triangleCount")] + [Bitfield(.Public, .Bits(9), "vertexCount")] + [Bitfield(.Public, .Bits(6), "positionTruncateBitCount")] + [Bitfield(.Public, .Bits(4), "indexType")] + [Bitfield(.Public, .Bits(4), "opacityMicromapIndexType")] + private uint32 __bitfields_opacityMicromapIndexType = 0; + public VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = default; + public uint16 indexBufferStride = 0; + public uint16 vertexBufferStride = 0; + public uint16 geometryIndexAndFlagsBufferStride = 0; + public uint16 opacityMicromapIndexBufferStride = 0; + public VkDeviceAddress indexBuffer = default; + public VkDeviceAddress vertexBuffer = default; + public VkDeviceAddress geometryIndexAndFlagsBuffer = default; + public VkDeviceAddress opacityMicromapArray = default; + public VkDeviceAddress opacityMicromapIndexBuffer = default; + + public this(uint32 clusterID, VkClusterAccelerationStructureClusterFlagsNV clusterFlags, uint32 triangleCount, uint32 vertexCount, uint32 positionTruncateBitCount, uint32 indexType, uint32 opacityMicromapIndexType, VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags, uint16 indexBufferStride, uint16 vertexBufferStride, uint16 geometryIndexAndFlagsBufferStride, uint16 opacityMicromapIndexBufferStride, VkDeviceAddress indexBuffer, VkDeviceAddress vertexBuffer, VkDeviceAddress geometryIndexAndFlagsBuffer, VkDeviceAddress opacityMicromapArray, VkDeviceAddress opacityMicromapIndexBuffer) : this() + { + this.clusterID = clusterID; + this.clusterFlags = clusterFlags; + this.triangleCount = triangleCount; + this.vertexCount = vertexCount; + this.positionTruncateBitCount = positionTruncateBitCount; + this.indexType = indexType; + this.opacityMicromapIndexType = opacityMicromapIndexType; + this.baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags; + this.indexBufferStride = indexBufferStride; + this.vertexBufferStride = vertexBufferStride; + this.geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride; + this.opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride; + this.indexBuffer = indexBuffer; + this.vertexBuffer = vertexBuffer; + this.geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer; + this.opacityMicromapArray = opacityMicromapArray; + this.opacityMicromapIndexBuffer = opacityMicromapIndexBuffer; + } +} + +[CRepr] struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV : this() +{ + + public uint32 clusterID = 0; + public VkClusterAccelerationStructureClusterFlagsNV clusterFlags = default; + [Bitfield(.Public, .Bits(9), "triangleCount")] + [Bitfield(.Public, .Bits(9), "vertexCount")] + [Bitfield(.Public, .Bits(6), "positionTruncateBitCount")] + [Bitfield(.Public, .Bits(4), "indexType")] + [Bitfield(.Public, .Bits(4), "opacityMicromapIndexType")] + private uint32 __bitfields_opacityMicromapIndexType = 0; + public VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = default; + public uint16 indexBufferStride = 0; + public uint16 vertexBufferStride = 0; + public uint16 geometryIndexAndFlagsBufferStride = 0; + public uint16 opacityMicromapIndexBufferStride = 0; + public VkDeviceAddress indexBuffer = default; + public VkDeviceAddress vertexBuffer = default; + public VkDeviceAddress geometryIndexAndFlagsBuffer = default; + public VkDeviceAddress opacityMicromapArray = default; + public VkDeviceAddress opacityMicromapIndexBuffer = default; + public VkDeviceAddress instantiationBoundingBoxLimit = default; + + public this(uint32 clusterID, VkClusterAccelerationStructureClusterFlagsNV clusterFlags, uint32 triangleCount, uint32 vertexCount, uint32 positionTruncateBitCount, uint32 indexType, uint32 opacityMicromapIndexType, VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags, uint16 indexBufferStride, uint16 vertexBufferStride, uint16 geometryIndexAndFlagsBufferStride, uint16 opacityMicromapIndexBufferStride, VkDeviceAddress indexBuffer, VkDeviceAddress vertexBuffer, VkDeviceAddress geometryIndexAndFlagsBuffer, VkDeviceAddress opacityMicromapArray, VkDeviceAddress opacityMicromapIndexBuffer, VkDeviceAddress instantiationBoundingBoxLimit) : this() + { + this.clusterID = clusterID; + this.clusterFlags = clusterFlags; + this.triangleCount = triangleCount; + this.vertexCount = vertexCount; + this.positionTruncateBitCount = positionTruncateBitCount; + this.indexType = indexType; + this.opacityMicromapIndexType = opacityMicromapIndexType; + this.baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags; + this.indexBufferStride = indexBufferStride; + this.vertexBufferStride = vertexBufferStride; + this.geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride; + this.opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride; + this.indexBuffer = indexBuffer; + this.vertexBuffer = vertexBuffer; + this.geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer; + this.opacityMicromapArray = opacityMicromapArray; + this.opacityMicromapIndexBuffer = opacityMicromapIndexBuffer; + this.instantiationBoundingBoxLimit = instantiationBoundingBoxLimit; + } +} + +[CRepr] struct VkClusterAccelerationStructureInstantiateClusterInfoNV : this() +{ + public uint32 clusterIdOffset = 0; + [Bitfield(.Public, .Bits(24), "geometryIndexOffset")] + [Bitfield(.Public, .Bits(8), "reserved")] + private uint32 __bitfields_reserved = 0; + public VkDeviceAddress clusterTemplateAddress = default; + public VkStridedDeviceAddressNV vertexBuffer = default; + + public this(uint32 clusterIdOffset, uint32 geometryIndexOffset, uint32 reserved, VkDeviceAddress clusterTemplateAddress, VkStridedDeviceAddressNV vertexBuffer) : this() + { + this.clusterIdOffset = clusterIdOffset; + this.geometryIndexOffset = geometryIndexOffset; + this.reserved = reserved; + this.clusterTemplateAddress = clusterTemplateAddress; + this.vertexBuffer = vertexBuffer; + } +} + +[AllowDuplicates] enum VkClusterAccelerationStructureIndexFormatFlagBitsNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV = 1 << 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV = 1 << 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV = 1 << 2, + // pretty names + _8bitNV = 1 << 0, + _16bitNV = 1 << 1, + _32bitNV = 1 << 2, +} + +typealias VkClusterAccelerationStructureIndexFormatFlagsNV = VkClusterAccelerationStructureIndexFormatFlagBitsNV; + +[AllowDuplicates] enum VkClusterAccelerationStructureTypeNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV = 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV = 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV = 2, + // pretty names + ClustersBottomLevelNV = 0, + TriangleClusterNV = 1, + TriangleClusterTemplateNV = 2, +} + +[AllowDuplicates] enum VkClusterAccelerationStructureOpTypeNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV = 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV = 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV = 5, + // pretty names + MoveObjectsNV = 0, + BuildClustersBottomLevelNV = 1, + BuildTriangleClusterNV = 2, + BuildTriangleClusterTemplateNV = 3, + InstantiateTriangleClusterNV = 4, + GetClusterTemplateIndicesNV = 5, +} + +[AllowDuplicates] enum VkClusterAccelerationStructureOpModeNV : int32 +{ + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV = 0, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV = 1, + [NoShow] VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV = 2, + // pretty names + ImplicitDestinationsNV = 0, + ExplicitDestinationsNV = 1, + ComputeSizesNV = 2, +} + +[CRepr] struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV : this() +{ + public VkDeviceAddress clusterTemplateAddress = default; + + public this(VkDeviceAddress clusterTemplateAddress) : this() + { + this.clusterTemplateAddress = clusterTemplateAddress; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, VkClusterAccelerationStructureInputInfoNV* pInfo, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildClusterAccelerationStructureIndirectNV(VkCommandBuffer commandBuffer, VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); + +[CRepr] struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 allowClusterAccelerationStructure = false; + + public this(void* pNext, VkBool32 allowClusterAccelerationStructure) : this() + { + this.pNext = pNext; + this.allowClusterAccelerationStructure = allowClusterAccelerationStructure; + } +} + +static { public const let VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION = 1; } +static { public const let VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME = "VK_NV_partitioned_acceleration_structure"; } +static { public const uint32 VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV = (~0U); } + +[CRepr] struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 partitionedAccelerationStructure = false; + + public this(void* pNext, VkBool32 partitionedAccelerationStructure) : this() + { + this.pNext = pNext; + this.partitionedAccelerationStructure = partitionedAccelerationStructure; + } +} + +[CRepr] struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxPartitionCount = 0; +} + +[CRepr] struct VkPartitionedAccelerationStructureFlagsNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 enablePartitionTranslation = false; + + public this(void* pNext, VkBool32 enablePartitionTranslation) : this() + { + this.pNext = pNext; + this.enablePartitionTranslation = enablePartitionTranslation; + } +} + +[AllowDuplicates] enum VkPartitionedAccelerationStructureOpTypeNV : int32 +{ + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV = 0, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV = 1, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV = 2, + // pretty names + WriteInstanceNV = 0, + UpdateInstanceNV = 1, + WritePartitionTranslationNV = 2, +} + +[CRepr] struct VkBuildPartitionedAccelerationStructureIndirectCommandNV : this() +{ + public VkPartitionedAccelerationStructureOpTypeNV opType = default; + public uint32 argCount = 0; + public VkStridedDeviceAddressNV argData = default; + + public this(VkPartitionedAccelerationStructureOpTypeNV opType, uint32 argCount, VkStridedDeviceAddressNV argData) : this() + { + this.opType = opType; + this.argCount = argCount; + this.argData = argData; + } +} + +typealias VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagBitsNV; + +[AllowDuplicates] enum VkPartitionedAccelerationStructureInstanceFlagBitsNV : int32 +{ + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV = 1 << 0, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV = 1 << 1, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV = 1 << 2, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV = 1 << 3, + [NoShow] VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV = 1 << 4, + // pretty names + FlagTriangleFacingCullDisableNV = 1 << 0, + FlagTriangleFlipFacingNV = 1 << 1, + FlagForceOpaqueNV = 1 << 2, + FlagForceNoOpaqueNV = 1 << 3, + FlagEnableExplicitBoundingBoxNV = 1 << 4, +} + +[CRepr] struct VkPartitionedAccelerationStructureWriteInstanceDataNV : this() +{ + public VkTransformMatrixKHR transform = default; + public float[6] explicitAABB = .(); + public uint32 instanceID = 0; + public uint32 instanceMask = 0; + public uint32 instanceContributionToHitGroupIndex = 0; + public VkPartitionedAccelerationStructureInstanceFlagsNV instanceFlags = default; + public uint32 instanceIndex = 0; + public uint32 partitionIndex = 0; + public VkDeviceAddress accelerationStructure = default; + + public this(VkTransformMatrixKHR transform, float[6] explicitAABB, uint32 instanceID, uint32 instanceMask, uint32 instanceContributionToHitGroupIndex, VkPartitionedAccelerationStructureInstanceFlagsNV instanceFlags, uint32 instanceIndex, uint32 partitionIndex, VkDeviceAddress accelerationStructure) : this() + { + this.transform = transform; + this.explicitAABB = explicitAABB; + this.instanceID = instanceID; + this.instanceMask = instanceMask; + this.instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex; + this.instanceFlags = instanceFlags; + this.instanceIndex = instanceIndex; + this.partitionIndex = partitionIndex; + this.accelerationStructure = accelerationStructure; + } +} + +[CRepr] struct VkPartitionedAccelerationStructureUpdateInstanceDataNV : this() +{ + public uint32 instanceIndex = 0; + public uint32 instanceContributionToHitGroupIndex = 0; + public VkDeviceAddress accelerationStructure = default; + + public this(uint32 instanceIndex, uint32 instanceContributionToHitGroupIndex, VkDeviceAddress accelerationStructure) : this() + { + this.instanceIndex = instanceIndex; + this.instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex; + this.accelerationStructure = accelerationStructure; + } +} + +[CRepr] struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV : this() +{ + public uint32 partitionIndex = 0; + public float[3] partitionTranslation = .(); + + public this(uint32 partitionIndex, float[3] partitionTranslation) : this() + { + this.partitionIndex = partitionIndex; + this.partitionTranslation = partitionTranslation; + } +} + +[CRepr] struct VkWriteDescriptorSetPartitionedAccelerationStructureNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 accelerationStructureCount = 0; + public VkDeviceAddress* pAccelerationStructures = null; + public Span accelerationStructures + { + get { return .(pAccelerationStructures, (.)accelerationStructureCount); } + set mut { pAccelerationStructures = value.Ptr; accelerationStructureCount = (.)value.Length; } + } + + public this(void* pNext, Span accelerationStructures) : this() + { + this.pNext = pNext; + this.accelerationStructures = accelerationStructures; + } +} + +[CRepr] struct VkPartitionedAccelerationStructureInstancesInputNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBuildAccelerationStructureFlagsKHR flags = default; + public uint32 instanceCount = 0; + public uint32 maxInstancePerPartitionCount = 0; + public uint32 partitionCount = 0; + public uint32 maxInstanceInGlobalPartitionCount = 0; + + public this(void* pNext, VkBuildAccelerationStructureFlagsKHR flags, uint32 instanceCount, uint32 maxInstancePerPartitionCount, uint32 partitionCount, uint32 maxInstanceInGlobalPartitionCount) : this() + { + this.pNext = pNext; + this.flags = flags; + this.instanceCount = instanceCount; + this.maxInstancePerPartitionCount = maxInstancePerPartitionCount; + this.partitionCount = partitionCount; + this.maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount; + } +} + +[CRepr] struct VkBuildPartitionedAccelerationStructureInfoNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPartitionedAccelerationStructureInstancesInputNV input = default; + public VkDeviceAddress srcAccelerationStructureData = default; + public VkDeviceAddress dstAccelerationStructureData = default; + public VkDeviceAddress scratchData = default; + public VkDeviceAddress srcInfos = default; + public VkDeviceAddress srcInfosCount = default; + + public this(void* pNext, VkPartitionedAccelerationStructureInstancesInputNV input, VkDeviceAddress srcAccelerationStructureData, VkDeviceAddress dstAccelerationStructureData, VkDeviceAddress scratchData, VkDeviceAddress srcInfos, VkDeviceAddress srcInfosCount) : this() + { + this.pNext = pNext; + this.input = input; + this.srcAccelerationStructureData = srcAccelerationStructureData; + this.dstAccelerationStructureData = dstAccelerationStructureData; + this.scratchData = scratchData; + this.srcInfos = srcInfos; + this.srcInfosCount = srcInfosCount; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, VkPartitionedAccelerationStructureInstancesInputNV* pInfo, out VkAccelerationStructureBuildSizesInfoKHR pSizeInfo); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBuildPartitionedAccelerationStructuresNV(VkCommandBuffer commandBuffer, VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); + +static { public const let VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = "VK_EXT_device_generated_commands"; } + +[CRepr] struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 deviceGeneratedCommands = false; + public VkBool32 dynamicGeneratedPipelineLayout = false; + + public this(void* pNext, VkBool32 deviceGeneratedCommands, VkBool32 dynamicGeneratedPipelineLayout) : this() + { + this.pNext = pNext; + this.deviceGeneratedCommands = deviceGeneratedCommands; + this.dynamicGeneratedPipelineLayout = dynamicGeneratedPipelineLayout; + } +} + +[CRepr] struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxIndirectPipelineCount = 0; + public uint32 maxIndirectShaderObjectCount = 0; + public uint32 maxIndirectSequenceCount = 0; + public uint32 maxIndirectCommandsTokenCount = 0; + public uint32 maxIndirectCommandsTokenOffset = 0; + public uint32 maxIndirectCommandsIndirectStride = 0; + public VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes = default; + public VkShaderStageFlags supportedIndirectCommandsShaderStages = default; + public VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding = default; + public VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding = default; + public VkBool32 deviceGeneratedCommandsTransformFeedback = false; + public VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount = false; +} + +[CRepr] struct VkGeneratedCommandsMemoryRequirementsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectExecutionSetEXT indirectExecutionSet = null; + public VkIndirectCommandsLayoutEXT indirectCommandsLayout = null; + public uint32 maxSequenceCount = 0; + public uint32 maxDrawCount = 0; + + public this(void* pNext, VkIndirectExecutionSetEXT indirectExecutionSet, VkIndirectCommandsLayoutEXT indirectCommandsLayout, uint32 maxSequenceCount, uint32 maxDrawCount) : this() + { + this.pNext = pNext; + this.indirectExecutionSet = indirectExecutionSet; + this.indirectCommandsLayout = indirectCommandsLayout; + this.maxSequenceCount = maxSequenceCount; + this.maxDrawCount = maxDrawCount; + } +} + +[CRepr] struct VkIndirectExecutionSetCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectExecutionSetInfoTypeEXT type = default; + public VkIndirectExecutionSetInfoEXT info = default; + + public this(void* pNext, VkIndirectExecutionSetInfoTypeEXT type, VkIndirectExecutionSetInfoEXT info) : this() + { + this.pNext = pNext; + this.type = type; + this.info = info; + } +} + +[CRepr, Union] struct VkIndirectExecutionSetInfoEXT : this() +{ + public VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo = null; + public VkIndirectExecutionSetShaderInfoEXT* pShaderInfo = null; + + public this(VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo, VkIndirectExecutionSetShaderInfoEXT* pShaderInfo) : this() + { + this.pPipelineInfo = pPipelineInfo; + this.pShaderInfo = pShaderInfo; + } +} + +[CRepr] struct VkIndirectExecutionSetPipelineInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline initialPipeline = null; + public uint32 maxPipelineCount = 0; + + public this(void* pNext, VkPipeline initialPipeline, uint32 maxPipelineCount) : this() + { + this.pNext = pNext; + this.initialPipeline = initialPipeline; + this.maxPipelineCount = maxPipelineCount; + } +} + +[CRepr] struct VkIndirectExecutionSetShaderInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderCount = 0; + public VkShaderEXT* pInitialShaders = null; + public VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos = null; + public uint32 maxShaderCount = 0; + public uint32 pushConstantRangeCount = 0; + public VkPushConstantRange* pPushConstantRanges = null; + public Span pushConstantRanges + { + get { return .(pPushConstantRanges, (.)pushConstantRangeCount); } + set mut { pPushConstantRanges = value.Ptr; pushConstantRangeCount = (.)value.Length; } + } + + public this(void* pNext, uint32 shaderCount, VkShaderEXT* pInitialShaders, VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos, uint32 maxShaderCount, Span pushConstantRanges = default) : this() + { + this.pNext = pNext; + this.shaderCount = shaderCount; + this.pInitialShaders = pInitialShaders; + this.pSetLayoutInfos = pSetLayoutInfos; + this.maxShaderCount = maxShaderCount; + this.pushConstantRanges = pushConstantRanges; + } +} + +[CRepr] struct VkGeneratedCommandsInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkShaderStageFlags shaderStages = default; + public VkIndirectExecutionSetEXT indirectExecutionSet = null; + public VkIndirectCommandsLayoutEXT indirectCommandsLayout = null; + public VkDeviceAddress indirectAddress = default; + public VkDeviceSize indirectAddressSize = default; + public VkDeviceAddress preprocessAddress = default; + public VkDeviceSize preprocessSize = default; + public uint32 maxSequenceCount = 0; + public VkDeviceAddress sequenceCountAddress = default; + public uint32 maxDrawCount = 0; + + public this(void* pNext, VkShaderStageFlags shaderStages, VkIndirectExecutionSetEXT indirectExecutionSet, VkIndirectCommandsLayoutEXT indirectCommandsLayout, VkDeviceAddress indirectAddress, VkDeviceSize indirectAddressSize, VkDeviceAddress preprocessAddress, VkDeviceSize preprocessSize, uint32 maxSequenceCount, VkDeviceAddress sequenceCountAddress, uint32 maxDrawCount) : this() + { + this.pNext = pNext; + this.shaderStages = shaderStages; + this.indirectExecutionSet = indirectExecutionSet; + this.indirectCommandsLayout = indirectCommandsLayout; + this.indirectAddress = indirectAddress; + this.indirectAddressSize = indirectAddressSize; + this.preprocessAddress = preprocessAddress; + this.preprocessSize = preprocessSize; + this.maxSequenceCount = maxSequenceCount; + this.sequenceCountAddress = sequenceCountAddress; + this.maxDrawCount = maxDrawCount; + } +} + +[CRepr] struct VkWriteIndirectExecutionSetPipelineEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 index = 0; + public VkPipeline pipeline = null; + + public this(void* pNext, uint32 index, VkPipeline pipeline) : this() + { + this.pNext = pNext; + this.index = index; + this.pipeline = pipeline; + } +} + +[CRepr] struct VkIndirectCommandsLayoutCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectCommandsLayoutUsageFlagsEXT flags = default; + public VkShaderStageFlags shaderStages = default; + public uint32 indirectStride = 0; + public VkPipelineLayout pipelineLayout = null; + public uint32 tokenCount = 0; + public VkIndirectCommandsLayoutTokenEXT* pTokens = null; + public Span tokens + { + get { return .(pTokens, (.)tokenCount); } + set mut { pTokens = value.Ptr; tokenCount = (.)value.Length; } + } + + public this(void* pNext, VkIndirectCommandsLayoutUsageFlagsEXT flags, VkShaderStageFlags shaderStages, uint32 indirectStride, VkPipelineLayout pipelineLayout, Span tokens) : this() + { + this.pNext = pNext; + this.flags = flags; + this.shaderStages = shaderStages; + this.indirectStride = indirectStride; + this.pipelineLayout = pipelineLayout; + this.tokens = tokens; + } +} + +[CRepr] struct VkIndirectCommandsLayoutTokenEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkIndirectCommandsTokenTypeEXT type = default; + public VkIndirectCommandsTokenDataEXT data = default; + public uint32 offset = 0; + + public this(void* pNext, VkIndirectCommandsTokenTypeEXT type, VkIndirectCommandsTokenDataEXT data, uint32 offset) : this() + { + this.pNext = pNext; + this.type = type; + this.data = data; + this.offset = offset; + } +} + +[CRepr] struct VkDrawIndirectCountIndirectCommandEXT : this() +{ + public VkDeviceAddress bufferAddress = default; + public uint32 stride = 0; + public uint32 commandCount = 0; + + public this(VkDeviceAddress bufferAddress, uint32 stride, uint32 commandCount) : this() + { + this.bufferAddress = bufferAddress; + this.stride = stride; + this.commandCount = commandCount; + } +} + +[CRepr] struct VkIndirectCommandsVertexBufferTokenEXT : this() +{ + public uint32 vertexBindingUnit = 0; + + public this(uint32 vertexBindingUnit) : this() + { + this.vertexBindingUnit = vertexBindingUnit; + } +} + +[CRepr] struct VkBindVertexBufferIndirectCommandEXT : this() +{ + public VkDeviceAddress bufferAddress = default; + public uint32 size = 0; + public uint32 stride = 0; + + public this(VkDeviceAddress bufferAddress, uint32 size, uint32 stride) : this() + { + this.bufferAddress = bufferAddress; + this.size = size; + this.stride = stride; + } +} + +[CRepr] struct VkIndirectCommandsIndexBufferTokenEXT : this() +{ + public VkIndirectCommandsInputModeFlagBitsEXT mode = default; + + public this(VkIndirectCommandsInputModeFlagBitsEXT mode) : this() + { + this.mode = mode; + } +} + +[CRepr] struct VkBindIndexBufferIndirectCommandEXT : this() +{ + public VkDeviceAddress bufferAddress = default; + public uint32 size = 0; + public VkIndexType indexType = default; + + public this(VkDeviceAddress bufferAddress, uint32 size, VkIndexType indexType) : this() + { + this.bufferAddress = bufferAddress; + this.size = size; + this.indexType = indexType; + } +} + +[CRepr] struct VkIndirectCommandsPushConstantTokenEXT : this() +{ + public VkPushConstantRange updateRange = default; + + public this(VkPushConstantRange updateRange) : this() + { + this.updateRange = updateRange; + } +} + +[CRepr] struct VkIndirectCommandsExecutionSetTokenEXT : this() +{ + public VkIndirectExecutionSetInfoTypeEXT type = default; + public VkShaderStageFlags shaderStages = default; + + public this(VkIndirectExecutionSetInfoTypeEXT type, VkShaderStageFlags shaderStages) : this() + { + this.type = type; + this.shaderStages = shaderStages; + } +} + +[CRepr, Union] struct VkIndirectCommandsTokenDataEXT : this() +{ + public VkIndirectCommandsPushConstantTokenEXT* pPushConstant = null; + public VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer = null; + public VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer = null; + public VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet = null; + + public this(VkIndirectCommandsPushConstantTokenEXT* pPushConstant, VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer, VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer, VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet) : this() + { + this.pPushConstant = pPushConstant; + this.pVertexBuffer = pVertexBuffer; + this.pIndexBuffer = pIndexBuffer; + this.pExecutionSet = pExecutionSet; + } +} + +struct VkIndirectCommandsLayoutEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} +struct VkIndirectExecutionSetEXT : uint64 +{ + public const VkObjectType ObjectType = .VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; + public static operator Self(decltype(null)) => VK_NULL_HANDLE; +} + +[AllowDuplicates] enum VkIndirectCommandsTokenTypeEXT : int32 +{ + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001, + [NoShow] VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004, + // pretty names + ExecutionSetEXT = 0, + PushConstantEXT = 1, + SequenceIndexEXT = 2, + IndexBufferEXT = 3, + VertexBufferEXT = 4, + DrawIndexedEXT = 5, + DrawEXT = 6, + DrawIndexedCountEXT = 7, + DrawCountEXT = 8, + DispatchEXT = 9, + DrawMeshTasksNvEXT = 1000202002, + DrawMeshTasksCountNvEXT = 1000202003, + DrawMeshTasksEXT = 1000328000, + DrawMeshTasksCountEXT = 1000328001, + TraceRays2EXT = 1000386004, +} + +[AllowDuplicates] enum VkIndirectExecutionSetInfoTypeEXT : int32 +{ + [NoShow] VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0, + [NoShow] VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1, + // pretty names + PipelinesEXT = 0, + ShaderObjectsEXT = 1, +} + +typealias VkIndirectCommandsLayoutUsageFlagsEXT = VkIndirectCommandsLayoutUsageFlagBitsEXT; + +[AllowDuplicates] enum VkIndirectCommandsLayoutUsageFlagBitsEXT : int32 +{ + [NoShow] VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 1 << 0, + [NoShow] VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 1 << 1, + // pretty names + ExplicitPreprocessEXT = 1 << 0, + UnorderedSequencesEXT = 1 << 1, +} + +typealias VkIndirectCommandsInputModeFlagsEXT = VkIndirectCommandsInputModeFlagBitsEXT; + +[AllowDuplicates] enum VkIndirectCommandsInputModeFlagBitsEXT : int32 +{ + [NoShow] VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 1 << 0, + [NoShow] VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 1 << 1, + // pretty names + VulkanIndexBufferEXT = 1 << 0, + DxgiIndexBufferEXT = 1 << 1, +} + +[CRepr] struct VkIndirectExecutionSetShaderLayoutInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 setLayoutCount = 0; + public VkDescriptorSetLayout* pSetLayouts = null; + public Span setLayouts + { + get { return .(pSetLayouts, (.)setLayoutCount); } + set mut { pSetLayouts = value.Ptr; setLayoutCount = (.)value.Length; } + } + + public this(void* pNext = null, Span setLayouts = default) : this() + { + this.pNext = pNext; + this.setLayouts = setLayouts; + } +} + +[CRepr] struct VkGeneratedCommandsPipelineInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPipeline pipeline = null; + + public this(void* pNext, VkPipeline pipeline) : this() + { + this.pNext = pNext; + this.pipeline = pipeline; + } +} + +[CRepr] struct VkGeneratedCommandsShaderInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 shaderCount = 0; + public VkShaderEXT* pShaders = null; + public Span shaders + { + get { return .(pShaders, (.)shaderCount); } + set mut { pShaders = value.Ptr; shaderCount = (.)value.Length; } + } + + public this(void* pNext, Span shaders) : this() + { + this.pNext = pNext; + this.shaders = shaders; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, out VkMemoryRequirements2 pMemoryRequirements); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectCommandsLayoutEXT pIndirectCommandsLayout); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkIndirectExecutionSetEXT pIndirectExecutionSet); +[CallingConvention(VKAPI_PTR)] function void PFN_vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet = null, VkAllocationCallbacks* pAllocator = null); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32 executionSetWriteCount, VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); +[CallingConvention(VKAPI_PTR)] function void PFN_vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32 executionSetWriteCount, VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); + +[CRepr] struct VkWriteIndirectExecutionSetShaderEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 index = 0; + public VkShaderEXT shader = null; + + public this(void* pNext, uint32 index, VkShaderEXT shader) : this() + { + this.pNext = pNext; + this.index = index; + this.shader = shader; + } +} + +static { public const let VK_KHR_MAINTENANCE_8_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_8_EXTENSION_NAME = "VK_KHR_maintenance8"; } + +[CRepr] struct VkMemoryBarrierAccessFlags3KHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkAccessFlags3KHR srcAccessMask3 = default; + public VkAccessFlags3KHR dstAccessMask3 = default; + + public this(void* pNext = null, VkAccessFlags3KHR srcAccessMask3 = default, VkAccessFlags3KHR dstAccessMask3 = default) : this() + { + this.pNext = pNext; + this.srcAccessMask3 = srcAccessMask3; + this.dstAccessMask3 = dstAccessMask3; + } +} + +[AllowDuplicates] enum VkAccessFlagBits3KHR : int32 +{ + [NoShow] VK_ACCESS_3_NONE_KHR = 0, + // pretty names + VkAccess3_NoneKHR = 0, +} + +typealias VkAccessFlags3KHR = VkFlags64; + +[CRepr] struct VkPhysicalDeviceMaintenance8FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance8 = false; + + public this(void* pNext, VkBool32 maintenance8) : this() + { + this.pNext = pNext; + this.maintenance8 = maintenance8; + } +} + +static { public const let VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME = "VK_MESA_image_alignment_control"; } + +[CRepr] struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 imageAlignmentControl = false; + + public this(void* pNext, VkBool32 imageAlignmentControl) : this() + { + this.pNext = pNext; + this.imageAlignmentControl = imageAlignmentControl; + } +} + +[CRepr] struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 supportedImageAlignmentMask = 0; +} + +[CRepr] struct VkImageAlignmentControlCreateInfoMESA : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maximumRequestedAlignment = 0; + + public this(void* pNext, uint32 maximumRequestedAlignment) : this() + { + this.pNext = pNext; + this.maximumRequestedAlignment = maximumRequestedAlignment; + } +} + +static { public const let VK_KHR_SHADER_FMA_SPEC_VERSION = 1; } +static { public const let VK_KHR_SHADER_FMA_EXTENSION_NAME = "VK_KHR_shader_fma"; } + +[CRepr] struct VkPhysicalDeviceShaderFmaFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderFmaFloat16 = false; + public VkBool32 shaderFmaFloat32 = false; + public VkBool32 shaderFmaFloat64 = false; + + public this(void* pNext, VkBool32 shaderFmaFloat16, VkBool32 shaderFmaFloat32, VkBool32 shaderFmaFloat64) : this() + { + this.pNext = pNext; + this.shaderFmaFloat16 = shaderFmaFloat16; + this.shaderFmaFloat32 = shaderFmaFloat32; + this.shaderFmaFloat64 = shaderFmaFloat64; + } +} + +static { public const let VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION = 1; } +static { public const let VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME = "VK_EXT_ray_tracing_invocation_reorder"; } + +[AllowDuplicates] enum VkRayTracingInvocationReorderModeEXT : int32 +{ + [NoShow] VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT = 0, + [NoShow] VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT = 1, + [NoShow] VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, + [NoShow] VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT, + // pretty names + NoneEXT = 0, + ReorderEXT = 1, + NoneNV = NoneEXT, + ReorderNV = ReorderEXT, +} + +[CRepr] struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = default; + public uint32 maxShaderBindingTableRecordIndex = 0; +} + +[CRepr] struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rayTracingInvocationReorder = false; + + public this(void* pNext, VkBool32 rayTracingInvocationReorder) : this() + { + this.pNext = pNext; + this.rayTracingInvocationReorder = rayTracingInvocationReorder; + } +} + +// codespell:ignore blok +static { public const let VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION = 1; } +static { public const let VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME = "VK_EXT_depth_clamp_control"; } + +[CRepr] struct VkPhysicalDeviceDepthClampControlFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 depthClampControl = false; + + public this(void* pNext, VkBool32 depthClampControl) : this() + { + this.pNext = pNext; + this.depthClampControl = depthClampControl; + } +} + +[CRepr] struct VkPipelineViewportDepthClampControlCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDepthClampModeEXT depthClampMode = default; + public VkDepthClampRangeEXT* pDepthClampRange = null; + + public this(void* pNext, VkDepthClampModeEXT depthClampMode, VkDepthClampRangeEXT* pDepthClampRange = null) : this() + { + this.pNext = pNext; + this.depthClampMode = depthClampMode; + this.pDepthClampRange = pDepthClampRange; + } +} + +[AllowDuplicates] enum VkDepthClampModeEXT : int32 +{ + [NoShow] VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0, + [NoShow] VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1, + // pretty names + ViewportRangeEXT = 0, + UserDefinedRangeEXT = 1, +} + +[CRepr] struct VkDepthClampRangeEXT : this() +{ + public float minDepthClamp = 0; + public float maxDepthClamp = 0; + + public this(float minDepthClamp, float maxDepthClamp) : this() + { + this.minDepthClamp = minDepthClamp; + this.maxDepthClamp = maxDepthClamp; + } +} + +static { public const let VK_KHR_MAINTENANCE_9_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_9_EXTENSION_NAME = "VK_KHR_maintenance9"; } + +[CRepr] struct VkPhysicalDeviceMaintenance9FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance9 = false; + + public this(void* pNext, VkBool32 maintenance9) : this() + { + this.pNext = pNext; + this.maintenance9 = maintenance9; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance9PropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 image2DViewOf3DSparse = false; + public VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue = default; +} + +[CRepr] struct VkQueueFamilyOwnershipTransferPropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 optimalImageTransferToQueueFamilies = 0; +} + +[AllowDuplicates] enum VkDefaultVertexAttributeValueKHR : int32 +{ + [NoShow] VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR = 0, + [NoShow] VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR = 1, + // pretty names + ZeroZeroZeroZeroKHR = 0, + ZeroZeroZeroOneKHR = 1, +} + +// Individual APIs with dependencies on specific versions/extensions should get their own require blocks with depends= attribute set appropriately +static { public const let VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME = "VK_KHR_video_maintenance2"; } + +[CRepr] struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 videoMaintenance2 = false; + + public this(void* pNext, VkBool32 videoMaintenance2) : this() + { + this.pNext = pNext; + this.videoMaintenance2 = videoMaintenance2; + } +} + +[CRepr] struct VkVideoDecodeH264InlineSessionParametersInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH264SequenceParameterSet* pStdSPS = null; + public StdVideoH264PictureParameterSet* pStdPPS = null; + + public this(void* pNext = null, StdVideoH264SequenceParameterSet* pStdSPS = null, StdVideoH264PictureParameterSet* pStdPPS = null) : this() + { + this.pNext = pNext; + this.pStdSPS = pStdSPS; + this.pStdPPS = pStdPPS; + } +} + +[CRepr] struct VkVideoDecodeH265InlineSessionParametersInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoH265VideoParameterSet* pStdVPS = null; + public StdVideoH265SequenceParameterSet* pStdSPS = null; + public StdVideoH265PictureParameterSet* pStdPPS = null; + + public this(void* pNext = null, StdVideoH265VideoParameterSet* pStdVPS = null, StdVideoH265SequenceParameterSet* pStdSPS = null, StdVideoH265PictureParameterSet* pStdPPS = null) : this() + { + this.pNext = pNext; + this.pStdVPS = pStdVPS; + this.pStdSPS = pStdSPS; + this.pStdPPS = pStdPPS; + } +} + +[CRepr] struct VkVideoDecodeAV1InlineSessionParametersInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public StdVideoAV1SequenceHeader* pStdSequenceHeader = null; + + public this(void* pNext = null, StdVideoAV1SequenceHeader* pStdSequenceHeader = null) : this() + { + this.pNext = pNext; + this.pStdSequenceHeader = pStdSequenceHeader; + } +} + +static { public const let VK_OHOS_SURFACE_SPEC_VERSION = 1; } +static { public const let VK_OHOS_SURFACE_EXTENSION_NAME = "VK_OHOS_surface"; } + +typealias VkSurfaceCreateFlagsOHOS = VkFlags; + +[CRepr] struct VkSurfaceCreateInfoOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSurfaceCreateFlagsOHOS flags = default; + public OHNativeWindow* window = null; + + public this(void* pNext, VkSurfaceCreateFlagsOHOS flags, OHNativeWindow* window) : this() + { + this.pNext = pNext; + this.flags = flags; + this.window = window; + } +} + +struct OHNativeWindow; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkCreateSurfaceOHOS(VkInstance instance, VkSurfaceCreateInfoOHOS* pCreateInfo, VkAllocationCallbacks* pAllocator, out VkSurfaceKHR pSurface); + +static { public const let VK_OHOS_NATIVE_BUFFER_SPEC_VERSION = 1; } +static { public const let VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME = "VK_OHOS_native_buffer"; } + +[AllowDuplicates] enum VkSwapchainImageUsageFlagBitsOHOS : int32 +{ + [NoShow] VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS = 1 << 0, + // pretty names + SharedOHOS = 1 << 0, +} + +[CRepr] struct VkNativeBufferOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public OHBufferHandle* handle = null; + + public this(void* pNext, OHBufferHandle* handle) : this() + { + this.pNext = pNext; + this.handle = handle; + } +} + +[CRepr] struct VkSwapchainImageCreateInfoOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkSwapchainImageUsageFlagsOHOS usage = default; + + public this(void* pNext, VkSwapchainImageUsageFlagsOHOS usage) : this() + { + this.pNext = pNext; + this.usage = usage; + } +} + +[CRepr] struct VkPhysicalDevicePresentationPropertiesOHOS : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 sharedImage = false; +} + +struct OHBufferHandle; +typealias VkSwapchainImageUsageFlagsOHOS = VkSwapchainImageUsageFlagBitsOHOS; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetSwapchainGrallocUsageOHOS(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, out uint64 grallocUsage); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkAcquireImageOHOS(VkDevice device, VkImage image, int32 nativeFenceFd, VkSemaphore semaphore = null, VkFence fence = null); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkQueueSignalReleaseImageOHOS(VkQueue queue, uint32 waitSemaphoreCount, VkSemaphore* pWaitSemaphores, VkImage image, out int32 pNativeFenceFd); + +static { public const let VK_HUAWEI_HDR_VIVID_SPEC_VERSION = 1; } +static { public const let VK_HUAWEI_HDR_VIVID_EXTENSION_NAME = "VK_HUAWEI_hdr_vivid"; } + +[CRepr] struct VkPhysicalDeviceHdrVividFeaturesHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 hdrVivid = false; + + public this(void* pNext, VkBool32 hdrVivid) : this() + { + this.pNext = pNext; + this.hdrVivid = hdrVivid; + } +} + +[CRepr] struct VkHdrVividDynamicMetadataHUAWEI : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; + public VkStructureType sType = SType; + public void* pNext = null; + public c_size dynamicMetadataSize = 0; // Specified in bytes + public void* pDynamicMetadata = null; // Binary code of size dynamicMetadataSize + public Span dynamicMetadata + { + get { return .(pDynamicMetadata, (.)dynamicMetadataSize); } + set mut { pDynamicMetadata = value.Ptr; dynamicMetadataSize = (.)value.Length; } + } + + public this(void* pNext, Span dynamicMetadata) : this() + { + this.pNext = pNext; + this.dynamicMetadata = dynamicMetadata; + } +} + +static { public const let VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION = 1; } +static { public const let VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME = "VK_NV_cooperative_matrix2"; } + +[CRepr] struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 MGranularity = 0; + public uint32 NGranularity = 0; + public uint32 KGranularity = 0; + public VkComponentTypeKHR AType = default; + public VkComponentTypeKHR BType = default; + public VkComponentTypeKHR CType = default; + public VkComponentTypeKHR ResultType = default; + public VkBool32 saturatingAccumulation = false; + public VkScopeKHR @scope = default; + public uint32 workgroupInvocations = 0; +} + +[CRepr] struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 cooperativeMatrixWorkgroupScope = false; + public VkBool32 cooperativeMatrixFlexibleDimensions = false; + public VkBool32 cooperativeMatrixReductions = false; + public VkBool32 cooperativeMatrixConversions = false; + public VkBool32 cooperativeMatrixPerElementOperations = false; + public VkBool32 cooperativeMatrixTensorAddressing = false; + public VkBool32 cooperativeMatrixBlockLoads = false; + + public this(void* pNext, VkBool32 cooperativeMatrixWorkgroupScope, VkBool32 cooperativeMatrixFlexibleDimensions, VkBool32 cooperativeMatrixReductions, VkBool32 cooperativeMatrixConversions, VkBool32 cooperativeMatrixPerElementOperations, VkBool32 cooperativeMatrixTensorAddressing, VkBool32 cooperativeMatrixBlockLoads) : this() + { + this.pNext = pNext; + this.cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope; + this.cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions; + this.cooperativeMatrixReductions = cooperativeMatrixReductions; + this.cooperativeMatrixConversions = cooperativeMatrixConversions; + this.cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations; + this.cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing; + this.cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads; + } +} + +[CRepr] struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = 0; + public uint32 cooperativeMatrixFlexibleDimensionsMaxDimension = 0; + public uint32 cooperativeMatrixWorkgroupScopeReservedSharedMemory = 0; +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, out uint32 pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties = null); + +static { public const let VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION = 1; } +static { public const let VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME = "VK_ARM_pipeline_opacity_micromap"; } + +[CRepr] struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineOpacityMicromap = false; + + public this(void* pNext, VkBool32 pipelineOpacityMicromap) : this() + { + this.pNext = pNext; + this.pipelineOpacityMicromap = pipelineOpacityMicromap; + } +} + +static { public const let VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION = 1; } +static { public const let VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME = "VK_EXT_external_memory_metal"; } + +[CRepr] struct VkImportMemoryMetalHandleInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + public void* handle = null; + + public this(void* pNext = null, VkExternalMemoryHandleTypeFlagBits handleType = default, void* handle = null) : this() + { + this.pNext = pNext; + this.handleType = handleType; + this.handle = handle; + } +} + +[CRepr] struct VkMemoryMetalHandlePropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 memoryTypeBits = 0; +} + +[CRepr] struct VkMemoryGetMetalHandleInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceMemory memory = null; + public VkExternalMemoryHandleTypeFlagBits handleType = default; + + public this(void* pNext, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBits handleType) : this() + { + this.pNext = pNext; + this.memory = memory; + this.handleType = handleType; + } +} + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryMetalHandleEXT(VkDevice device, VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, out void* pHandle); +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, void* pHandle, out VkMemoryMetalHandlePropertiesEXT pMemoryMetalHandleProperties); + +static { public const let VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION = 1; } +static { public const let VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME = "VK_KHR_depth_clamp_zero_one"; } + +[CRepr] struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 depthClampZeroOne = false; + + public this(void* pNext, VkBool32 depthClampZeroOne) : this() + { + this.pNext = pNext; + this.depthClampZeroOne = depthClampZeroOne; + } +} + +static { public const let VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION = 1; } +static { public const let VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME = "VK_ARM_performance_counters_by_region"; } + +[CRepr] struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 performanceCountersByRegion = false; + + public this(void* pNext, VkBool32 performanceCountersByRegion) : this() + { + this.pNext = pNext; + this.performanceCountersByRegion = performanceCountersByRegion; + } +} + +[CRepr] struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxPerRegionPerformanceCounters = 0; + public VkExtent2D performanceCounterRegionSize = default; + public uint32 rowStrideAlignment = 0; + public uint32 regionAlignment = 0; + public VkBool32 identityTransformOrder = false; +} + +[CRepr] struct VkPerformanceCounterARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 counterID = 0; +} + +[CRepr] struct VkPerformanceCounterDescriptionARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPerformanceCounterDescriptionFlagsARM flags = default; + public char8[VK_MAX_DESCRIPTION_SIZE] name = .(); +} + +[CRepr] struct VkRenderPassPerformanceCountersByRegionBeginInfoARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM; + public VkStructureType sType = SType; + public void* pNext = null; // Pointer to next structure + public uint32 counterAddressCount = 0; + public VkDeviceAddress* pCounterAddresses = null; + public VkBool32 serializeRegions = false; + public uint32 counterIndexCount = 0; + public uint32* pCounterIndices = null; + + public this(void* pNext, uint32 counterAddressCount, VkDeviceAddress* pCounterAddresses, VkBool32 serializeRegions, uint32 counterIndexCount, uint32* pCounterIndices) : this() + { + this.pNext = pNext; + this.counterAddressCount = counterAddressCount; + this.pCounterAddresses = pCounterAddresses; + this.serializeRegions = serializeRegions; + this.counterIndexCount = counterIndexCount; + this.pCounterIndices = pCounterIndices; + } +} + +typealias VkPerformanceCounterDescriptionFlagsARM = VkFlags; + +[CallingConvention(VKAPI_PTR)] function VkResult PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32 queueFamilyIndex, out uint32 pCounterCount, VkPerformanceCounterARM* pCounters = null, VkPerformanceCounterDescriptionARM* pCounterDescriptions = null); + +static { public const let VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION = 1; } +static { public const let VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME = "VK_EXT_vertex_attribute_robustness"; } + +[CRepr] struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 vertexAttributeRobustness = false; + + public this(void* pNext, VkBool32 vertexAttributeRobustness) : this() + { + this.pNext = pNext; + this.vertexAttributeRobustness = vertexAttributeRobustness; + } +} + +static { public const let VK_ARM_FORMAT_PACK_SPEC_VERSION = 1; } +static { public const let VK_ARM_FORMAT_PACK_EXTENSION_NAME = "VK_ARM_format_pack"; } + +[CRepr] struct VkPhysicalDeviceFormatPackFeaturesARM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 formatPack = false; + + public this(void* pNext, VkBool32 formatPack) : this() + { + this.pNext = pNext; + this.formatPack = formatPack; + } +} + +static { public const let VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION = 1; } +static { public const let VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME = "VK_VALVE_fragment_density_map_layered"; } + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentDensityMapLayered = false; + + public this(void* pNext, VkBool32 fragmentDensityMapLayered) : this() + { + this.pNext = pNext; + this.fragmentDensityMapLayered = fragmentDensityMapLayered; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxFragmentDensityMapLayers = 0; +} + +[CRepr] struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 maxFragmentDensityMapLayers = 0; + + public this(void* pNext, uint32 maxFragmentDensityMapLayers) : this() + { + this.pNext = pNext; + this.maxFragmentDensityMapLayers = maxFragmentDensityMapLayers; + } +} + +static { public const let VK_KHR_ROBUSTNESS_2_SPEC_VERSION = 1; } +static { public const let VK_KHR_ROBUSTNESS_2_EXTENSION_NAME = "VK_KHR_robustness2"; } + +[CRepr] struct VkPhysicalDeviceRobustness2FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 robustBufferAccess2 = false; + public VkBool32 robustImageAccess2 = false; + public VkBool32 nullDescriptor = false; + + public this(void* pNext, VkBool32 robustBufferAccess2, VkBool32 robustImageAccess2, VkBool32 nullDescriptor) : this() + { + this.pNext = pNext; + this.robustBufferAccess2 = robustBufferAccess2; + this.robustImageAccess2 = robustImageAccess2; + this.nullDescriptor = nullDescriptor; + } +} + +[CRepr] struct VkPhysicalDeviceRobustness2PropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkDeviceSize robustStorageBufferAccessSizeAlignment = default; + public VkDeviceSize robustUniformBufferAccessSizeAlignment = default; +} + +static { public const let VK_NV_PRESENT_METERING_SPEC_VERSION = 1; } +static { public const let VK_NV_PRESENT_METERING_EXTENSION_NAME = "VK_NV_present_metering"; } + +[CRepr] struct VkSetPresentConfigNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 numFramesPerBatch = 0; + public uint32 presentConfigFeedback = 0; + + public this(void* pNext, uint32 numFramesPerBatch, uint32 presentConfigFeedback) : this() + { + this.pNext = pNext; + this.numFramesPerBatch = numFramesPerBatch; + this.presentConfigFeedback = presentConfigFeedback; + } +} + +[CRepr] struct VkPhysicalDevicePresentMeteringFeaturesNV : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentMetering = false; + + public this(void* pNext, VkBool32 presentMetering) : this() + { + this.pNext = pNext; + this.presentMetering = presentMetering; + } +} + +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION = 1; } +static { public const let VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME = "VK_EXT_fragment_density_map_offset"; } + +typealias VkRenderingEndInfoEXT = VkRenderingEndInfoKHR; + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 fragmentDensityMapOffset = false; + + public this(void* pNext, VkBool32 fragmentDensityMapOffset) : this() + { + this.pNext = pNext; + this.fragmentDensityMapOffset = fragmentDensityMapOffset; + } +} + +[CRepr] struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkExtent2D fragmentDensityOffsetGranularity = default; +} + +[CRepr] struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public uint32 fragmentDensityOffsetCount = 0; + public VkOffset2D* pFragmentDensityOffsets = null; + public Span fragmentDensityOffsets + { + get { return .(pFragmentDensityOffsets, (.)fragmentDensityOffsetCount); } + set mut { pFragmentDensityOffsets = value.Ptr; fragmentDensityOffsetCount = (.)value.Length; } + } + + public this(void* pNext = null, Span fragmentDensityOffsets = default) : this() + { + this.pNext = pNext; + this.fragmentDensityOffsets = fragmentDensityOffsets; + } +} + +typealias PFN_vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2KHR; + +static { public const let VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION = 1; } +static { public const let VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME = "VK_EXT_zero_initialize_device_memory"; } + +[CRepr] struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 zeroInitializeDeviceMemory = false; + + public this(void* pNext, VkBool32 zeroInitializeDeviceMemory) : this() + { + this.pNext = pNext; + this.zeroInitializeDeviceMemory = zeroInitializeDeviceMemory; + } +} + +static { public const let VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION = 1; } +static { public const let VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME = "VK_KHR_present_mode_fifo_latest_ready"; } + +[CRepr] struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 presentModeFifoLatestReady = false; + + public this(void* pNext, VkBool32 presentModeFifoLatestReady) : this() + { + this.pNext = pNext; + this.presentModeFifoLatestReady = presentModeFifoLatestReady; + } +} + +static { public const let VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME = "VK_EXT_shader_64bit_indexing"; } + +[CRepr] struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shader64BitIndexing = false; + + public this(void* pNext, VkBool32 shader64BitIndexing) : this() + { + this.pNext = pNext; + this.shader64BitIndexing = shader64BitIndexing; + } +} + +static { public const let VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION = 1; } +static { public const let VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME = "VK_EXT_custom_resolve"; } + +[CRepr] struct VkPhysicalDeviceCustomResolveFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 customResolve = false; + + public this(void* pNext, VkBool32 customResolve) : this() + { + this.pNext = pNext; + this.customResolve = customResolve; + } +} + +[CRepr] struct VkBeginCustomResolveInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CRepr] struct VkCustomResolveCreateInfoEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 customResolve = false; + public uint32 colorAttachmentCount = 0; + public VkFormat* pColorAttachmentFormats = null; + public Span colorAttachmentFormats + { + get { return .(pColorAttachmentFormats, (.)colorAttachmentCount); } + set mut { pColorAttachmentFormats = value.Ptr; colorAttachmentCount = (.)value.Length; } + } + public VkFormat depthAttachmentFormat = default; + public VkFormat stencilAttachmentFormat = default; + + public this(void* pNext, VkBool32 customResolve, Span colorAttachmentFormats, VkFormat depthAttachmentFormat, VkFormat stencilAttachmentFormat) : this() + { + this.pNext = pNext; + this.customResolve = customResolve; + this.colorAttachmentFormats = colorAttachmentFormats; + this.depthAttachmentFormat = depthAttachmentFormat; + this.stencilAttachmentFormat = stencilAttachmentFormat; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo = null); + +static { public const let VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION = 1; } +static { public const let VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME = "VK_QCOM_data_graph_model"; } +static { public const uint32 VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM = 3; } + +[AllowDuplicates] enum VkDataGraphModelCacheTypeQCOM : int32 +{ + [NoShow] VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM = 0, + // pretty names + GenericBinaryQCOM = 0, +} + +[CRepr] struct VkPipelineCacheHeaderVersionDataGraphQCOM : this() +{ + + public uint32 headerSize = 0; + public VkPipelineCacheHeaderVersion headerVersion = default; + public VkDataGraphModelCacheTypeQCOM cacheType = default; + public uint32 cacheVersion = 0; + public uint32[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM] toolchainVersion = .(); + + public this(uint32 headerSize, VkPipelineCacheHeaderVersion headerVersion, VkDataGraphModelCacheTypeQCOM cacheType, uint32 cacheVersion, uint32[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM] toolchainVersion) : this() + { + this.headerSize = headerSize; + this.headerVersion = headerVersion; + this.cacheType = cacheType; + this.cacheVersion = cacheVersion; + this.toolchainVersion = toolchainVersion; + } +} + +[CRepr] struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkPhysicalDeviceDataGraphOperationSupportARM* pOperation = null; + + public this(void* pNext, VkPhysicalDeviceDataGraphOperationSupportARM* pOperation) : this() + { + this.pNext = pNext; + this.pOperation = pOperation; + } +} + +[CRepr] struct VkPhysicalDeviceDataGraphModelFeaturesQCOM : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 dataGraphModel = false; + + public this(void* pNext, VkBool32 dataGraphModel) : this() + { + this.pNext = pNext; + this.dataGraphModel = dataGraphModel; + } +} + +static { public const let VK_KHR_MAINTENANCE_10_SPEC_VERSION = 1; } +static { public const let VK_KHR_MAINTENANCE_10_EXTENSION_NAME = "VK_KHR_maintenance10"; } + +[CRepr] struct VkPhysicalDeviceMaintenance10FeaturesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 maintenance10 = false; + + public this(void* pNext, VkBool32 maintenance10) : this() + { + this.pNext = pNext; + this.maintenance10 = maintenance10; + } +} + +[CRepr] struct VkPhysicalDeviceMaintenance10PropertiesKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 rgba4OpaqueBlackSwizzled = false; + public VkBool32 resolveSrgbFormatAppliesTransferFunction = false; + public VkBool32 resolveSrgbFormatSupportsTransferFunctionControl = false; +} + +[CRepr] struct VkRenderingEndInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + + public this(void* pNext = null) : this() + { + this.pNext = pNext; + } +} + +[CallingConvention(VKAPI_PTR)] function void PFN_vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, VkRenderingEndInfoKHR* pRenderingEndInfo = null); + +[CRepr] struct VkRenderingAttachmentFlagsInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkRenderingAttachmentFlagsKHR flags = default; + + public this(void* pNext = null, VkRenderingAttachmentFlagsKHR flags = default) : this() + { + this.pNext = pNext; + this.flags = flags; + } +} + +typealias VkRenderingAttachmentFlagsKHR = VkRenderingAttachmentFlagBitsKHR; + +[AllowDuplicates] enum VkRenderingAttachmentFlagBitsKHR : int32 +{ + [NoShow] VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR = 1 << 0, + [NoShow] VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 1 << 1, + [NoShow] VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 1 << 2, + // pretty names + InputAttachmentFeedbackKHR = 1 << 0, + ResolveSkipTransferFunctionKHR = 1 << 1, + ResolveEnableTransferFunctionKHR = 1 << 2, +} + +[CRepr] struct VkResolveImageModeInfoKHR : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR; + public VkStructureType sType = SType; + public void* pNext = null; + public VkResolveImageFlagsKHR flags = default; + public VkResolveModeFlagBits resolveMode = default; + public VkResolveModeFlagBits stencilResolveMode = default; + + public this(void* pNext = null, VkResolveImageFlagsKHR flags = default, VkResolveModeFlagBits resolveMode = default, VkResolveModeFlagBits stencilResolveMode = default) : this() + { + this.pNext = pNext; + this.flags = flags; + this.resolveMode = resolveMode; + this.stencilResolveMode = stencilResolveMode; + } +} + +typealias VkResolveImageFlagsKHR = VkResolveImageFlagBitsKHR; + +[AllowDuplicates] enum VkResolveImageFlagBitsKHR : int32 +{ + [NoShow] VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 1 << 0, + [NoShow] VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 1 << 1, + // pretty names + SkipTransferFunctionKHR = 1 << 0, + EnableTransferFunctionKHR = 1 << 1, +} + +static { public const let VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION = 1; } +static { public const let VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME = "VK_SEC_pipeline_cache_incremental_mode"; } + +[CRepr] struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 pipelineCacheIncrementalMode = false; + + public this(void* pNext, VkBool32 pipelineCacheIncrementalMode) : this() + { + this.pNext = pNext; + this.pipelineCacheIncrementalMode = pipelineCacheIncrementalMode; + } +} + +static { public const let VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION = 1; } +static { public const let VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME = "VK_EXT_shader_uniform_buffer_unsized_array"; } + +[CRepr] struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT : this() +{ + public const VkStructureType SType = .VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT; + public VkStructureType sType = SType; + public void* pNext = null; + public VkBool32 shaderUniformBufferUnsizedArray = false; + + public this(void* pNext, VkBool32 shaderUniformBufferUnsizedArray) : this() + { + this.pNext = pNext; + this.shaderUniformBufferUnsizedArray = shaderUniformBufferUnsizedArray; + } +}