Add `vendor:vulkan`

vendor/vulkan/_gen/create_vulkan_odin_wrapper.py

@@ -0,0 +1,608 @@
+import re
+import urllib.request as req
+from tokenize import tokenize
+from io import BytesIO
+import string
+import os.path
+import math
+
+file_and_urls = [
+    ("vk_platform.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_platform.h',  True),
+    ("vulkan_core.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h',  False),
+    ("vk_layer.h",     'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_layer.h',     False),
+    ("vk_icd.h",       'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_icd.h',       False),
+    ("vulkan_win32.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_win32.h', False),
+    ("vulkan_metal.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_metal.h', False),
+    ("vulkan_macos.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_macos.h', False),
+    ("vulkan_ios.h",   'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_ios.h',   False),
+]
+
+for file, url, _ in file_and_urls:
+    if not os.path.isfile(file):
+        with open(file, 'w', encoding='utf-8') as f:
+            f.write(req.urlopen(url).read().decode('utf-8'))
+
+src = ""
+for file, _, skip in file_and_urls:
+    if skip: continue
+    with open(file, 'r', encoding='utf-8') as f:
+        src += f.read()
+
+
+def no_vk(t):
+    t = t.replace('Vk', '')
+    t = t.replace('PFN_vk_icd', 'Procicd')
+    t = t.replace('PFN_vk', 'Proc')
+    t = t.replace('PFN_', 'Proc')
+    t = t.replace('PFN_', 'Proc')
+    t = t.replace('VK_', '')
+    return t
+
+def convert_type(t):
+    table = {
+        "Bool32":      'b32',
+        "float":       'f32',
+        "double":      'f64',
+        "uint32_t":    'u32',
+        "uint64_t":    'u64',
+        "size_t":      'int',
+        'int32_t':     'i32',
+        'int64_t':     'i64',
+        'int':         'c.int',
+        'uint8_t':     'u8',
+        "uint16_t":    'u16',
+        "char":        "byte",
+        "void":        "void",
+        "void*":       "rawptr",
+        "void *":      "rawptr",
+        "char*":       'cstring',
+        "const uint32_t* const*": "^^u32",
+        "const void*": 'rawptr',
+        "const char*": 'cstring',
+        "const char* const*": 'cstring_array',
+        "const ObjectTableEntryNVX* const*": "^^ObjectTableEntryNVX",
+        "const void* const *": "^rawptr",
+        "const AccelerationStructureGeometryKHR* const*": "^^AccelerationStructureGeometryKHR",
+        "const AccelerationStructureBuildRangeInfoKHR* const*": "^^AccelerationStructureBuildRangeInfoKHR",
+        "struct BaseOutStructure": "BaseOutStructure",
+        "struct BaseInStructure":  "BaseInStructure",
+        'v': '',
+     }
+
+    if t in table.keys():
+        return table[t]
+
+    if t == "":
+        return t
+    elif t.endswith("*"):
+        if t.startswith("const"):
+            ttype = t[6:len(t)-1]
+            return "^{}".format(convert_type(ttype))
+        else:
+            ttype = t[:len(t)-1]
+            return "^{}".format(convert_type(ttype))
+    elif t[0].isupper():
+        return t
+
+    return t
+
+def parse_array(n, t):
+    name, length = n.split('[', 1)
+    length = no_vk(length[:-1])
+    type_ = "[{}]{}".format(length, do_type(t))
+    return name, type_
+
+def remove_prefix(text, prefix):
+    if text.startswith(prefix):
+        return text[len(prefix):]
+    return text
+def remove_suffix(text, suffix):
+    if text.endswith(suffix):
+        return text[:-len(suffix)]
+    return text
+
+
+def to_snake_case(name):
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+ext_suffixes = ["KHR", "EXT", "AMD", "NV", "NVX", "GOOGLE"]
+ext_suffixes_title = [ext.title() for ext in ext_suffixes]
+
+
+def fix_arg(arg):
+    name = arg
+
+    # Remove useless pointer identifier in field name
+    for p in ('s_', 'p_', 'pp_', 'pfn_'):
+        if name.startswith(p):
+            name = name[len(p)::]
+    name = name.replace("__", "_")
+
+    return name
+
+
+def fix_ext_suffix(name):
+    for ext in ext_suffixes_title:
+        if name.endswith(ext):
+            start = name[:-len(ext)]
+            end = name[-len(ext):].upper()
+            return start+end
+    return name
+
+def to_int(x):
+    if x.startswith('0x'):
+        return int(x, 16)
+    return int(x)
+
+def is_int(x):
+    try:
+        int(x)
+        return True
+    except ValueError:
+        return False
+
+def fix_enum_arg(name, is_flag_bit=False):
+    # name = name.title()
+    name = fix_ext_suffix(name)
+    if len(name) > 0 and name[0].isdigit() and not name.startswith("0x") and not is_int(name):
+        if name[1] == "D":
+            name = name[1] + name[0] + (name[2:] if len(name) > 2 else "")
+        else:
+            name = "_"+name
+    if is_flag_bit:
+        name = name.replace("_BIT", "")
+    return name
+
+def do_type(t):
+    return convert_type(no_vk(t)).replace("FlagBits", "Flags")
+
+def parse_handles_def(f):
+    f.write("// Handles types\n")
+    handles = [h for h in re.findall(r"VK_DEFINE_HANDLE\(Vk(\w+)\)", src, re.S)]
+
+    max_len = max(len(h) for h in handles)
+    for h in handles:
+        f.write("{} :: distinct Handle;\n".format(h.ljust(max_len)))
+
+    handles_non_dispatchable = [h for h in re.findall(r"VK_DEFINE_NON_DISPATCHABLE_HANDLE\(Vk(\w+)\)", src, re.S)]
+    max_len = max(len(h) for h in handles_non_dispatchable)
+    for h in handles_non_dispatchable:
+        f.write("{} :: distinct NonDispatchableHandle;\n".format(h.ljust(max_len)))
+
+
+flags_defs = set()
+
+def parse_flags_def(f):
+    names = [n for n in re.findall(r"typedef VkFlags Vk(\w+?);", src)]
+
+    global flags_defs
+    flags_defs = set(names)
+
+
+class FlagError(ValueError):
+    pass
+class IgnoreFlagError(ValueError):
+    pass
+
+def fix_enum_name(name, prefix, suffix, is_flag_bit):
+    name = remove_prefix(name, prefix)
+    if suffix:
+        name = remove_suffix(name, suffix)
+    if name.startswith("0x"):
+        if is_flag_bit:
+            i = int(name, 16)
+            if i == 0:
+                raise IgnoreFlagError(i)
+            v = int(math.log2(i))
+            if 2**v != i:
+                raise FlagError(i)
+            return str(v)
+        return name
+    elif is_flag_bit:
+        ignore = False
+        try:
+            if int(name) == 0:
+                ignore = True
+        except:
+            pass
+        if ignore:
+            raise IgnoreFlagError()
+
+    return fix_enum_arg(name, is_flag_bit)
+
+
+def fix_enum_value(value, prefix, suffix, is_flag_bit):
+    v = no_vk(value)
+    g = tokenize(BytesIO(v.encode('utf-8')).readline)
+    tokens = [val for _, val, _, _, _ in g]
+    assert len(tokens) > 2
+    token = ''.join([t for t in tokens[1:-1] if t])
+    token = fix_enum_name(token, prefix, suffix, is_flag_bit)
+    return token
+
+def parse_constants(f):
+    f.write("// General Constants\n");
+    all_data = re.findall(r"#define VK_(\w+)\s*(.*?)U?\n", src, re.S)
+    allowed_names = (
+        "HEADER_VERSION",
+        "MAX_DRIVER_NAME_SIZE",
+        "MAX_DRIVER_INFO_SIZE",
+    )
+    allowed_data = [nv for nv in all_data if nv[0] in allowed_names]
+    max_len = max(len(name) for name, value in allowed_data)
+    for name, value in allowed_data:
+        f.write("{}{} :: {};\n".format(name, "".rjust(max_len-len(name)), value))
+
+    f.write("\n// Vendor Constants\n");
+    data = re.findall(r"#define VK_((?:"+'|'.join(ext_suffixes)+r")\w+)\s*(.*?)\n", src, re.S)
+    max_len = max(len(name) for name, value in data)
+    for name, value in data:
+        f.write("{}{} :: {};\n".format(name, "".rjust(max_len-len(name)), value))
+    f.write("\n")
+
+
+def parse_enums(f):
+    f.write("// Enums\n")
+
+    data = re.findall(r"typedef enum Vk(\w+) {(.+?)} \w+;", src, re.S)
+
+    generated_flags = set()
+
+    for name, fields in data:
+        enum_name = name
+
+        is_flag_bit = False
+        if "FlagBits" in enum_name:
+            is_flag_bit = True
+            flags_name = enum_name.replace("FlagBits", "Flags")
+            enum_name = enum_name.replace("FlagBits", "Flag")
+            generated_flags.add(flags_name)
+            f.write("{} :: distinct bit_set[{}; Flags];\n".format(flags_name, enum_name))
+
+
+        if is_flag_bit:
+            f.write("{} :: enum Flags {{\n".format(name.replace("FlagBits", "Flag")))
+        else:
+            f.write("{} :: enum c.int {{\n".format(name))
+
+        prefix = to_snake_case(name).upper()
+        suffix = None
+        for ext in ext_suffixes:
+            prefix_new = remove_suffix(prefix, "_"+ext)
+            assert suffix is None
+            if prefix_new != prefix:
+                suffix = "_"+ext
+                prefix = prefix_new
+                break
+
+
+        prefix = prefix.replace("_FLAG_BITS", "")
+        prefix += "_"
+
+        ff = []
+
+        names_and_values = re.findall(r"VK_(\w+?) = (.*?)(?:,|})", fields, re.S)
+
+        groups = []
+        flags = {}
+
+        for name, value in names_and_values:
+            n = fix_enum_name(name, prefix, suffix, is_flag_bit)
+            try:
+                v = fix_enum_value(value, prefix, suffix, is_flag_bit)
+            except FlagError as e:
+                v = int(str(e))
+                groups.append((n, v))
+                continue
+            except IgnoreFlagError as e:
+                groups.append((n, 0))
+                continue
+
+            if n == v:
+                continue
+            try:
+                flags[int(v)] = n
+            except ValueError as e:
+                pass
+
+            if v == "NONE":
+                continue
+
+            ff.append((n, v))
+
+        max_flag_value = max([int(v) for n, v in ff if is_int(v)] + [0])
+        max_group_value = max([int(v) for n, v in groups if is_int(v)] + [0])
+        if max_flag_value < max_group_value:
+            if (1<<max_flag_value)+1 < max_group_value:
+                ff.append(('_MAX', 31))
+                flags[31] = '_MAX'
+                pass
+
+        max_len = max([len(n) for n, v in ff] + [0])
+
+        flag_names = set([n for n, v in ff])
+
+        for n, v in ff:
+            if is_flag_bit and not is_int(v) and v not in flag_names:
+                print("Ignoring", n, "=", v)
+                continue
+            f.write("\t{} = {},".format(n.ljust(max_len), v))
+            if n == "_MAX":
+                f.write(" // Needed for the *_ALL bit set")
+            f.write("\n")
+
+
+
+        f.write("}\n\n")
+
+        for n, v in groups:
+            used_flags = []
+            for i in range(0, 32):
+                if 1<<i & v != 0:
+                    if i in flags:
+                        used_flags.append('.'+flags[i])
+                    else:
+                        used_flags.append('{}({})'.format(enum_name, i))
+            s = "{enum_name}s_{n} :: {enum_name}s{{".format(enum_name=enum_name, n=n);
+            s += ', '.join(used_flags)
+            s += "};\n"
+            f.write(s)
+
+        if len(groups) > 0:
+            f.write("\n\n")
+
+
+    unused_flags = [flag for flag in flags_defs if flag not in generated_flags]
+
+    max_len = max(len(flag) for flag in unused_flags)
+    for flag in unused_flags:
+        flag_name = flag.replace("Flags", "Flag")
+        f.write("{} :: distinct bit_set[{}; Flags];\n".format(flag.ljust(max_len), flag_name))
+        f.write("{} :: enum u32 {{}};\n".format(flag_name.ljust(max_len)))
+
+
+
+def parse_structs(f):
+    data = re.findall(r"typedef (struct|union) Vk(\w+?) {(.+?)} \w+?;", src, re.S)
+
+    for _type, name, fields in data:
+        fields = re.findall(r"\s+(.+?)\s+([_a-zA-Z0-9[\]]+);", fields)
+        f.write("{} :: struct ".format(name))
+        if _type == "union":
+            f.write("#raw_union ")
+        f.write("{\n")
+
+        ffields = []
+        for type_, fname in fields:
+            if '[' in fname:
+                fname, type_ = parse_array(fname, type_)
+            comment = None
+            n = fix_arg(fname)
+            if "Flag_Bits" in type_:
+                comment = " // only single bit set"
+            t = do_type(type_)
+            if t == "Structure_Type" and n == "type":
+                n = "s_type"
+
+            ffields.append(tuple([n, t, comment]))
+
+        max_len = max(len(n) for n, _, _ in ffields)
+
+        for n, t, comment in ffields:
+            k = max_len-len(n)+len(t)
+            f.write("\t{}: {},{}\n".format(n, t.rjust(k), comment or ""))
+
+
+        f.write("}\n\n")
+
+
+    f.write("// Aliases\n")
+    data = re.findall(r"typedef Vk(\w+?) Vk(\w+?);", src, re.S)
+    aliases = []
+    for _type, name in data:
+        if _type == "Flags":
+            continue
+        name = name.replace("FlagBits", "Flag")
+        _type = _type.replace("FlagBits", "Flag")
+        aliases.append((name, _type))
+
+    max_len = max([len(n) for n, _ in aliases] + [0])
+    for n, t in aliases:
+        k = max_len
+        f.write("{} :: {};\n".format(n.ljust(k), t))
+
+
+
+procedure_map = {}
+
+def parse_procedures(f):
+    data = re.findall(r"typedef (\w+\*?) \(\w+ \*(\w+)\)\((.+?)\);", src, re.S)
+
+    ff = []
+
+    for rt, name, fields in data:
+        proc_name = no_vk(name)
+        pf = [(do_type(t), fix_arg(n)) for t, n in re.findall(r"(?:\s*|)(.+?)\s*(\w+)(?:,|$)", fields)]
+        data_fields = ', '.join(["{}: {}".format(n, t) for t, n in pf if t != ""])
+
+        ts = "proc \"c\" ({})".format(data_fields)
+        rt_str = do_type(rt)
+        if rt_str != "void":
+            ts += " -> {}".format(rt_str)
+
+        procedure_map[proc_name] = ts
+        ff.append( (proc_name, ts) )
+
+    max_len = max(len(n) for n, t in ff)
+
+    f.write("// Procedure Types\n\n");
+    f.write("when ODIN_OS == \"windows\" {\n");
+    for n, t in ff:
+        f.write("\t{} :: #type {};\n".format(n.ljust(max_len), t.replace('"c"', '"stdcall"')))
+    f.write("} else {\n");
+    for n, t in ff:
+        f.write("\t{} :: #type {};\n".format(n.ljust(max_len), t))
+    f.write("}\n\n");
+
+def group_functions(f):
+    data = re.findall(r"typedef (\w+\*?) \(\w+ \*(\w+)\)\((.+?)\);", src, re.S)
+    group_map = {"Instance":[], "Device":[], "Loader":[]}
+
+    for rt, vkname, fields in data:
+        fields_types_name = [do_type(t) for t in re.findall(r"(?:\s*|)(.+?)\s*\w+(?:,|$)", fields)]
+        table_name = fields_types_name[0]
+        name = no_vk(vkname)
+
+        nn = (fix_arg(name), fix_ext_suffix(name))
+
+        if table_name in ('Device', 'Queue', 'CommandBuffer') and name != 'GetDeviceProcAddr':
+            group_map["Device"].append(nn)
+        elif table_name in ('Instance', 'PhysicalDevice') or name == 'GetDeviceProcAddr':
+            group_map["Instance"].append(nn)
+        elif table_name in ('rawptr', '', 'DebugReportFlagsEXT') or name == 'GetInstanceProcAddr':
+            # Skip the allocation function and the dll entry point
+            pass
+        else:
+            group_map["Loader"].append(nn)
+
+    for group_name, group_lines in group_map.items():
+        f.write("// {} Procedures\n".format(group_name))
+        max_len = max(len(name) for name, _ in group_lines)
+        for name, vk_name in group_lines:
+            type_str = procedure_map[vk_name]
+            f.write('{}: {};\n'.format(remove_prefix(name, "Proc"), name.rjust(max_len)))
+        f.write("\n")
+
+    f.write("load_proc_addresses :: proc(set_proc_address: SetProcAddressType) {\n")
+    for group_name, group_lines in group_map.items():
+        f.write("\t// {} Procedures\n".format(group_name))
+        max_len = max(len(name) for name, _ in group_lines)
+        for name, vk_name in group_lines:
+            k = max_len - len(name)
+            f.write('\tset_proc_address(&{}, {}"vk{}");\n'.format(
+                remove_prefix(name, 'Proc'),
+                "".ljust(k),
+                remove_prefix(vk_name, 'Proc'),
+            ))
+        f.write("\n")
+    f.write("}\n")
+
+
+
+BASE = """
+//
+// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
+//
+package vulkan
+
+import "core:c"
+"""[1::]
+
+
+with open("../core.odin", 'w', encoding='utf-8') as f:
+    f.write(BASE)
+    f.write("""
+API_VERSION_1_0 :: (1<<22) | (0<<12) | (0);
+
+MAKE_VERSION :: proc(major, minor, patch: u32) -> u32 {
+    return (major<<22) | (minor<<12) | (patch);
+}
+
+// Base types
+Flags         :: distinct u32;
+Flags64       :: distinct u64;
+DeviceSize    :: distinct u64;
+DeviceAddress :: distinct u64;
+SampleMask    :: distinct u32;
+
+Handle                :: distinct rawptr;
+NonDispatchableHandle :: distinct u64;
+
+SetProcAddressType :: #type proc(p: rawptr, name: cstring);
+
+
+cstring_array :: ^cstring; // Helper Type
+
+RemoteAddressNV :: distinct rawptr; // Declared inline before MemoryGetRemoteAddressInfoNV
+
+// Base constants
+LOD_CLAMP_NONE                :: 1000.0;
+REMAINING_MIP_LEVELS          :: ~u32(0);
+REMAINING_ARRAY_LAYERS        :: ~u32(0);
+WHOLE_SIZE                    :: ~u64(0);
+ATTACHMENT_UNUSED             :: ~u32(0);
+TRUE                          :: 1;
+FALSE                         :: 0;
+QUEUE_FAMILY_IGNORED          :: ~u32(0);
+SUBPASS_EXTERNAL              :: ~u32(0);
+MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256;
+UUID_SIZE                     :: 16;
+MAX_MEMORY_TYPES              :: 32;
+MAX_MEMORY_HEAPS              :: 16;
+MAX_EXTENSION_NAME_SIZE       :: 256;
+MAX_DESCRIPTION_SIZE          :: 256;
+MAX_DEVICE_GROUP_SIZE_KHX     :: 32;
+MAX_DEVICE_GROUP_SIZE         :: 32;
+LUID_SIZE_KHX                 :: 8;
+LUID_SIZE_KHR                 :: 8;
+LUID_SIZE                     :: 8;
+MAX_DRIVER_NAME_SIZE_KHR      :: 256;
+MAX_DRIVER_INFO_SIZE_KHR      :: 256;
+MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(0)-1;
+MAX_GLOBAL_PRIORITY_SIZE_EXT  :: 16;
+
+"""[1::])
+    parse_constants(f)
+    parse_handles_def(f)
+    f.write("\n\n")
+    parse_flags_def(f)
+    with open("../enums.odin", 'w', encoding='utf-8') as f:
+        f.write(BASE)
+        f.write("\n")
+        parse_enums(f)
+        f.write("\n\n")
+    with open("../structs.odin", 'w', encoding='utf-8') as f:
+        f.write(BASE)
+        f.write("""
+when ODIN_OS == "windows" {
+\timport win32 "core:sys/windows"
+
+\tHINSTANCE           :: win32.HINSTANCE;
+\tHWND                :: win32.HWND;
+\tHMONITOR            :: win32.HMONITOR;
+\tHANDLE              :: win32.HANDLE;
+\tLPCWSTR             :: win32.LPCWSTR;
+\tSECURITY_ATTRIBUTES :: win32.SECURITY_ATTRIBUTES;
+\tDWORD               :: win32.DWORD;
+\tLONG                :: win32.LONG;
+\tLUID                :: win32.LUID;
+} else {
+\tHINSTANCE           :: distinct rawptr;
+\tHWND                :: distinct rawptr;
+\tHMONITOR            :: distinct rawptr;
+\tHANDLE              :: distinct rawptr;
+\tLPCWSTR             :: ^u16;
+\tSECURITY_ATTRIBUTES :: struct {};
+\tDWORD               :: u32;
+\tLONG                :: c.long;
+\tLUID :: struct {
+\t\tLowPart:  DWORD,
+\t\tHighPart: LONG,
+\t}
+}
+
+CAMetalLayer :: struct {};
+
+/********************************/
+""")
+        f.write("\n")
+        parse_structs(f)
+        f.write("\n\n")
+    with open("../procedures.odin", 'w', encoding='utf-8') as f:
+        f.write(BASE)
+        f.write("\n")
+        parse_procedures(f)
+        f.write("\n")
+        group_functions(f)
+        f.write("\n\n")

vendor/vulkan/_gen/vk_icd.h

@@ -0,0 +1,245 @@
+//
+// File: vk_icd.h
+//
+/*
+ * Copyright (c) 2015-2016 The Khronos Group Inc.
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef VKICD_H
+#define VKICD_H
+
+#include "vulkan.h"
+#include <stdbool.h>
+
+// Loader-ICD version negotiation API.  Versions add the following features:
+//   Version 0 - Initial.  Doesn't support vk_icdGetInstanceProcAddr
+//               or vk_icdNegotiateLoaderICDInterfaceVersion.
+//   Version 1 - Add support for vk_icdGetInstanceProcAddr.
+//   Version 2 - Add Loader/ICD Interface version negotiation
+//               via vk_icdNegotiateLoaderICDInterfaceVersion.
+//   Version 3 - Add ICD creation/destruction of KHR_surface objects.
+//   Version 4 - Add unknown physical device extension qyering via
+//               vk_icdGetPhysicalDeviceProcAddr.
+//   Version 5 - Tells ICDs that the loader is now paying attention to the
+//               application version of Vulkan passed into the ApplicationInfo
+//               structure during vkCreateInstance.  This will tell the ICD
+//               that if the loader is older, it should automatically fail a
+//               call for any API version > 1.0.  Otherwise, the loader will
+//               manually determine if it can support the expected version.
+//   Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices.
+#define CURRENT_LOADER_ICD_INTERFACE_VERSION 6
+#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
+#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
+
+// Old typedefs that don't follow a proper naming convention but are preserved for compatibility
+typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
+// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
+// file directly, it won't be found.
+#ifndef PFN_GetPhysicalDeviceProcAddr
+typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
+#endif
+
+// Typedefs for loader/ICD interface
+typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID,
+    uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+#endif
+
+// Prototypes for loader/ICD interface
+#if !defined(VK_NO_PROTOTYPES)
+#ifdef __cplusplus
+extern "C" {
+#endif
+    VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion);
+    VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName);
+    VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance isntance, const char* pName);
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID,
+        uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+/*
+ * The ICD must reserve space for a pointer for the loader's dispatch
+ * table, at the start of <each object>.
+ * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
+ */
+
+#define ICD_LOADER_MAGIC 0x01CDC0DE
+
+typedef union {
+    uintptr_t loaderMagic;
+    void *loaderData;
+} VK_LOADER_DATA;
+
+static inline void set_loader_magic_value(void *pNewObject) {
+    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
+    loader_info->loaderMagic = ICD_LOADER_MAGIC;
+}
+
+static inline bool valid_loader_magic_value(void *pNewObject) {
+    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
+    return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
+}
+
+/*
+ * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
+ * contains the platform-specific connection and surface information.
+ */
+typedef enum {
+    VK_ICD_WSI_PLATFORM_MIR,
+    VK_ICD_WSI_PLATFORM_WAYLAND,
+    VK_ICD_WSI_PLATFORM_WIN32,
+    VK_ICD_WSI_PLATFORM_XCB,
+    VK_ICD_WSI_PLATFORM_XLIB,
+    VK_ICD_WSI_PLATFORM_ANDROID,
+    VK_ICD_WSI_PLATFORM_MACOS,
+    VK_ICD_WSI_PLATFORM_IOS,
+    VK_ICD_WSI_PLATFORM_DISPLAY,
+    VK_ICD_WSI_PLATFORM_HEADLESS,
+    VK_ICD_WSI_PLATFORM_METAL,
+    VK_ICD_WSI_PLATFORM_DIRECTFB,
+    VK_ICD_WSI_PLATFORM_VI,
+    VK_ICD_WSI_PLATFORM_GGP,
+    VK_ICD_WSI_PLATFORM_SCREEN,
+} VkIcdWsiPlatform;
+
+typedef struct {
+    VkIcdWsiPlatform platform;
+} VkIcdSurfaceBase;
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    MirConnection *connection;
+    MirSurface *mirSurface;
+} VkIcdSurfaceMir;
+#endif  // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct wl_display *display;
+    struct wl_surface *surface;
+} VkIcdSurfaceWayland;
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    HINSTANCE hinstance;
+    HWND hwnd;
+} VkIcdSurfaceWin32;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    xcb_connection_t *connection;
+    xcb_window_t window;
+} VkIcdSurfaceXcb;
+#endif  // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    Display *dpy;
+    Window window;
+} VkIcdSurfaceXlib;
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+typedef struct {
+    VkIcdSurfaceBase base;
+    IDirectFB *dfb;
+    IDirectFBSurface *surface;
+} VkIcdSurfaceDirectFB;
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct ANativeWindow *window;
+} VkIcdSurfaceAndroid;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+typedef struct {
+    VkIcdSurfaceBase base;
+    const void *pView;
+} VkIcdSurfaceMacOS;
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+typedef struct {
+    VkIcdSurfaceBase base;
+    const void *pView;
+} VkIcdSurfaceIOS;
+#endif  // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_GGP
+typedef struct {
+    VkIcdSurfaceBase base;
+    GgpStreamDescriptor streamDescriptor;
+} VkIcdSurfaceGgp;
+#endif  // VK_USE_PLATFORM_GGP
+
+typedef struct {
+    VkIcdSurfaceBase base;
+    VkDisplayModeKHR displayMode;
+    uint32_t planeIndex;
+    uint32_t planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR transform;
+    float globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+    VkExtent2D imageExtent;
+} VkIcdSurfaceDisplay;
+
+typedef struct {
+    VkIcdSurfaceBase base;
+} VkIcdSurfaceHeadless;
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+typedef struct {
+    VkIcdSurfaceBase base;
+    const CAMetalLayer *pLayer;
+} VkIcdSurfaceMetal;
+#endif // VK_USE_PLATFORM_METAL_EXT
+
+#ifdef VK_USE_PLATFORM_VI_NN
+typedef struct {
+    VkIcdSurfaceBase base;
+    void *window;
+} VkIcdSurfaceVi;
+#endif // VK_USE_PLATFORM_VI_NN
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct _screen_context *context;
+    struct _screen_window *window;
+} VkIcdSurfaceScreen;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
+#endif  // VKICD_H

vendor/vulkan/_gen/vk_layer.h

@@ -0,0 +1,210 @@
+//
+// File: vk_layer.h
+//
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Need to define dispatch table
+ * Core struct can then have ptr to dispatch table at the top
+ * Along with object ptrs for current and next OBJ
+ */
+#pragma once
+
+#include "vulkan.h"
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define VK_LAYER_EXPORT __attribute__((visibility("default")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define VK_LAYER_EXPORT __attribute__((visibility("default")))
+#else
+#define VK_LAYER_EXPORT
+#endif
+
+#define MAX_NUM_UNKNOWN_EXTS 250
+
+ // Loader-Layer version negotiation API.  Versions add the following features:
+ //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
+ //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
+ //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
+ //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
+#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
+#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
+
+#define VK_CURRENT_CHAIN_VERSION 1
+
+// Typedef for use in the interfaces below
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
+
+// Version negotiation values
+typedef enum VkNegotiateLayerStructType {
+    LAYER_NEGOTIATE_UNINTIALIZED = 0,
+    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
+} VkNegotiateLayerStructType;
+
+// Version negotiation structures
+typedef struct VkNegotiateLayerInterface {
+    VkNegotiateLayerStructType sType;
+    void *pNext;
+    uint32_t loaderLayerInterfaceVersion;
+    PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
+    PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
+} VkNegotiateLayerInterface;
+
+// Version negotiation functions
+typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
+
+// Function prototype for unknown physical device extension command
+typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
+
+// ------------------------------------------------------------------------------------------------
+// CreateInstance and CreateDevice support structures
+
+/* Sub type of structure for instance and device loader ext of CreateInfo.
+ * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
+ * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
+ * then VkLayerFunction indicates struct type pointed to by pNext
+ */
+typedef enum VkLayerFunction_ {
+    VK_LAYER_LINK_INFO = 0,
+    VK_LOADER_DATA_CALLBACK = 1,
+    VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2,
+    VK_LOADER_FEATURES = 3,
+} VkLayerFunction;
+
+typedef struct VkLayerInstanceLink_ {
+    struct VkLayerInstanceLink_ *pNext;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
+} VkLayerInstanceLink;
+
+/*
+ * When creating the device chain the loader needs to pass
+ * down information about it's device structure needed at
+ * the end of the chain. Passing the data via the
+ * VkLayerDeviceInfo avoids issues with finding the
+ * exact instance being used.
+ */
+typedef struct VkLayerDeviceInfo_ {
+    void *device_info;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+} VkLayerDeviceInfo;
+
+typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
+        void *object);
+typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
+        void *object);
+typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
+						      const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
+typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
+
+typedef enum VkLoaderFeastureFlagBits {
+    VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001,
+} VkLoaderFlagBits;
+typedef VkFlags VkLoaderFeatureFlags;
+
+typedef struct {
+    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
+    const void *pNext;
+    VkLayerFunction function;
+    union {
+        VkLayerInstanceLink *pLayerInfo;
+        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
+        struct {
+	        PFN_vkLayerCreateDevice pfnLayerCreateDevice;
+	        PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
+	    } layerDevice;
+        VkLoaderFeatureFlags loaderFeatures;
+    } u;
+} VkLayerInstanceCreateInfo;
+
+typedef struct VkLayerDeviceLink_ {
+    struct VkLayerDeviceLink_ *pNext;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
+} VkLayerDeviceLink;
+
+typedef struct {
+    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
+    const void *pNext;
+    VkLayerFunction function;
+    union {
+        VkLayerDeviceLink *pLayerInfo;
+        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
+    } u;
+} VkLayerDeviceCreateInfo;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
+
+typedef enum VkChainType {
+    VK_CHAIN_TYPE_UNKNOWN = 0,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
+} VkChainType;
+
+typedef struct VkChainHeader {
+    VkChainType type;
+    uint32_t version;
+    uint32_t size;
+} VkChainHeader;
+
+typedef struct VkEnumerateInstanceExtensionPropertiesChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
+                                      VkExtensionProperties *);
+    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
+        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
+    }
+#endif
+} VkEnumerateInstanceExtensionPropertiesChain;
+
+typedef struct VkEnumerateInstanceLayerPropertiesChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
+    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
+        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
+    }
+#endif
+} VkEnumerateInstanceLayerPropertiesChain;
+
+typedef struct VkEnumerateInstanceVersionChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
+    const struct VkEnumerateInstanceVersionChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(uint32_t *pApiVersion) const {
+        return pfnNextLayer(pNextLink, pApiVersion);
+    }
+#endif
+} VkEnumerateInstanceVersionChain;
+
+#ifdef __cplusplus
+}
+#endif

vendor/vulkan/_gen/vk_platform.h

@@ -0,0 +1,84 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright 2014-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+
+#ifndef VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#if !defined(VK_NO_STDDEF_H)
+    #include <stddef.h>
+#endif // !defined(VK_NO_STDDEF_H)
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif

vendor/vulkan/_gen/vulkan_core.h

@@ -0,0 +1,13121 @@
+#ifndef VULKAN_CORE_H_
+#define VULKAN_CORE_H_ 1
+
+/*
+** Copyright 2015-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_VERSION_1_0 1
+#include "vk_platform.h"
+
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+
+
+#ifndef VK_USE_64_BIT_PTR_DEFINES
+    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VK_USE_64_BIT_PTR_DEFINES 1
+    #else
+        #define VK_USE_64_BIT_PTR_DEFINES 0
+    #endif
+#endif
+
+
+#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
+    #if (VK_USE_64_BIT_PTR_DEFINES==1)
+        #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
+            #define VK_NULL_HANDLE nullptr
+        #else
+            #define VK_NULL_HANDLE ((void*)0)
+        #endif
+    #else
+        #define VK_NULL_HANDLE 0ULL
+    #endif
+#endif
+#ifndef VK_NULL_HANDLE
+    #define VK_NULL_HANDLE 0
+#endif
+
+
+#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
+    #if (VK_USE_64_BIT_PTR_DEFINES==1)
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
+    #else
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+    #endif
+#endif
+
+// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
+#define VK_MAKE_VERSION(major, minor, patch) \
+    ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
+
+// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
+//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
+
+#define VK_MAKE_API_VERSION(variant, major, minor, patch) \
+    ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
+
+// Vulkan 1.0 version number
+#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
+
+// Version of this file
+#define VK_HEADER_VERSION 189
+
+// Complete version of this file
+#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
+
+// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
+#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
+
+// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
+#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
+
+// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
+#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
+
+#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)
+#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
+#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
+#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
+typedef uint32_t VkBool32;
+typedef uint64_t VkDeviceAddress;
+typedef uint64_t VkDeviceSize;
+typedef uint32_t VkFlags;
+typedef uint32_t VkSampleMask;
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+VK_DEFINE_HANDLE(VkInstance)
+VK_DEFINE_HANDLE(VkPhysicalDevice)
+VK_DEFINE_HANDLE(VkDevice)
+VK_DEFINE_HANDLE(VkQueue)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+VK_DEFINE_HANDLE(VkCommandBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+#define VK_UUID_SIZE                      16U
+#define VK_ATTACHMENT_UNUSED              (~0U)
+#define VK_FALSE                          0U
+#define VK_LOD_CLAMP_NONE                 1000.0F
+#define VK_QUEUE_FAMILY_IGNORED           (~0U)
+#define VK_REMAINING_ARRAY_LAYERS         (~0U)
+#define VK_REMAINING_MIP_LEVELS           (~0U)
+#define VK_SUBPASS_EXTERNAL               (~0U)
+#define VK_TRUE                           1U
+#define VK_WHOLE_SIZE                     (~0ULL)
+#define VK_MAX_MEMORY_TYPES               32U
+#define VK_MAX_MEMORY_HEAPS               16U
+#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256U
+#define VK_MAX_EXTENSION_NAME_SIZE        256U
+#define VK_MAX_DESCRIPTION_SIZE           256U
+
+typedef enum VkResult {
+    VK_SUCCESS = 0,
+    VK_NOT_READY = 1,
+    VK_TIMEOUT = 2,
+    VK_EVENT_SET = 3,
+    VK_EVENT_RESET = 4,
+    VK_INCOMPLETE = 5,
+    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+    VK_ERROR_INITIALIZATION_FAILED = -3,
+    VK_ERROR_DEVICE_LOST = -4,
+    VK_ERROR_MEMORY_MAP_FAILED = -5,
+    VK_ERROR_LAYER_NOT_PRESENT = -6,
+    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+    VK_ERROR_FEATURE_NOT_PRESENT = -8,
+    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+    VK_ERROR_TOO_MANY_OBJECTS = -10,
+    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+    VK_ERROR_FRAGMENTED_POOL = -12,
+    VK_ERROR_UNKNOWN = -13,
+    VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
+    VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
+    VK_ERROR_FRAGMENTATION = -1000161000,
+    VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
+    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
+    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
+    VK_SUBOPTIMAL_KHR = 1000001003,
+    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
+    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
+    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
+    VK_ERROR_INVALID_SHADER_NV = -1000012000,
+    VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
+    VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
+    VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
+    VK_THREAD_IDLE_KHR = 1000268000,
+    VK_THREAD_DONE_KHR = 1000268001,
+    VK_OPERATION_DEFERRED_KHR = 1000268002,
+    VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,
+    VK_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000,
+    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
+    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+    VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
+    VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+    VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+    VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED_EXT,
+    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+} VkResult;
+
+typedef enum VkStructureType {
+    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
+    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
+    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
+    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
+    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
+    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
+    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
+    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
+    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
+    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
+    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
+    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
+    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
+    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
+    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
+    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
+    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
+    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
+    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
+    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
+    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
+    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
+    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
+    VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
+    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
+    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
+    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
+    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
+    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002,
+    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004,
+    VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005,
+    VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000,
+    VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000,
+    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002,
+    VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001,
+    VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002,
+    VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003,
+    VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004,
+    VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000,
+    VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001,
+    VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002,
+    VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003,
+    VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
+    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
+    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
+    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
+    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
+    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
+#endif
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
+    VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000,
+    VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001,
+    VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038002,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038003,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038004,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038005,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038006,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038007,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038008,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT = 1000040001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040002,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040003,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040004,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040005,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040006,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040007,
+#endif
+    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
+    VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
+    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
+    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
+    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
+    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
+    VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
+    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
+    VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
+    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
+    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
+    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
+    VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
+    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
+    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
+    VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
+    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
+    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
+    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
+    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
+    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
+    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
+    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
+    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
+    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
+    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
+    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
+    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
+    VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
+    VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
+    VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
+    VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
+    VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
+    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
+    VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
+    VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
+    VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
+    VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
+    VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
+    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
+    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
+    VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
+    VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
+    VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
+    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
+    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
+    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
+    VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
+    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009,
+    VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010,
+    VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001,
+    VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015,
+    VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016,
+    VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013,
+    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
+    VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
+    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
+    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
+    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
+    VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
+    VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,
+#endif
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
+    VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
+    VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
+    VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
+    VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
+    VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
+    VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
+    VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
+    VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
+    VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
+    VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
+    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT = 1000187001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187002,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187003,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187004,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187005,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187006,
+#endif
+    VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
+    VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
+    VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
+    VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
+    VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,
+    VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
+    VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
+    VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
+    VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
+    VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
+    VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
+    VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000,
+    VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
+    VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
+    VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000,
+    VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
+    VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
+    VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
+    VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000,
+    VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
+    VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
+    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002,
+    VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
+    VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
+    VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+    VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,
+    VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002,
+    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003,
+    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
+    VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
+    VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
+    VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
+    VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
+    VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
+    VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000,
+    VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001,
+    VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
+#endif
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
+    VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002,
+    VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003,
+    VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004,
+    VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008,
+    VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = 1000325000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001,
+    VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,
+    VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000,
+    VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000,
+    VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001,
+    VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002,
+    VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003,
+    VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004,
+    VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005,
+    VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006,
+    VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007,
+    VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008,
+    VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009,
+    VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
+    VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,
+    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,
+    VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,
+    VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000,
+    VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001,
+    VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,
+    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,
+    VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,
+    VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000,
+    VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000,
+    VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = 1000388000,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = 1000388001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
+    VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+    VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
+    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
+    VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
+    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
+    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
+    VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
+    VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
+    VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
+    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+    VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
+    VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
+    VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkStructureType;
+
+typedef enum VkImageLayout {
+    VK_IMAGE_LAYOUT_UNDEFINED = 0,
+    VK_IMAGE_LAYOUT_GENERAL = 1,
+    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
+    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
+    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
+    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,
+    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,
+    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
+    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002,
+#endif
+    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
+    VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
+    VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
+#endif
+    VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000,
+    VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
+} VkImageLayout;
+
+typedef enum VkObjectType {
+    VK_OBJECT_TYPE_UNKNOWN = 0,
+    VK_OBJECT_TYPE_INSTANCE = 1,
+    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
+    VK_OBJECT_TYPE_DEVICE = 3,
+    VK_OBJECT_TYPE_QUEUE = 4,
+    VK_OBJECT_TYPE_SEMAPHORE = 5,
+    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
+    VK_OBJECT_TYPE_FENCE = 7,
+    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
+    VK_OBJECT_TYPE_BUFFER = 9,
+    VK_OBJECT_TYPE_IMAGE = 10,
+    VK_OBJECT_TYPE_EVENT = 11,
+    VK_OBJECT_TYPE_QUERY_POOL = 12,
+    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
+    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
+    VK_OBJECT_TYPE_SHADER_MODULE = 15,
+    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
+    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
+    VK_OBJECT_TYPE_RENDER_PASS = 18,
+    VK_OBJECT_TYPE_PIPELINE = 19,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
+    VK_OBJECT_TYPE_SAMPLER = 21,
+    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
+    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
+    VK_OBJECT_TYPE_COMMAND_POOL = 25,
+    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
+    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
+    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
+    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
+    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
+    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
+    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001,
+#endif
+    VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000,
+    VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001,
+    VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
+    VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
+    VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
+    VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
+    VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
+    VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,
+    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
+    VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000,
+    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkObjectType;
+
+typedef enum VkPipelineCacheHeaderVersion {
+    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCacheHeaderVersion;
+
+typedef enum VkVendorId {
+    VK_VENDOR_ID_VIV = 0x10001,
+    VK_VENDOR_ID_VSI = 0x10002,
+    VK_VENDOR_ID_KAZAN = 0x10003,
+    VK_VENDOR_ID_CODEPLAY = 0x10004,
+    VK_VENDOR_ID_MESA = 0x10005,
+    VK_VENDOR_ID_POCL = 0x10006,
+    VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
+} VkVendorId;
+
+typedef enum VkSystemAllocationScope {
+    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
+    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
+    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
+    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
+    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
+    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocationScope;
+
+typedef enum VkInternalAllocationType {
+    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
+    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkInternalAllocationType;
+
+typedef enum VkFormat {
+    VK_FORMAT_UNDEFINED = 0,
+    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
+    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
+    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
+    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
+    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
+    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
+    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
+    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
+    VK_FORMAT_R8_UNORM = 9,
+    VK_FORMAT_R8_SNORM = 10,
+    VK_FORMAT_R8_USCALED = 11,
+    VK_FORMAT_R8_SSCALED = 12,
+    VK_FORMAT_R8_UINT = 13,
+    VK_FORMAT_R8_SINT = 14,
+    VK_FORMAT_R8_SRGB = 15,
+    VK_FORMAT_R8G8_UNORM = 16,
+    VK_FORMAT_R8G8_SNORM = 17,
+    VK_FORMAT_R8G8_USCALED = 18,
+    VK_FORMAT_R8G8_SSCALED = 19,
+    VK_FORMAT_R8G8_UINT = 20,
+    VK_FORMAT_R8G8_SINT = 21,
+    VK_FORMAT_R8G8_SRGB = 22,
+    VK_FORMAT_R8G8B8_UNORM = 23,
+    VK_FORMAT_R8G8B8_SNORM = 24,
+    VK_FORMAT_R8G8B8_USCALED = 25,
+    VK_FORMAT_R8G8B8_SSCALED = 26,
+    VK_FORMAT_R8G8B8_UINT = 27,
+    VK_FORMAT_R8G8B8_SINT = 28,
+    VK_FORMAT_R8G8B8_SRGB = 29,
+    VK_FORMAT_B8G8R8_UNORM = 30,
+    VK_FORMAT_B8G8R8_SNORM = 31,
+    VK_FORMAT_B8G8R8_USCALED = 32,
+    VK_FORMAT_B8G8R8_SSCALED = 33,
+    VK_FORMAT_B8G8R8_UINT = 34,
+    VK_FORMAT_B8G8R8_SINT = 35,
+    VK_FORMAT_B8G8R8_SRGB = 36,
+    VK_FORMAT_R8G8B8A8_UNORM = 37,
+    VK_FORMAT_R8G8B8A8_SNORM = 38,
+    VK_FORMAT_R8G8B8A8_USCALED = 39,
+    VK_FORMAT_R8G8B8A8_SSCALED = 40,
+    VK_FORMAT_R8G8B8A8_UINT = 41,
+    VK_FORMAT_R8G8B8A8_SINT = 42,
+    VK_FORMAT_R8G8B8A8_SRGB = 43,
+    VK_FORMAT_B8G8R8A8_UNORM = 44,
+    VK_FORMAT_B8G8R8A8_SNORM = 45,
+    VK_FORMAT_B8G8R8A8_USCALED = 46,
+    VK_FORMAT_B8G8R8A8_SSCALED = 47,
+    VK_FORMAT_B8G8R8A8_UINT = 48,
+    VK_FORMAT_B8G8R8A8_SINT = 49,
+    VK_FORMAT_B8G8R8A8_SRGB = 50,
+    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
+    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
+    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
+    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
+    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
+    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
+    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
+    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
+    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
+    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
+    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
+    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
+    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
+    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
+    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
+    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
+    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
+    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
+    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
+    VK_FORMAT_R16_UNORM = 70,
+    VK_FORMAT_R16_SNORM = 71,
+    VK_FORMAT_R16_USCALED = 72,
+    VK_FORMAT_R16_SSCALED = 73,
+    VK_FORMAT_R16_UINT = 74,
+    VK_FORMAT_R16_SINT = 75,
+    VK_FORMAT_R16_SFLOAT = 76,
+    VK_FORMAT_R16G16_UNORM = 77,
+    VK_FORMAT_R16G16_SNORM = 78,
+    VK_FORMAT_R16G16_USCALED = 79,
+    VK_FORMAT_R16G16_SSCALED = 80,
+    VK_FORMAT_R16G16_UINT = 81,
+    VK_FORMAT_R16G16_SINT = 82,
+    VK_FORMAT_R16G16_SFLOAT = 83,
+    VK_FORMAT_R16G16B16_UNORM = 84,
+    VK_FORMAT_R16G16B16_SNORM = 85,
+    VK_FORMAT_R16G16B16_USCALED = 86,
+    VK_FORMAT_R16G16B16_SSCALED = 87,
+    VK_FORMAT_R16G16B16_UINT = 88,
+    VK_FORMAT_R16G16B16_SINT = 89,
+    VK_FORMAT_R16G16B16_SFLOAT = 90,
+    VK_FORMAT_R16G16B16A16_UNORM = 91,
+    VK_FORMAT_R16G16B16A16_SNORM = 92,
+    VK_FORMAT_R16G16B16A16_USCALED = 93,
+    VK_FORMAT_R16G16B16A16_SSCALED = 94,
+    VK_FORMAT_R16G16B16A16_UINT = 95,
+    VK_FORMAT_R16G16B16A16_SINT = 96,
+    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
+    VK_FORMAT_R32_UINT = 98,
+    VK_FORMAT_R32_SINT = 99,
+    VK_FORMAT_R32_SFLOAT = 100,
+    VK_FORMAT_R32G32_UINT = 101,
+    VK_FORMAT_R32G32_SINT = 102,
+    VK_FORMAT_R32G32_SFLOAT = 103,
+    VK_FORMAT_R32G32B32_UINT = 104,
+    VK_FORMAT_R32G32B32_SINT = 105,
+    VK_FORMAT_R32G32B32_SFLOAT = 106,
+    VK_FORMAT_R32G32B32A32_UINT = 107,
+    VK_FORMAT_R32G32B32A32_SINT = 108,
+    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
+    VK_FORMAT_R64_UINT = 110,
+    VK_FORMAT_R64_SINT = 111,
+    VK_FORMAT_R64_SFLOAT = 112,
+    VK_FORMAT_R64G64_UINT = 113,
+    VK_FORMAT_R64G64_SINT = 114,
+    VK_FORMAT_R64G64_SFLOAT = 115,
+    VK_FORMAT_R64G64B64_UINT = 116,
+    VK_FORMAT_R64G64B64_SINT = 117,
+    VK_FORMAT_R64G64B64_SFLOAT = 118,
+    VK_FORMAT_R64G64B64A64_UINT = 119,
+    VK_FORMAT_R64G64B64A64_SINT = 120,
+    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
+    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
+    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
+    VK_FORMAT_D16_UNORM = 124,
+    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
+    VK_FORMAT_D32_SFLOAT = 126,
+    VK_FORMAT_S8_UINT = 127,
+    VK_FORMAT_D16_UNORM_S8_UINT = 128,
+    VK_FORMAT_D24_UNORM_S8_UINT = 129,
+    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
+    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
+    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
+    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
+    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
+    VK_FORMAT_BC2_UNORM_BLOCK = 135,
+    VK_FORMAT_BC2_SRGB_BLOCK = 136,
+    VK_FORMAT_BC3_UNORM_BLOCK = 137,
+    VK_FORMAT_BC3_SRGB_BLOCK = 138,
+    VK_FORMAT_BC4_UNORM_BLOCK = 139,
+    VK_FORMAT_BC4_SNORM_BLOCK = 140,
+    VK_FORMAT_BC5_UNORM_BLOCK = 141,
+    VK_FORMAT_BC5_SNORM_BLOCK = 142,
+    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
+    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
+    VK_FORMAT_BC7_UNORM_BLOCK = 145,
+    VK_FORMAT_BC7_SRGB_BLOCK = 146,
+    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
+    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
+    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
+    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
+    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
+    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
+    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
+    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
+    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
+    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
+    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
+    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
+    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
+    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
+    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
+    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
+    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
+    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
+    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
+    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
+    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
+    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
+    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
+    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
+    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
+    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
+    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
+    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
+    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
+    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
+    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
+    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
+    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
+    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
+    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
+    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
+    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
+    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+    VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
+    VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
+    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
+    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
+    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
+    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
+    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
+    VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
+    VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
+    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
+    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
+    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
+    VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
+    VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
+    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
+    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
+    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
+    VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
+    VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
+    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
+    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
+    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
+    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
+    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
+    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
+    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
+    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
+    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
+    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
+    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
+    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
+    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
+    VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
+    VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
+    VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
+    VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
+    VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
+    VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
+    VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
+    VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
+    VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
+    VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
+    VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
+    VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
+    VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
+    VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
+    VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002,
+    VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003,
+    VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000,
+    VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001,
+    VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
+    VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+    VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
+    VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
+    VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
+    VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
+    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
+} VkFormat;
+
+typedef enum VkImageTiling {
+    VK_IMAGE_TILING_OPTIMAL = 0,
+    VK_IMAGE_TILING_LINEAR = 1,
+    VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
+    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+} VkImageTiling;
+
+typedef enum VkImageType {
+    VK_IMAGE_TYPE_1D = 0,
+    VK_IMAGE_TYPE_2D = 1,
+    VK_IMAGE_TYPE_3D = 2,
+    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkImageType;
+
+typedef enum VkPhysicalDeviceType {
+    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
+    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
+    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
+    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
+    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
+    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkPhysicalDeviceType;
+
+typedef enum VkQueryType {
+    VK_QUERY_TYPE_OCCLUSION = 0,
+    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+    VK_QUERY_TYPE_TIMESTAMP = 2,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000,
+#endif
+    VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
+    VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
+    VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000,
+    VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,
+    VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
+    VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000,
+#endif
+    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkQueryType;
+
+typedef enum VkSharingMode {
+    VK_SHARING_MODE_EXCLUSIVE = 0,
+    VK_SHARING_MODE_CONCURRENT = 1,
+    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSharingMode;
+
+typedef enum VkComponentSwizzle {
+    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
+    VK_COMPONENT_SWIZZLE_ZERO = 1,
+    VK_COMPONENT_SWIZZLE_ONE = 2,
+    VK_COMPONENT_SWIZZLE_R = 3,
+    VK_COMPONENT_SWIZZLE_G = 4,
+    VK_COMPONENT_SWIZZLE_B = 5,
+    VK_COMPONENT_SWIZZLE_A = 6,
+    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+} VkComponentSwizzle;
+
+typedef enum VkImageViewType {
+    VK_IMAGE_VIEW_TYPE_1D = 0,
+    VK_IMAGE_VIEW_TYPE_2D = 1,
+    VK_IMAGE_VIEW_TYPE_3D = 2,
+    VK_IMAGE_VIEW_TYPE_CUBE = 3,
+    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
+    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
+    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
+    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkImageViewType;
+
+typedef enum VkBlendFactor {
+    VK_BLEND_FACTOR_ZERO = 0,
+    VK_BLEND_FACTOR_ONE = 1,
+    VK_BLEND_FACTOR_SRC_COLOR = 2,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
+    VK_BLEND_FACTOR_DST_COLOR = 4,
+    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
+    VK_BLEND_FACTOR_SRC_ALPHA = 6,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
+    VK_BLEND_FACTOR_DST_ALPHA = 8,
+    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
+    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
+    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
+    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
+    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
+    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
+    VK_BLEND_FACTOR_SRC1_COLOR = 15,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
+    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
+    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
+} VkBlendFactor;
+
+typedef enum VkBlendOp {
+    VK_BLEND_OP_ADD = 0,
+    VK_BLEND_OP_SUBTRACT = 1,
+    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
+    VK_BLEND_OP_MIN = 3,
+    VK_BLEND_OP_MAX = 4,
+    VK_BLEND_OP_ZERO_EXT = 1000148000,
+    VK_BLEND_OP_SRC_EXT = 1000148001,
+    VK_BLEND_OP_DST_EXT = 1000148002,
+    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
+    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
+    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
+    VK_BLEND_OP_DST_IN_EXT = 1000148006,
+    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
+    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
+    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
+    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
+    VK_BLEND_OP_XOR_EXT = 1000148011,
+    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
+    VK_BLEND_OP_SCREEN_EXT = 1000148013,
+    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
+    VK_BLEND_OP_DARKEN_EXT = 1000148015,
+    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
+    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
+    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
+    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
+    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
+    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
+    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
+    VK_BLEND_OP_INVERT_EXT = 1000148023,
+    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
+    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
+    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
+    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
+    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
+    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
+    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
+    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
+    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
+    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
+    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
+    VK_BLEND_OP_PLUS_EXT = 1000148035,
+    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
+    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
+    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
+    VK_BLEND_OP_MINUS_EXT = 1000148039,
+    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
+    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
+    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
+    VK_BLEND_OP_RED_EXT = 1000148043,
+    VK_BLEND_OP_GREEN_EXT = 1000148044,
+    VK_BLEND_OP_BLUE_EXT = 1000148045,
+    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
+} VkBlendOp;
+
+typedef enum VkCompareOp {
+    VK_COMPARE_OP_NEVER = 0,
+    VK_COMPARE_OP_LESS = 1,
+    VK_COMPARE_OP_EQUAL = 2,
+    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
+    VK_COMPARE_OP_GREATER = 4,
+    VK_COMPARE_OP_NOT_EQUAL = 5,
+    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
+    VK_COMPARE_OP_ALWAYS = 7,
+    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
+} VkCompareOp;
+
+typedef enum VkDynamicState {
+    VK_DYNAMIC_STATE_VIEWPORT = 0,
+    VK_DYNAMIC_STATE_SCISSOR = 1,
+    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
+    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
+    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
+    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
+    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
+    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
+    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
+    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
+    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
+    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
+    VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
+    VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
+    VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
+    VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
+    VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
+    VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000,
+    VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001,
+    VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002,
+    VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003,
+    VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004,
+    VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005,
+    VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006,
+    VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007,
+    VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008,
+    VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009,
+    VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010,
+    VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011,
+    VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
+    VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
+    VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001,
+    VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002,
+    VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
+    VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004,
+    VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
+    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
+} VkDynamicState;
+
+typedef enum VkFrontFace {
+    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+    VK_FRONT_FACE_CLOCKWISE = 1,
+    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
+} VkFrontFace;
+
+typedef enum VkVertexInputRate {
+    VK_VERTEX_INPUT_RATE_VERTEX = 0,
+    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
+    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
+} VkVertexInputRate;
+
+typedef enum VkPrimitiveTopology {
+    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
+    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
+    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
+    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
+    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
+    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
+    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
+} VkPrimitiveTopology;
+
+typedef enum VkPolygonMode {
+    VK_POLYGON_MODE_FILL = 0,
+    VK_POLYGON_MODE_LINE = 1,
+    VK_POLYGON_MODE_POINT = 2,
+    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
+    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkPolygonMode;
+
+typedef enum VkStencilOp {
+    VK_STENCIL_OP_KEEP = 0,
+    VK_STENCIL_OP_ZERO = 1,
+    VK_STENCIL_OP_REPLACE = 2,
+    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
+    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
+    VK_STENCIL_OP_INVERT = 5,
+    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
+    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
+    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
+} VkStencilOp;
+
+typedef enum VkLogicOp {
+    VK_LOGIC_OP_CLEAR = 0,
+    VK_LOGIC_OP_AND = 1,
+    VK_LOGIC_OP_AND_REVERSE = 2,
+    VK_LOGIC_OP_COPY = 3,
+    VK_LOGIC_OP_AND_INVERTED = 4,
+    VK_LOGIC_OP_NO_OP = 5,
+    VK_LOGIC_OP_XOR = 6,
+    VK_LOGIC_OP_OR = 7,
+    VK_LOGIC_OP_NOR = 8,
+    VK_LOGIC_OP_EQUIVALENT = 9,
+    VK_LOGIC_OP_INVERT = 10,
+    VK_LOGIC_OP_OR_REVERSE = 11,
+    VK_LOGIC_OP_COPY_INVERTED = 12,
+    VK_LOGIC_OP_OR_INVERTED = 13,
+    VK_LOGIC_OP_NAND = 14,
+    VK_LOGIC_OP_SET = 15,
+    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
+} VkLogicOp;
+
+typedef enum VkBorderColor {
+    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
+    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
+    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
+    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
+    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
+    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
+    VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003,
+    VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004,
+    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
+} VkBorderColor;
+
+typedef enum VkFilter {
+    VK_FILTER_NEAREST = 0,
+    VK_FILTER_LINEAR = 1,
+    VK_FILTER_CUBIC_IMG = 1000015000,
+    VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
+    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
+} VkFilter;
+
+typedef enum VkSamplerAddressMode {
+    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
+    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
+    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
+    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
+    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
+    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
+    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerAddressMode;
+
+typedef enum VkSamplerMipmapMode {
+    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
+    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
+    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerMipmapMode;
+
+typedef enum VkDescriptorType {
+    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
+    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
+    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
+    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
+    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
+    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
+    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
+    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
+    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
+    VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
+    VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
+    VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
+    VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000,
+    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorType;
+
+typedef enum VkAttachmentLoadOp {
+    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
+    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
+    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
+    VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentLoadOp;
+
+typedef enum VkAttachmentStoreOp {
+    VK_ATTACHMENT_STORE_OP_STORE = 0,
+    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
+    VK_ATTACHMENT_STORE_OP_NONE_EXT = 1000301000,
+    VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE_EXT,
+    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentStoreOp;
+
+typedef enum VkPipelineBindPoint {
+    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
+    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
+    VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
+    VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,
+    VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
+    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineBindPoint;
+
+typedef enum VkCommandBufferLevel {
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferLevel;
+
+typedef enum VkIndexType {
+    VK_INDEX_TYPE_UINT16 = 0,
+    VK_INDEX_TYPE_UINT32 = 1,
+    VK_INDEX_TYPE_NONE_KHR = 1000165000,
+    VK_INDEX_TYPE_UINT8_EXT = 1000265000,
+    VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
+    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkIndexType;
+
+typedef enum VkSubpassContents {
+    VK_SUBPASS_CONTENTS_INLINE = 0,
+    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+} VkSubpassContents;
+
+typedef enum VkAccessFlagBits {
+    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
+    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
+    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
+    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
+    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
+    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
+    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
+    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
+    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
+    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
+    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
+    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
+    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
+    VK_ACCESS_HOST_READ_BIT = 0x00002000,
+    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
+    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
+    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+    VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
+    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
+    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
+    VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
+    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
+    VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000,
+    VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000,
+    VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
+    VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000,
+    VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000,
+    VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000,
+    VK_ACCESS_NONE_KHR = 0,
+    VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
+    VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
+    VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
+    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkAccessFlagBits;
+typedef VkFlags VkAccessFlags;
+
+typedef enum VkImageAspectFlagBits {
+    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+    VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
+    VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
+    VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
+    VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
+    VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
+    VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
+    VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
+    VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
+    VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
+    VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
+    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageAspectFlagBits;
+typedef VkFlags VkImageAspectFlags;
+
+typedef enum VkFormatFeatureFlagBits {
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
+    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
+    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
+    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
+    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
+    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
+    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
+    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
+    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
+    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
+    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
+    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
+    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
+    VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
+    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
+    VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
+    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000,
+#endif
+    VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000,
+    VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
+    VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
+#endif
+    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
+    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+    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,
+    VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
+    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
+    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFormatFeatureFlagBits;
+typedef VkFlags VkFormatFeatureFlags;
+
+typedef enum VkImageCreateFlagBits {
+    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
+    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
+    VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
+    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
+    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
+    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
+    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
+    VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
+    VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
+    VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
+    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
+    VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
+    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+    VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
+    VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
+    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageCreateFlagBits;
+typedef VkFlags VkImageCreateFlags;
+
+typedef enum VkSampleCountFlagBits {
+    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
+    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
+    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
+    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
+    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
+    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
+    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
+    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSampleCountFlagBits;
+typedef VkFlags VkSampleCountFlags;
+
+typedef enum VkImageUsageFlagBits {
+    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
+    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
+    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
+    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
+    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
+    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000,
+#endif
+    VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
+    VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,
+#endif
+    VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000,
+    VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
+    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageUsageFlagBits;
+typedef VkFlags VkImageUsageFlags;
+typedef VkFlags VkInstanceCreateFlags;
+
+typedef enum VkMemoryHeapFlagBits {
+    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
+    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
+    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryHeapFlagBits;
+typedef VkFlags VkMemoryHeapFlags;
+
+typedef enum VkMemoryPropertyFlagBits {
+    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
+    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
+    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
+    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
+    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
+    VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
+    VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
+    VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
+    VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100,
+    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryPropertyFlagBits;
+typedef VkFlags VkMemoryPropertyFlags;
+
+typedef enum VkQueueFlagBits {
+    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
+    VK_QUEUE_COMPUTE_BIT = 0x00000002,
+    VK_QUEUE_TRANSFER_BIT = 0x00000004,
+    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
+    VK_QUEUE_PROTECTED_BIT = 0x00000010,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,
+#endif
+    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueueFlagBits;
+typedef VkFlags VkQueueFlags;
+typedef VkFlags VkDeviceCreateFlags;
+
+typedef enum VkDeviceQueueCreateFlagBits {
+    VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
+    VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDeviceQueueCreateFlagBits;
+typedef VkFlags VkDeviceQueueCreateFlags;
+
+typedef enum VkPipelineStageFlagBits {
+    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
+    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
+    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
+    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
+    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
+    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
+    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
+    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
+    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
+    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+    VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
+    VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
+    VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,
+    VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000,
+    VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
+    VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
+    VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
+    VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000,
+    VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000,
+    VK_PIPELINE_STAGE_NONE_KHR = 0,
+    VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
+    VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
+    VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineStageFlagBits;
+typedef VkFlags VkPipelineStageFlags;
+typedef VkFlags VkMemoryMapFlags;
+
+typedef enum VkSparseMemoryBindFlagBits {
+    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
+    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSparseMemoryBindFlagBits;
+typedef VkFlags VkSparseMemoryBindFlags;
+
+typedef enum VkSparseImageFormatFlagBits {
+    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
+    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSparseImageFormatFlagBits;
+typedef VkFlags VkSparseImageFormatFlags;
+
+typedef enum VkFenceCreateFlagBits {
+    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
+    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFenceCreateFlagBits;
+typedef VkFlags VkFenceCreateFlags;
+typedef VkFlags VkSemaphoreCreateFlags;
+
+typedef enum VkEventCreateFlagBits {
+    VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = 0x00000001,
+    VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkEventCreateFlagBits;
+typedef VkFlags VkEventCreateFlags;
+
+typedef enum VkQueryPipelineStatisticFlagBits {
+    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
+    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
+    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
+    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
+    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
+    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
+    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
+    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
+    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
+    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
+    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
+    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryPipelineStatisticFlagBits;
+typedef VkFlags VkQueryPipelineStatisticFlags;
+typedef VkFlags VkQueryPoolCreateFlags;
+
+typedef enum VkQueryResultFlagBits {
+    VK_QUERY_RESULT_64_BIT = 0x00000001,
+    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
+    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
+    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010,
+#endif
+    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryResultFlagBits;
+typedef VkFlags VkQueryResultFlags;
+
+typedef enum VkBufferCreateFlagBits {
+    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+    VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
+    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
+    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
+    VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
+    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkBufferCreateFlagBits;
+typedef VkFlags VkBufferCreateFlags;
+
+typedef enum VkBufferUsageFlagBits {
+    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
+    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
+    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
+    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
+    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
+    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000,
+#endif
+    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
+    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
+    VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
+    VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
+    VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
+    VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,
+#endif
+    VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
+    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkBufferUsageFlagBits;
+typedef VkFlags VkBufferUsageFlags;
+typedef VkFlags VkBufferViewCreateFlags;
+
+typedef enum VkImageViewCreateFlagBits {
+    VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
+    VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002,
+    VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageViewCreateFlagBits;
+typedef VkFlags VkImageViewCreateFlags;
+
+typedef enum VkShaderModuleCreateFlagBits {
+    VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderModuleCreateFlagBits;
+typedef VkFlags VkShaderModuleCreateFlags;
+
+typedef enum VkPipelineCacheCreateFlagBits {
+    VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = 0x00000001,
+    VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCacheCreateFlagBits;
+typedef VkFlags VkPipelineCacheCreateFlags;
+
+typedef enum VkColorComponentFlagBits {
+    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
+    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
+    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
+    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
+    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkColorComponentFlagBits;
+typedef VkFlags VkColorComponentFlags;
+
+typedef enum VkPipelineCreateFlagBits {
+    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
+    VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
+    VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000,
+    VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000,
+    VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000,
+    VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000,
+    VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000,
+    VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000,
+    VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000,
+    VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+    VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+    VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
+    VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000,
+    VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800,
+    VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = 0x00000100,
+    VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = 0x00000200,
+    VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000,
+    VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
+    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+    VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
+    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCreateFlagBits;
+typedef VkFlags VkPipelineCreateFlags;
+
+typedef enum VkPipelineShaderStageCreateFlagBits {
+    VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
+    VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
+    VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineShaderStageCreateFlagBits;
+typedef VkFlags VkPipelineShaderStageCreateFlags;
+
+typedef enum VkShaderStageFlagBits {
+    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
+    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+    VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,
+    VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,
+    VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,
+    VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,
+    VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,
+    VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
+    VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
+    VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
+    VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,
+    VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
+    VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
+    VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
+    VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,
+    VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
+    VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
+    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderStageFlagBits;
+
+typedef enum VkCullModeFlagBits {
+    VK_CULL_MODE_NONE = 0,
+    VK_CULL_MODE_FRONT_BIT = 0x00000001,
+    VK_CULL_MODE_BACK_BIT = 0x00000002,
+    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCullModeFlagBits;
+typedef VkFlags VkCullModeFlags;
+typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+typedef VkFlags VkPipelineTessellationStateCreateFlags;
+typedef VkFlags VkPipelineViewportStateCreateFlags;
+typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+typedef VkFlags VkPipelineDynamicStateCreateFlags;
+typedef VkFlags VkPipelineLayoutCreateFlags;
+typedef VkFlags VkShaderStageFlags;
+
+typedef enum VkSamplerCreateFlagBits {
+    VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
+    VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
+    VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerCreateFlagBits;
+typedef VkFlags VkSamplerCreateFlags;
+
+typedef enum VkDescriptorPoolCreateFlagBits {
+    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
+    VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004,
+    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
+    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorPoolCreateFlagBits;
+typedef VkFlags VkDescriptorPoolCreateFlags;
+typedef VkFlags VkDescriptorPoolResetFlags;
+
+typedef enum VkDescriptorSetLayoutCreateFlagBits {
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorSetLayoutCreateFlagBits;
+typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+
+typedef enum VkAttachmentDescriptionFlagBits {
+    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentDescriptionFlagBits;
+typedef VkFlags VkAttachmentDescriptionFlags;
+
+typedef enum VkDependencyFlagBits {
+    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+    VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
+    VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
+    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
+    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDependencyFlagBits;
+typedef VkFlags VkDependencyFlags;
+
+typedef enum VkFramebufferCreateFlagBits {
+    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
+    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
+    VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFramebufferCreateFlagBits;
+typedef VkFlags VkFramebufferCreateFlags;
+
+typedef enum VkRenderPassCreateFlagBits {
+    VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002,
+    VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkRenderPassCreateFlagBits;
+typedef VkFlags VkRenderPassCreateFlags;
+
+typedef enum VkSubpassDescriptionFlagBits {
+    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
+    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
+    VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,
+    VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,
+    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSubpassDescriptionFlagBits;
+typedef VkFlags VkSubpassDescriptionFlags;
+
+typedef enum VkCommandPoolCreateFlagBits {
+    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+    VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
+    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandPoolCreateFlagBits;
+typedef VkFlags VkCommandPoolCreateFlags;
+
+typedef enum VkCommandPoolResetFlagBits {
+    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandPoolResetFlagBits;
+typedef VkFlags VkCommandPoolResetFlags;
+
+typedef enum VkCommandBufferUsageFlagBits {
+    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferUsageFlagBits;
+typedef VkFlags VkCommandBufferUsageFlags;
+
+typedef enum VkQueryControlFlagBits {
+    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryControlFlagBits;
+typedef VkFlags VkQueryControlFlags;
+
+typedef enum VkCommandBufferResetFlagBits {
+    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferResetFlagBits;
+typedef VkFlags VkCommandBufferResetFlags;
+
+typedef enum VkStencilFaceFlagBits {
+    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
+    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
+    VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
+    VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
+    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkStencilFaceFlagBits;
+typedef VkFlags VkStencilFaceFlags;
+typedef struct VkExtent2D {
+    uint32_t    width;
+    uint32_t    height;
+} VkExtent2D;
+
+typedef struct VkExtent3D {
+    uint32_t    width;
+    uint32_t    height;
+    uint32_t    depth;
+} VkExtent3D;
+
+typedef struct VkOffset2D {
+    int32_t    x;
+    int32_t    y;
+} VkOffset2D;
+
+typedef struct VkOffset3D {
+    int32_t    x;
+    int32_t    y;
+    int32_t    z;
+} VkOffset3D;
+
+typedef struct VkRect2D {
+    VkOffset2D    offset;
+    VkExtent2D    extent;
+} VkRect2D;
+
+typedef struct VkBaseInStructure {
+    VkStructureType                    sType;
+    const struct VkBaseInStructure*    pNext;
+} VkBaseInStructure;
+
+typedef struct VkBaseOutStructure {
+    VkStructureType               sType;
+    struct VkBaseOutStructure*    pNext;
+} VkBaseOutStructure;
+
+typedef struct VkBufferMemoryBarrier {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkAccessFlags      srcAccessMask;
+    VkAccessFlags      dstAccessMask;
+    uint32_t           srcQueueFamilyIndex;
+    uint32_t           dstQueueFamilyIndex;
+    VkBuffer           buffer;
+    VkDeviceSize       offset;
+    VkDeviceSize       size;
+} VkBufferMemoryBarrier;
+
+typedef struct VkDispatchIndirectCommand {
+    uint32_t    x;
+    uint32_t    y;
+    uint32_t    z;
+} VkDispatchIndirectCommand;
+
+typedef struct VkDrawIndexedIndirectCommand {
+    uint32_t    indexCount;
+    uint32_t    instanceCount;
+    uint32_t    firstIndex;
+    int32_t     vertexOffset;
+    uint32_t    firstInstance;
+} VkDrawIndexedIndirectCommand;
+
+typedef struct VkDrawIndirectCommand {
+    uint32_t    vertexCount;
+    uint32_t    instanceCount;
+    uint32_t    firstVertex;
+    uint32_t    firstInstance;
+} VkDrawIndirectCommand;
+
+typedef struct VkImageSubresourceRange {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              baseMipLevel;
+    uint32_t              levelCount;
+    uint32_t              baseArrayLayer;
+    uint32_t              layerCount;
+} VkImageSubresourceRange;
+
+typedef struct VkImageMemoryBarrier {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkAccessFlags              srcAccessMask;
+    VkAccessFlags              dstAccessMask;
+    VkImageLayout              oldLayout;
+    VkImageLayout              newLayout;
+    uint32_t                   srcQueueFamilyIndex;
+    uint32_t                   dstQueueFamilyIndex;
+    VkImage                    image;
+    VkImageSubresourceRange    subresourceRange;
+} VkImageMemoryBarrier;
+
+typedef struct VkMemoryBarrier {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkAccessFlags      srcAccessMask;
+    VkAccessFlags      dstAccessMask;
+} VkMemoryBarrier;
+
+typedef struct VkPipelineCacheHeaderVersionOne {
+    uint32_t                        headerSize;
+    VkPipelineCacheHeaderVersion    headerVersion;
+    uint32_t                        vendorID;
+    uint32_t                        deviceID;
+    uint8_t                         pipelineCacheUUID[VK_UUID_SIZE];
+} VkPipelineCacheHeaderVersionOne;
+
+typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
+    void*                                       pUserData,
+    size_t                                      size,
+    size_t                                      alignment,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
+    void*                                       pUserData,
+    void*                                       pMemory);
+
+typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
+    void*                                       pUserData,
+    size_t                                      size,
+    VkInternalAllocationType                    allocationType,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
+    void*                                       pUserData,
+    size_t                                      size,
+    VkInternalAllocationType                    allocationType,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
+    void*                                       pUserData,
+    void*                                       pOriginal,
+    size_t                                      size,
+    size_t                                      alignment,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
+typedef struct VkAllocationCallbacks {
+    void*                                   pUserData;
+    PFN_vkAllocationFunction                pfnAllocation;
+    PFN_vkReallocationFunction              pfnReallocation;
+    PFN_vkFreeFunction                      pfnFree;
+    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
+    PFN_vkInternalFreeNotification          pfnInternalFree;
+} VkAllocationCallbacks;
+
+typedef struct VkApplicationInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pApplicationName;
+    uint32_t           applicationVersion;
+    const char*        pEngineName;
+    uint32_t           engineVersion;
+    uint32_t           apiVersion;
+} VkApplicationInfo;
+
+typedef struct VkFormatProperties {
+    VkFormatFeatureFlags    linearTilingFeatures;
+    VkFormatFeatureFlags    optimalTilingFeatures;
+    VkFormatFeatureFlags    bufferFeatures;
+} VkFormatProperties;
+
+typedef struct VkImageFormatProperties {
+    VkExtent3D            maxExtent;
+    uint32_t              maxMipLevels;
+    uint32_t              maxArrayLayers;
+    VkSampleCountFlags    sampleCounts;
+    VkDeviceSize          maxResourceSize;
+} VkImageFormatProperties;
+
+typedef struct VkInstanceCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkInstanceCreateFlags       flags;
+    const VkApplicationInfo*    pApplicationInfo;
+    uint32_t                    enabledLayerCount;
+    const char* const*          ppEnabledLayerNames;
+    uint32_t                    enabledExtensionCount;
+    const char* const*          ppEnabledExtensionNames;
+} VkInstanceCreateInfo;
+
+typedef struct VkMemoryHeap {
+    VkDeviceSize         size;
+    VkMemoryHeapFlags    flags;
+} VkMemoryHeap;
+
+typedef struct VkMemoryType {
+    VkMemoryPropertyFlags    propertyFlags;
+    uint32_t                 heapIndex;
+} VkMemoryType;
+
+typedef struct VkPhysicalDeviceFeatures {
+    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;
+} VkPhysicalDeviceFeatures;
+
+typedef struct VkPhysicalDeviceLimits {
+    uint32_t              maxImageDimension1D;
+    uint32_t              maxImageDimension2D;
+    uint32_t              maxImageDimension3D;
+    uint32_t              maxImageDimensionCube;
+    uint32_t              maxImageArrayLayers;
+    uint32_t              maxTexelBufferElements;
+    uint32_t              maxUniformBufferRange;
+    uint32_t              maxStorageBufferRange;
+    uint32_t              maxPushConstantsSize;
+    uint32_t              maxMemoryAllocationCount;
+    uint32_t              maxSamplerAllocationCount;
+    VkDeviceSize          bufferImageGranularity;
+    VkDeviceSize          sparseAddressSpaceSize;
+    uint32_t              maxBoundDescriptorSets;
+    uint32_t              maxPerStageDescriptorSamplers;
+    uint32_t              maxPerStageDescriptorUniformBuffers;
+    uint32_t              maxPerStageDescriptorStorageBuffers;
+    uint32_t              maxPerStageDescriptorSampledImages;
+    uint32_t              maxPerStageDescriptorStorageImages;
+    uint32_t              maxPerStageDescriptorInputAttachments;
+    uint32_t              maxPerStageResources;
+    uint32_t              maxDescriptorSetSamplers;
+    uint32_t              maxDescriptorSetUniformBuffers;
+    uint32_t              maxDescriptorSetUniformBuffersDynamic;
+    uint32_t              maxDescriptorSetStorageBuffers;
+    uint32_t              maxDescriptorSetStorageBuffersDynamic;
+    uint32_t              maxDescriptorSetSampledImages;
+    uint32_t              maxDescriptorSetStorageImages;
+    uint32_t              maxDescriptorSetInputAttachments;
+    uint32_t              maxVertexInputAttributes;
+    uint32_t              maxVertexInputBindings;
+    uint32_t              maxVertexInputAttributeOffset;
+    uint32_t              maxVertexInputBindingStride;
+    uint32_t              maxVertexOutputComponents;
+    uint32_t              maxTessellationGenerationLevel;
+    uint32_t              maxTessellationPatchSize;
+    uint32_t              maxTessellationControlPerVertexInputComponents;
+    uint32_t              maxTessellationControlPerVertexOutputComponents;
+    uint32_t              maxTessellationControlPerPatchOutputComponents;
+    uint32_t              maxTessellationControlTotalOutputComponents;
+    uint32_t              maxTessellationEvaluationInputComponents;
+    uint32_t              maxTessellationEvaluationOutputComponents;
+    uint32_t              maxGeometryShaderInvocations;
+    uint32_t              maxGeometryInputComponents;
+    uint32_t              maxGeometryOutputComponents;
+    uint32_t              maxGeometryOutputVertices;
+    uint32_t              maxGeometryTotalOutputComponents;
+    uint32_t              maxFragmentInputComponents;
+    uint32_t              maxFragmentOutputAttachments;
+    uint32_t              maxFragmentDualSrcAttachments;
+    uint32_t              maxFragmentCombinedOutputResources;
+    uint32_t              maxComputeSharedMemorySize;
+    uint32_t              maxComputeWorkGroupCount[3];
+    uint32_t              maxComputeWorkGroupInvocations;
+    uint32_t              maxComputeWorkGroupSize[3];
+    uint32_t              subPixelPrecisionBits;
+    uint32_t              subTexelPrecisionBits;
+    uint32_t              mipmapPrecisionBits;
+    uint32_t              maxDrawIndexedIndexValue;
+    uint32_t              maxDrawIndirectCount;
+    float                 maxSamplerLodBias;
+    float                 maxSamplerAnisotropy;
+    uint32_t              maxViewports;
+    uint32_t              maxViewportDimensions[2];
+    float                 viewportBoundsRange[2];
+    uint32_t              viewportSubPixelBits;
+    size_t                minMemoryMapAlignment;
+    VkDeviceSize          minTexelBufferOffsetAlignment;
+    VkDeviceSize          minUniformBufferOffsetAlignment;
+    VkDeviceSize          minStorageBufferOffsetAlignment;
+    int32_t               minTexelOffset;
+    uint32_t              maxTexelOffset;
+    int32_t               minTexelGatherOffset;
+    uint32_t              maxTexelGatherOffset;
+    float                 minInterpolationOffset;
+    float                 maxInterpolationOffset;
+    uint32_t              subPixelInterpolationOffsetBits;
+    uint32_t              maxFramebufferWidth;
+    uint32_t              maxFramebufferHeight;
+    uint32_t              maxFramebufferLayers;
+    VkSampleCountFlags    framebufferColorSampleCounts;
+    VkSampleCountFlags    framebufferDepthSampleCounts;
+    VkSampleCountFlags    framebufferStencilSampleCounts;
+    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
+    uint32_t              maxColorAttachments;
+    VkSampleCountFlags    sampledImageColorSampleCounts;
+    VkSampleCountFlags    sampledImageIntegerSampleCounts;
+    VkSampleCountFlags    sampledImageDepthSampleCounts;
+    VkSampleCountFlags    sampledImageStencilSampleCounts;
+    VkSampleCountFlags    storageImageSampleCounts;
+    uint32_t              maxSampleMaskWords;
+    VkBool32              timestampComputeAndGraphics;
+    float                 timestampPeriod;
+    uint32_t              maxClipDistances;
+    uint32_t              maxCullDistances;
+    uint32_t              maxCombinedClipAndCullDistances;
+    uint32_t              discreteQueuePriorities;
+    float                 pointSizeRange[2];
+    float                 lineWidthRange[2];
+    float                 pointSizeGranularity;
+    float                 lineWidthGranularity;
+    VkBool32              strictLines;
+    VkBool32              standardSampleLocations;
+    VkDeviceSize          optimalBufferCopyOffsetAlignment;
+    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
+    VkDeviceSize          nonCoherentAtomSize;
+} VkPhysicalDeviceLimits;
+
+typedef struct VkPhysicalDeviceMemoryProperties {
+    uint32_t        memoryTypeCount;
+    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
+    uint32_t        memoryHeapCount;
+    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryProperties;
+
+typedef struct VkPhysicalDeviceSparseProperties {
+    VkBool32    residencyStandard2DBlockShape;
+    VkBool32    residencyStandard2DMultisampleBlockShape;
+    VkBool32    residencyStandard3DBlockShape;
+    VkBool32    residencyAlignedMipSize;
+    VkBool32    residencyNonResidentStrict;
+} VkPhysicalDeviceSparseProperties;
+
+typedef struct VkPhysicalDeviceProperties {
+    uint32_t                            apiVersion;
+    uint32_t                            driverVersion;
+    uint32_t                            vendorID;
+    uint32_t                            deviceID;
+    VkPhysicalDeviceType                deviceType;
+    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
+    VkPhysicalDeviceLimits              limits;
+    VkPhysicalDeviceSparseProperties    sparseProperties;
+} VkPhysicalDeviceProperties;
+
+typedef struct VkQueueFamilyProperties {
+    VkQueueFlags    queueFlags;
+    uint32_t        queueCount;
+    uint32_t        timestampValidBits;
+    VkExtent3D      minImageTransferGranularity;
+} VkQueueFamilyProperties;
+
+typedef struct VkDeviceQueueCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkDeviceQueueCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+    uint32_t                    queueCount;
+    const float*                pQueuePriorities;
+} VkDeviceQueueCreateInfo;
+
+typedef struct VkDeviceCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkDeviceCreateFlags                flags;
+    uint32_t                           queueCreateInfoCount;
+    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
+    uint32_t                           enabledLayerCount;
+    const char* const*                 ppEnabledLayerNames;
+    uint32_t                           enabledExtensionCount;
+    const char* const*                 ppEnabledExtensionNames;
+    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
+} VkDeviceCreateInfo;
+
+typedef struct VkExtensionProperties {
+    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t    specVersion;
+} VkExtensionProperties;
+
+typedef struct VkLayerProperties {
+    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t    specVersion;
+    uint32_t    implementationVersion;
+    char        description[VK_MAX_DESCRIPTION_SIZE];
+} VkLayerProperties;
+
+typedef struct VkSubmitInfo {
+    VkStructureType                sType;
+    const void*                    pNext;
+    uint32_t                       waitSemaphoreCount;
+    const VkSemaphore*             pWaitSemaphores;
+    const VkPipelineStageFlags*    pWaitDstStageMask;
+    uint32_t                       commandBufferCount;
+    const VkCommandBuffer*         pCommandBuffers;
+    uint32_t                       signalSemaphoreCount;
+    const VkSemaphore*             pSignalSemaphores;
+} VkSubmitInfo;
+
+typedef struct VkMappedMemoryRange {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+    VkDeviceSize       offset;
+    VkDeviceSize       size;
+} VkMappedMemoryRange;
+
+typedef struct VkMemoryAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeIndex;
+} VkMemoryAllocateInfo;
+
+typedef struct VkMemoryRequirements {
+    VkDeviceSize    size;
+    VkDeviceSize    alignment;
+    uint32_t        memoryTypeBits;
+} VkMemoryRequirements;
+
+typedef struct VkSparseMemoryBind {
+    VkDeviceSize               resourceOffset;
+    VkDeviceSize               size;
+    VkDeviceMemory             memory;
+    VkDeviceSize               memoryOffset;
+    VkSparseMemoryBindFlags    flags;
+} VkSparseMemoryBind;
+
+typedef struct VkSparseBufferMemoryBindInfo {
+    VkBuffer                     buffer;
+    uint32_t                     bindCount;
+    const VkSparseMemoryBind*    pBinds;
+} VkSparseBufferMemoryBindInfo;
+
+typedef struct VkSparseImageOpaqueMemoryBindInfo {
+    VkImage                      image;
+    uint32_t                     bindCount;
+    const VkSparseMemoryBind*    pBinds;
+} VkSparseImageOpaqueMemoryBindInfo;
+
+typedef struct VkImageSubresource {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              mipLevel;
+    uint32_t              arrayLayer;
+} VkImageSubresource;
+
+typedef struct VkSparseImageMemoryBind {
+    VkImageSubresource         subresource;
+    VkOffset3D                 offset;
+    VkExtent3D                 extent;
+    VkDeviceMemory             memory;
+    VkDeviceSize               memoryOffset;
+    VkSparseMemoryBindFlags    flags;
+} VkSparseImageMemoryBind;
+
+typedef struct VkSparseImageMemoryBindInfo {
+    VkImage                           image;
+    uint32_t                          bindCount;
+    const VkSparseImageMemoryBind*    pBinds;
+} VkSparseImageMemoryBindInfo;
+
+typedef struct VkBindSparseInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    waitSemaphoreCount;
+    const VkSemaphore*                          pWaitSemaphores;
+    uint32_t                                    bufferBindCount;
+    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
+    uint32_t                                    imageOpaqueBindCount;
+    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
+    uint32_t                                    imageBindCount;
+    const VkSparseImageMemoryBindInfo*          pImageBinds;
+    uint32_t                                    signalSemaphoreCount;
+    const VkSemaphore*                          pSignalSemaphores;
+} VkBindSparseInfo;
+
+typedef struct VkSparseImageFormatProperties {
+    VkImageAspectFlags          aspectMask;
+    VkExtent3D                  imageGranularity;
+    VkSparseImageFormatFlags    flags;
+} VkSparseImageFormatProperties;
+
+typedef struct VkSparseImageMemoryRequirements {
+    VkSparseImageFormatProperties    formatProperties;
+    uint32_t                         imageMipTailFirstLod;
+    VkDeviceSize                     imageMipTailSize;
+    VkDeviceSize                     imageMipTailOffset;
+    VkDeviceSize                     imageMipTailStride;
+} VkSparseImageMemoryRequirements;
+
+typedef struct VkFenceCreateInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkFenceCreateFlags    flags;
+} VkFenceCreateInfo;
+
+typedef struct VkSemaphoreCreateInfo {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkSemaphoreCreateFlags    flags;
+} VkSemaphoreCreateInfo;
+
+typedef struct VkEventCreateInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkEventCreateFlags    flags;
+} VkEventCreateInfo;
+
+typedef struct VkQueryPoolCreateInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkQueryPoolCreateFlags           flags;
+    VkQueryType                      queryType;
+    uint32_t                         queryCount;
+    VkQueryPipelineStatisticFlags    pipelineStatistics;
+} VkQueryPoolCreateInfo;
+
+typedef struct VkBufferCreateInfo {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkBufferCreateFlags    flags;
+    VkDeviceSize           size;
+    VkBufferUsageFlags     usage;
+    VkSharingMode          sharingMode;
+    uint32_t               queueFamilyIndexCount;
+    const uint32_t*        pQueueFamilyIndices;
+} VkBufferCreateInfo;
+
+typedef struct VkBufferViewCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkBufferViewCreateFlags    flags;
+    VkBuffer                   buffer;
+    VkFormat                   format;
+    VkDeviceSize               offset;
+    VkDeviceSize               range;
+} VkBufferViewCreateInfo;
+
+typedef struct VkImageCreateInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageCreateFlags       flags;
+    VkImageType              imageType;
+    VkFormat                 format;
+    VkExtent3D               extent;
+    uint32_t                 mipLevels;
+    uint32_t                 arrayLayers;
+    VkSampleCountFlagBits    samples;
+    VkImageTiling            tiling;
+    VkImageUsageFlags        usage;
+    VkSharingMode            sharingMode;
+    uint32_t                 queueFamilyIndexCount;
+    const uint32_t*          pQueueFamilyIndices;
+    VkImageLayout            initialLayout;
+} VkImageCreateInfo;
+
+typedef struct VkSubresourceLayout {
+    VkDeviceSize    offset;
+    VkDeviceSize    size;
+    VkDeviceSize    rowPitch;
+    VkDeviceSize    arrayPitch;
+    VkDeviceSize    depthPitch;
+} VkSubresourceLayout;
+
+typedef struct VkComponentMapping {
+    VkComponentSwizzle    r;
+    VkComponentSwizzle    g;
+    VkComponentSwizzle    b;
+    VkComponentSwizzle    a;
+} VkComponentMapping;
+
+typedef struct VkImageViewCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkImageViewCreateFlags     flags;
+    VkImage                    image;
+    VkImageViewType            viewType;
+    VkFormat                   format;
+    VkComponentMapping         components;
+    VkImageSubresourceRange    subresourceRange;
+} VkImageViewCreateInfo;
+
+typedef struct VkShaderModuleCreateInfo {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkShaderModuleCreateFlags    flags;
+    size_t                       codeSize;
+    const uint32_t*              pCode;
+} VkShaderModuleCreateInfo;
+
+typedef struct VkPipelineCacheCreateInfo {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkPipelineCacheCreateFlags    flags;
+    size_t                        initialDataSize;
+    const void*                   pInitialData;
+} VkPipelineCacheCreateInfo;
+
+typedef struct VkSpecializationMapEntry {
+    uint32_t    constantID;
+    uint32_t    offset;
+    size_t      size;
+} VkSpecializationMapEntry;
+
+typedef struct VkSpecializationInfo {
+    uint32_t                           mapEntryCount;
+    const VkSpecializationMapEntry*    pMapEntries;
+    size_t                             dataSize;
+    const void*                        pData;
+} VkSpecializationInfo;
+
+typedef struct VkPipelineShaderStageCreateInfo {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkPipelineShaderStageCreateFlags    flags;
+    VkShaderStageFlagBits               stage;
+    VkShaderModule                      module;
+    const char*                         pName;
+    const VkSpecializationInfo*         pSpecializationInfo;
+} VkPipelineShaderStageCreateInfo;
+
+typedef struct VkComputePipelineCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkPipelineCreateFlags              flags;
+    VkPipelineShaderStageCreateInfo    stage;
+    VkPipelineLayout                   layout;
+    VkPipeline                         basePipelineHandle;
+    int32_t                            basePipelineIndex;
+} VkComputePipelineCreateInfo;
+
+typedef struct VkVertexInputBindingDescription {
+    uint32_t             binding;
+    uint32_t             stride;
+    VkVertexInputRate    inputRate;
+} VkVertexInputBindingDescription;
+
+typedef struct VkVertexInputAttributeDescription {
+    uint32_t    location;
+    uint32_t    binding;
+    VkFormat    format;
+    uint32_t    offset;
+} VkVertexInputAttributeDescription;
+
+typedef struct VkPipelineVertexInputStateCreateInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkPipelineVertexInputStateCreateFlags       flags;
+    uint32_t                                    vertexBindingDescriptionCount;
+    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
+    uint32_t                                    vertexAttributeDescriptionCount;
+    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
+} VkPipelineVertexInputStateCreateInfo;
+
+typedef struct VkPipelineInputAssemblyStateCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPipelineInputAssemblyStateCreateFlags    flags;
+    VkPrimitiveTopology                        topology;
+    VkBool32                                   primitiveRestartEnable;
+} VkPipelineInputAssemblyStateCreateInfo;
+
+typedef struct VkPipelineTessellationStateCreateInfo {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkPipelineTessellationStateCreateFlags    flags;
+    uint32_t                                  patchControlPoints;
+} VkPipelineTessellationStateCreateInfo;
+
+typedef struct VkViewport {
+    float    x;
+    float    y;
+    float    width;
+    float    height;
+    float    minDepth;
+    float    maxDepth;
+} VkViewport;
+
+typedef struct VkPipelineViewportStateCreateInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkPipelineViewportStateCreateFlags    flags;
+    uint32_t                              viewportCount;
+    const VkViewport*                     pViewports;
+    uint32_t                              scissorCount;
+    const VkRect2D*                       pScissors;
+} VkPipelineViewportStateCreateInfo;
+
+typedef struct VkPipelineRasterizationStateCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPipelineRasterizationStateCreateFlags    flags;
+    VkBool32                                   depthClampEnable;
+    VkBool32                                   rasterizerDiscardEnable;
+    VkPolygonMode                              polygonMode;
+    VkCullModeFlags                            cullMode;
+    VkFrontFace                                frontFace;
+    VkBool32                                   depthBiasEnable;
+    float                                      depthBiasConstantFactor;
+    float                                      depthBiasClamp;
+    float                                      depthBiasSlopeFactor;
+    float                                      lineWidth;
+} VkPipelineRasterizationStateCreateInfo;
+
+typedef struct VkPipelineMultisampleStateCreateInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkPipelineMultisampleStateCreateFlags    flags;
+    VkSampleCountFlagBits                    rasterizationSamples;
+    VkBool32                                 sampleShadingEnable;
+    float                                    minSampleShading;
+    const VkSampleMask*                      pSampleMask;
+    VkBool32                                 alphaToCoverageEnable;
+    VkBool32                                 alphaToOneEnable;
+} VkPipelineMultisampleStateCreateInfo;
+
+typedef struct VkStencilOpState {
+    VkStencilOp    failOp;
+    VkStencilOp    passOp;
+    VkStencilOp    depthFailOp;
+    VkCompareOp    compareOp;
+    uint32_t       compareMask;
+    uint32_t       writeMask;
+    uint32_t       reference;
+} VkStencilOpState;
+
+typedef struct VkPipelineDepthStencilStateCreateInfo {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkPipelineDepthStencilStateCreateFlags    flags;
+    VkBool32                                  depthTestEnable;
+    VkBool32                                  depthWriteEnable;
+    VkCompareOp                               depthCompareOp;
+    VkBool32                                  depthBoundsTestEnable;
+    VkBool32                                  stencilTestEnable;
+    VkStencilOpState                          front;
+    VkStencilOpState                          back;
+    float                                     minDepthBounds;
+    float                                     maxDepthBounds;
+} VkPipelineDepthStencilStateCreateInfo;
+
+typedef struct VkPipelineColorBlendAttachmentState {
+    VkBool32                 blendEnable;
+    VkBlendFactor            srcColorBlendFactor;
+    VkBlendFactor            dstColorBlendFactor;
+    VkBlendOp                colorBlendOp;
+    VkBlendFactor            srcAlphaBlendFactor;
+    VkBlendFactor            dstAlphaBlendFactor;
+    VkBlendOp                alphaBlendOp;
+    VkColorComponentFlags    colorWriteMask;
+} VkPipelineColorBlendAttachmentState;
+
+typedef struct VkPipelineColorBlendStateCreateInfo {
+    VkStructureType                               sType;
+    const void*                                   pNext;
+    VkPipelineColorBlendStateCreateFlags          flags;
+    VkBool32                                      logicOpEnable;
+    VkLogicOp                                     logicOp;
+    uint32_t                                      attachmentCount;
+    const VkPipelineColorBlendAttachmentState*    pAttachments;
+    float                                         blendConstants[4];
+} VkPipelineColorBlendStateCreateInfo;
+
+typedef struct VkPipelineDynamicStateCreateInfo {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkPipelineDynamicStateCreateFlags    flags;
+    uint32_t                             dynamicStateCount;
+    const VkDynamicState*                pDynamicStates;
+} VkPipelineDynamicStateCreateInfo;
+
+typedef struct VkGraphicsPipelineCreateInfo {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    VkPipelineCreateFlags                            flags;
+    uint32_t                                         stageCount;
+    const VkPipelineShaderStageCreateInfo*           pStages;
+    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
+    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
+    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
+    const VkPipelineViewportStateCreateInfo*         pViewportState;
+    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
+    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
+    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
+    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
+    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
+    VkPipelineLayout                                 layout;
+    VkRenderPass                                     renderPass;
+    uint32_t                                         subpass;
+    VkPipeline                                       basePipelineHandle;
+    int32_t                                          basePipelineIndex;
+} VkGraphicsPipelineCreateInfo;
+
+typedef struct VkPushConstantRange {
+    VkShaderStageFlags    stageFlags;
+    uint32_t              offset;
+    uint32_t              size;
+} VkPushConstantRange;
+
+typedef struct VkPipelineLayoutCreateInfo {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkPipelineLayoutCreateFlags     flags;
+    uint32_t                        setLayoutCount;
+    const VkDescriptorSetLayout*    pSetLayouts;
+    uint32_t                        pushConstantRangeCount;
+    const VkPushConstantRange*      pPushConstantRanges;
+} VkPipelineLayoutCreateInfo;
+
+typedef struct VkSamplerCreateInfo {
+    VkStructureType         sType;
+    const 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;
+} VkSamplerCreateInfo;
+
+typedef struct VkCopyDescriptorSet {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDescriptorSet    srcSet;
+    uint32_t           srcBinding;
+    uint32_t           srcArrayElement;
+    VkDescriptorSet    dstSet;
+    uint32_t           dstBinding;
+    uint32_t           dstArrayElement;
+    uint32_t           descriptorCount;
+} VkCopyDescriptorSet;
+
+typedef struct VkDescriptorBufferInfo {
+    VkBuffer        buffer;
+    VkDeviceSize    offset;
+    VkDeviceSize    range;
+} VkDescriptorBufferInfo;
+
+typedef struct VkDescriptorImageInfo {
+    VkSampler        sampler;
+    VkImageView      imageView;
+    VkImageLayout    imageLayout;
+} VkDescriptorImageInfo;
+
+typedef struct VkDescriptorPoolSize {
+    VkDescriptorType    type;
+    uint32_t            descriptorCount;
+} VkDescriptorPoolSize;
+
+typedef struct VkDescriptorPoolCreateInfo {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkDescriptorPoolCreateFlags    flags;
+    uint32_t                       maxSets;
+    uint32_t                       poolSizeCount;
+    const VkDescriptorPoolSize*    pPoolSizes;
+} VkDescriptorPoolCreateInfo;
+
+typedef struct VkDescriptorSetAllocateInfo {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkDescriptorPool                descriptorPool;
+    uint32_t                        descriptorSetCount;
+    const VkDescriptorSetLayout*    pSetLayouts;
+} VkDescriptorSetAllocateInfo;
+
+typedef struct VkDescriptorSetLayoutBinding {
+    uint32_t              binding;
+    VkDescriptorType      descriptorType;
+    uint32_t              descriptorCount;
+    VkShaderStageFlags    stageFlags;
+    const VkSampler*      pImmutableSamplers;
+} VkDescriptorSetLayoutBinding;
+
+typedef struct VkDescriptorSetLayoutCreateInfo {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkDescriptorSetLayoutCreateFlags       flags;
+    uint32_t                               bindingCount;
+    const VkDescriptorSetLayoutBinding*    pBindings;
+} VkDescriptorSetLayoutCreateInfo;
+
+typedef struct VkWriteDescriptorSet {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkDescriptorSet                  dstSet;
+    uint32_t                         dstBinding;
+    uint32_t                         dstArrayElement;
+    uint32_t                         descriptorCount;
+    VkDescriptorType                 descriptorType;
+    const VkDescriptorImageInfo*     pImageInfo;
+    const VkDescriptorBufferInfo*    pBufferInfo;
+    const VkBufferView*              pTexelBufferView;
+} VkWriteDescriptorSet;
+
+typedef struct VkAttachmentDescription {
+    VkAttachmentDescriptionFlags    flags;
+    VkFormat                        format;
+    VkSampleCountFlagBits           samples;
+    VkAttachmentLoadOp              loadOp;
+    VkAttachmentStoreOp             storeOp;
+    VkAttachmentLoadOp              stencilLoadOp;
+    VkAttachmentStoreOp             stencilStoreOp;
+    VkImageLayout                   initialLayout;
+    VkImageLayout                   finalLayout;
+} VkAttachmentDescription;
+
+typedef struct VkAttachmentReference {
+    uint32_t         attachment;
+    VkImageLayout    layout;
+} VkAttachmentReference;
+
+typedef struct VkFramebufferCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkFramebufferCreateFlags    flags;
+    VkRenderPass                renderPass;
+    uint32_t                    attachmentCount;
+    const VkImageView*          pAttachments;
+    uint32_t                    width;
+    uint32_t                    height;
+    uint32_t                    layers;
+} VkFramebufferCreateInfo;
+
+typedef struct VkSubpassDescription {
+    VkSubpassDescriptionFlags       flags;
+    VkPipelineBindPoint             pipelineBindPoint;
+    uint32_t                        inputAttachmentCount;
+    const VkAttachmentReference*    pInputAttachments;
+    uint32_t                        colorAttachmentCount;
+    const VkAttachmentReference*    pColorAttachments;
+    const VkAttachmentReference*    pResolveAttachments;
+    const VkAttachmentReference*    pDepthStencilAttachment;
+    uint32_t                        preserveAttachmentCount;
+    const uint32_t*                 pPreserveAttachments;
+} VkSubpassDescription;
+
+typedef struct VkSubpassDependency {
+    uint32_t                srcSubpass;
+    uint32_t                dstSubpass;
+    VkPipelineStageFlags    srcStageMask;
+    VkPipelineStageFlags    dstStageMask;
+    VkAccessFlags           srcAccessMask;
+    VkAccessFlags           dstAccessMask;
+    VkDependencyFlags       dependencyFlags;
+} VkSubpassDependency;
+
+typedef struct VkRenderPassCreateInfo {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkRenderPassCreateFlags           flags;
+    uint32_t                          attachmentCount;
+    const VkAttachmentDescription*    pAttachments;
+    uint32_t                          subpassCount;
+    const VkSubpassDescription*       pSubpasses;
+    uint32_t                          dependencyCount;
+    const VkSubpassDependency*        pDependencies;
+} VkRenderPassCreateInfo;
+
+typedef struct VkCommandPoolCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkCommandPoolCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+} VkCommandPoolCreateInfo;
+
+typedef struct VkCommandBufferAllocateInfo {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkCommandPool           commandPool;
+    VkCommandBufferLevel    level;
+    uint32_t                commandBufferCount;
+} VkCommandBufferAllocateInfo;
+
+typedef struct VkCommandBufferInheritanceInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkRenderPass                     renderPass;
+    uint32_t                         subpass;
+    VkFramebuffer                    framebuffer;
+    VkBool32                         occlusionQueryEnable;
+    VkQueryControlFlags              queryFlags;
+    VkQueryPipelineStatisticFlags    pipelineStatistics;
+} VkCommandBufferInheritanceInfo;
+
+typedef struct VkCommandBufferBeginInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkCommandBufferUsageFlags                flags;
+    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
+} VkCommandBufferBeginInfo;
+
+typedef struct VkBufferCopy {
+    VkDeviceSize    srcOffset;
+    VkDeviceSize    dstOffset;
+    VkDeviceSize    size;
+} VkBufferCopy;
+
+typedef struct VkImageSubresourceLayers {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              mipLevel;
+    uint32_t              baseArrayLayer;
+    uint32_t              layerCount;
+} VkImageSubresourceLayers;
+
+typedef struct VkBufferImageCopy {
+    VkDeviceSize                bufferOffset;
+    uint32_t                    bufferRowLength;
+    uint32_t                    bufferImageHeight;
+    VkImageSubresourceLayers    imageSubresource;
+    VkOffset3D                  imageOffset;
+    VkExtent3D                  imageExtent;
+} VkBufferImageCopy;
+
+typedef union VkClearColorValue {
+    float       float32[4];
+    int32_t     int32[4];
+    uint32_t    uint32[4];
+} VkClearColorValue;
+
+typedef struct VkClearDepthStencilValue {
+    float       depth;
+    uint32_t    stencil;
+} VkClearDepthStencilValue;
+
+typedef union VkClearValue {
+    VkClearColorValue           color;
+    VkClearDepthStencilValue    depthStencil;
+} VkClearValue;
+
+typedef struct VkClearAttachment {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              colorAttachment;
+    VkClearValue          clearValue;
+} VkClearAttachment;
+
+typedef struct VkClearRect {
+    VkRect2D    rect;
+    uint32_t    baseArrayLayer;
+    uint32_t    layerCount;
+} VkClearRect;
+
+typedef struct VkImageBlit {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffsets[2];
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffsets[2];
+} VkImageBlit;
+
+typedef struct VkImageCopy {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageCopy;
+
+typedef struct VkImageResolve {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageResolve;
+
+typedef struct VkRenderPassBeginInfo {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkRenderPass           renderPass;
+    VkFramebuffer          framebuffer;
+    VkRect2D               renderArea;
+    uint32_t               clearValueCount;
+    const VkClearValue*    pClearValues;
+} VkRenderPassBeginInfo;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
+typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
+typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
+    const VkInstanceCreateInfo*                 pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkInstance*                                 pInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
+    VkInstance                                  instance,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceCount,
+    VkPhysicalDevice*                           pPhysicalDevices);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures*                   pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties*                         pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkImageTiling                               tiling,
+    VkImageUsageFlags                           usage,
+    VkImageCreateFlags                          flags,
+    VkImageFormatProperties*                    pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties*                 pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties*                    pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
+    VkInstance                                  instance,
+    const char*                                 pName);
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
+    VkDevice                                    device,
+    const char*                                 pName);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
+    VkPhysicalDevice                            physicalDevice,
+    const VkDeviceCreateInfo*                   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDevice*                                   pDevice);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
+    VkDevice                                    device,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
+    const char*                                 pLayerName,
+    uint32_t*                                   pPropertyCount,
+    VkExtensionProperties*                      pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const char*                                 pLayerName,
+    uint32_t*                                   pPropertyCount,
+    VkExtensionProperties*                      pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
+    uint32_t*                                   pPropertyCount,
+    VkLayerProperties*                          pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkLayerProperties*                          pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
+    VkDevice                                    device,
+    uint32_t                                    queueFamilyIndex,
+    uint32_t                                    queueIndex,
+    VkQueue*                                    pQueue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
+    VkQueue                                     queue,
+    uint32_t                                    submitCount,
+    const VkSubmitInfo*                         pSubmits,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
+    VkQueue                                     queue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
+    VkDevice                                    device);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
+    VkDevice                                    device,
+    const VkMemoryAllocateInfo*                 pAllocateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDeviceMemory*                             pMemory);
+
+VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                offset,
+    VkDeviceSize                                size,
+    VkMemoryMapFlags                            flags,
+    void**                                      ppData);
+
+VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
+    VkDevice                                    device,
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
+    VkDevice                                    device,
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkDeviceSize*                               pCommittedMemoryInBytes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                memoryOffset);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
+    VkDevice                                    device,
+    VkImage                                     image,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                memoryOffset);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    VkMemoryRequirements*                       pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    VkMemoryRequirements*                       pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkSampleCountFlagBits                       samples,
+    VkImageUsageFlags                           usage,
+    VkImageTiling                               tiling,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties*              pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
+    VkQueue                                     queue,
+    uint32_t                                    bindInfoCount,
+    const VkBindSparseInfo*                     pBindInfo,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
+    VkDevice                                    device,
+    const VkFenceCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
+    VkDevice                                    device,
+    VkFence                                     fence,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
+    VkDevice                                    device,
+    uint32_t                                    fenceCount,
+    const VkFence*                              pFences);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
+    VkDevice                                    device,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
+    VkDevice                                    device,
+    uint32_t                                    fenceCount,
+    const VkFence*                              pFences,
+    VkBool32                                    waitAll,
+    uint64_t                                    timeout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
+    VkDevice                                    device,
+    const VkSemaphoreCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSemaphore*                                pSemaphore);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
+    VkDevice                                    device,
+    VkSemaphore                                 semaphore,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
+    VkDevice                                    device,
+    const VkEventCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkEvent*                                    pEvent);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
+    VkDevice                                    device,
+    VkEvent                                     event,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
+    VkDevice                                    device,
+    const VkQueryPoolCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkQueryPool*                                pQueryPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount,
+    size_t                                      dataSize,
+    void*                                       pData,
+    VkDeviceSize                                stride,
+    VkQueryResultFlags                          flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
+    VkDevice                                    device,
+    const VkBufferCreateInfo*                   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBuffer*                                   pBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
+    VkDevice                                    device,
+    const VkBufferViewCreateInfo*               pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBufferView*                               pView);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
+    VkDevice                                    device,
+    VkBufferView                                bufferView,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
+    VkDevice                                    device,
+    const VkImageCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkImage*                                    pImage);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
+    VkDevice                                    device,
+    VkImage                                     image,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
+    VkDevice                                    device,
+    VkImage                                     image,
+    const VkImageSubresource*                   pSubresource,
+    VkSubresourceLayout*                        pLayout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
+    VkDevice                                    device,
+    const VkImageViewCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkImageView*                                pView);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
+    VkDevice                                    device,
+    VkImageView                                 imageView,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
+    VkDevice                                    device,
+    const VkShaderModuleCreateInfo*             pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkShaderModule*                             pShaderModule);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
+    VkDevice                                    device,
+    VkShaderModule                              shaderModule,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
+    VkDevice                                    device,
+    const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipelineCache*                            pPipelineCache);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    size_t*                                     pDataSize,
+    void*                                       pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
+    VkDevice                                    device,
+    VkPipelineCache                             dstCache,
+    uint32_t                                    srcCacheCount,
+    const VkPipelineCache*                      pSrcCaches);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkComputePipelineCreateInfo*          pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
+    VkDevice                                    device,
+    const VkPipelineLayoutCreateInfo*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipelineLayout*                           pPipelineLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
+    VkDevice                                    device,
+    VkPipelineLayout                            pipelineLayout,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
+    VkDevice                                    device,
+    const VkSamplerCreateInfo*                  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSampler*                                  pSampler);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
+    VkDevice                                    device,
+    VkSampler                                   sampler,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorSetLayout*                      pSetLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
+    VkDevice                                    device,
+    VkDescriptorSetLayout                       descriptorSetLayout,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
+    VkDevice                                    device,
+    const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorPool*                           pDescriptorPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    VkDescriptorPoolResetFlags                  flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
+    VkDevice                                    device,
+    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
+    VkDescriptorSet*                            pDescriptorSets);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    uint32_t                                    descriptorSetCount,
+    const VkDescriptorSet*                      pDescriptorSets);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
+    VkDevice                                    device,
+    uint32_t                                    descriptorWriteCount,
+    const VkWriteDescriptorSet*                 pDescriptorWrites,
+    uint32_t                                    descriptorCopyCount,
+    const VkCopyDescriptorSet*                  pDescriptorCopies);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
+    VkDevice                                    device,
+    const VkFramebufferCreateInfo*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFramebuffer*                              pFramebuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
+    VkDevice                                    device,
+    VkFramebuffer                               framebuffer,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
+    VkDevice                                    device,
+    const VkRenderPassCreateInfo*               pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkRenderPass*                               pRenderPass);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
+    VkDevice                                    device,
+    VkRenderPass                                renderPass,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
+    VkDevice                                    device,
+    VkRenderPass                                renderPass,
+    VkExtent2D*                                 pGranularity);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
+    VkDevice                                    device,
+    const VkCommandPoolCreateInfo*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCommandPool*                              pCommandPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolResetFlags                     flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
+    VkDevice                                    device,
+    const VkCommandBufferAllocateInfo*          pAllocateInfo,
+    VkCommandBuffer*                            pCommandBuffers);
+
+VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    uint32_t                                    commandBufferCount,
+    const VkCommandBuffer*                      pCommandBuffers);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
+    VkCommandBuffer                             commandBuffer,
+    const VkCommandBufferBeginInfo*             pBeginInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkCommandBufferResetFlags                   flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipeline                                  pipeline);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkViewport*                           pViewports);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstScissor,
+    uint32_t                                    scissorCount,
+    const VkRect2D*                             pScissors);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
+    VkCommandBuffer                             commandBuffer,
+    float                                       lineWidth);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
+    VkCommandBuffer                             commandBuffer,
+    float                                       depthBiasConstantFactor,
+    float                                       depthBiasClamp,
+    float                                       depthBiasSlopeFactor);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
+    VkCommandBuffer                             commandBuffer,
+    const float                                 blendConstants[4]);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
+    VkCommandBuffer                             commandBuffer,
+    float                                       minDepthBounds,
+    float                                       maxDepthBounds);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    compareMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    writeMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    reference);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipelineLayout                            layout,
+    uint32_t                                    firstSet,
+    uint32_t                                    descriptorSetCount,
+    const VkDescriptorSet*                      pDescriptorSets,
+    uint32_t                                    dynamicOffsetCount,
+    const uint32_t*                             pDynamicOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkIndexType                                 indexType);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkDeviceSize*                         pOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    vertexCount,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstVertex,
+    uint32_t                                    firstInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    indexCount,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstIndex,
+    int32_t                                     vertexOffset,
+    uint32_t                                    firstInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    srcBuffer,
+    VkBuffer                                    dstBuffer,
+    uint32_t                                    regionCount,
+    const VkBufferCopy*                         pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageCopy*                          pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageBlit*                          pRegions,
+    VkFilter                                    filter);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    srcBuffer,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkBufferImageCopy*                    pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkBuffer                                    dstBuffer,
+    uint32_t                                    regionCount,
+    const VkBufferImageCopy*                    pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                dataSize,
+    const void*                                 pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                size,
+    uint32_t                                    data);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     image,
+    VkImageLayout                               imageLayout,
+    const VkClearColorValue*                    pColor,
+    uint32_t                                    rangeCount,
+    const VkImageSubresourceRange*              pRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     image,
+    VkImageLayout                               imageLayout,
+    const VkClearDepthStencilValue*             pDepthStencil,
+    uint32_t                                    rangeCount,
+    const VkImageSubresourceRange*              pRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    attachmentCount,
+    const VkClearAttachment*                    pAttachments,
+    uint32_t                                    rectCount,
+    const VkClearRect*                          pRects);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageResolve*                       pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    VkPipelineStageFlags                        stageMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    VkPipelineStageFlags                        stageMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    eventCount,
+    const VkEvent*                              pEvents,
+    VkPipelineStageFlags                        srcStageMask,
+    VkPipelineStageFlags                        dstStageMask,
+    uint32_t                                    memoryBarrierCount,
+    const VkMemoryBarrier*                      pMemoryBarriers,
+    uint32_t                                    bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+    uint32_t                                    imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlags                        srcStageMask,
+    VkPipelineStageFlags                        dstStageMask,
+    VkDependencyFlags                           dependencyFlags,
+    uint32_t                                    memoryBarrierCount,
+    const VkMemoryBarrier*                      pMemoryBarriers,
+    uint32_t                                    bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+    uint32_t                                    imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query,
+    VkQueryControlFlags                         flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlagBits                     pipelineStage,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                stride,
+    VkQueryResultFlags                          flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineLayout                            layout,
+    VkShaderStageFlags                          stageFlags,
+    uint32_t                                    offset,
+    uint32_t                                    size,
+    const void*                                 pValues);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    VkSubpassContents                           contents);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
+    VkCommandBuffer                             commandBuffer,
+    VkSubpassContents                           contents);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    commandBufferCount,
+    const VkCommandBuffer*                      pCommandBuffers);
+#endif
+
+
+#define VK_VERSION_1_1 1
+// Vulkan 1.1 version number
+#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0
+
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
+#define VK_MAX_DEVICE_GROUP_SIZE          32U
+#define VK_LUID_SIZE                      8U
+#define VK_QUEUE_FAMILY_EXTERNAL          (~1U)
+
+typedef enum VkPointClippingBehavior {
+    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
+    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
+    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
+} VkPointClippingBehavior;
+
+typedef enum VkTessellationDomainOrigin {
+    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
+    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
+    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
+} VkTessellationDomainOrigin;
+
+typedef enum VkSamplerYcbcrModelConversion {
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerYcbcrModelConversion;
+
+typedef enum VkSamplerYcbcrRange {
+    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
+    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
+    VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerYcbcrRange;
+
+typedef enum VkChromaLocation {
+    VK_CHROMA_LOCATION_COSITED_EVEN = 0,
+    VK_CHROMA_LOCATION_MIDPOINT = 1,
+    VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
+    VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
+    VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
+} VkChromaLocation;
+
+typedef enum VkDescriptorUpdateTemplateType {
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorUpdateTemplateType;
+
+typedef enum VkSubgroupFeatureFlagBits {
+    VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
+    VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
+    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
+    VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
+    VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
+    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
+    VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
+    VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
+    VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
+    VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSubgroupFeatureFlagBits;
+typedef VkFlags VkSubgroupFeatureFlags;
+
+typedef enum VkPeerMemoryFeatureFlagBits {
+    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
+    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
+    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
+    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
+    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
+    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPeerMemoryFeatureFlagBits;
+typedef VkFlags VkPeerMemoryFeatureFlags;
+
+typedef enum VkMemoryAllocateFlagBits {
+    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
+    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,
+    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
+    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
+    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
+    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryAllocateFlagBits;
+typedef VkFlags VkMemoryAllocateFlags;
+typedef VkFlags VkCommandPoolTrimFlags;
+typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
+
+typedef enum VkExternalMemoryHandleTypeFlagBits {
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBits;
+typedef VkFlags VkExternalMemoryHandleTypeFlags;
+
+typedef enum VkExternalMemoryFeatureFlagBits {
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBits;
+typedef VkFlags VkExternalMemoryFeatureFlags;
+
+typedef enum VkExternalFenceHandleTypeFlagBits {
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalFenceHandleTypeFlagBits;
+typedef VkFlags VkExternalFenceHandleTypeFlags;
+
+typedef enum VkExternalFenceFeatureFlagBits {
+    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
+    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalFenceFeatureFlagBits;
+typedef VkFlags VkExternalFenceFeatureFlags;
+
+typedef enum VkFenceImportFlagBits {
+    VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
+    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
+    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFenceImportFlagBits;
+typedef VkFlags VkFenceImportFlags;
+
+typedef enum VkSemaphoreImportFlagBits {
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
+    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSemaphoreImportFlagBits;
+typedef VkFlags VkSemaphoreImportFlags;
+
+typedef enum VkExternalSemaphoreHandleTypeFlagBits {
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalSemaphoreHandleTypeFlagBits;
+typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
+
+typedef enum VkExternalSemaphoreFeatureFlagBits {
+    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalSemaphoreFeatureFlagBits;
+typedef VkFlags VkExternalSemaphoreFeatureFlags;
+typedef struct VkPhysicalDeviceSubgroupProperties {
+    VkStructureType           sType;
+    void*                     pNext;
+    uint32_t                  subgroupSize;
+    VkShaderStageFlags        supportedStages;
+    VkSubgroupFeatureFlags    supportedOperations;
+    VkBool32                  quadOperationsInAllStages;
+} VkPhysicalDeviceSubgroupProperties;
+
+typedef struct VkBindBufferMemoryInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           buffer;
+    VkDeviceMemory     memory;
+    VkDeviceSize       memoryOffset;
+} VkBindBufferMemoryInfo;
+
+typedef struct VkBindImageMemoryInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkDeviceMemory     memory;
+    VkDeviceSize       memoryOffset;
+} VkBindImageMemoryInfo;
+
+typedef struct VkPhysicalDevice16BitStorageFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           storageBuffer16BitAccess;
+    VkBool32           uniformAndStorageBuffer16BitAccess;
+    VkBool32           storagePushConstant16;
+    VkBool32           storageInputOutput16;
+} VkPhysicalDevice16BitStorageFeatures;
+
+typedef struct VkMemoryDedicatedRequirements {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           prefersDedicatedAllocation;
+    VkBool32           requiresDedicatedAllocation;
+} VkMemoryDedicatedRequirements;
+
+typedef struct VkMemoryDedicatedAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkBuffer           buffer;
+} VkMemoryDedicatedAllocateInfo;
+
+typedef struct VkMemoryAllocateFlagsInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkMemoryAllocateFlags    flags;
+    uint32_t                 deviceMask;
+} VkMemoryAllocateFlagsInfo;
+
+typedef struct VkDeviceGroupRenderPassBeginInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceMask;
+    uint32_t           deviceRenderAreaCount;
+    const VkRect2D*    pDeviceRenderAreas;
+} VkDeviceGroupRenderPassBeginInfo;
+
+typedef struct VkDeviceGroupCommandBufferBeginInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceMask;
+} VkDeviceGroupCommandBufferBeginInfo;
+
+typedef struct VkDeviceGroupSubmitInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreCount;
+    const uint32_t*    pWaitSemaphoreDeviceIndices;
+    uint32_t           commandBufferCount;
+    const uint32_t*    pCommandBufferDeviceMasks;
+    uint32_t           signalSemaphoreCount;
+    const uint32_t*    pSignalSemaphoreDeviceIndices;
+} VkDeviceGroupSubmitInfo;
+
+typedef struct VkDeviceGroupBindSparseInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           resourceDeviceIndex;
+    uint32_t           memoryDeviceIndex;
+} VkDeviceGroupBindSparseInfo;
+
+typedef struct VkBindBufferMemoryDeviceGroupInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceIndexCount;
+    const uint32_t*    pDeviceIndices;
+} VkBindBufferMemoryDeviceGroupInfo;
+
+typedef struct VkBindImageMemoryDeviceGroupInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceIndexCount;
+    const uint32_t*    pDeviceIndices;
+    uint32_t           splitInstanceBindRegionCount;
+    const VkRect2D*    pSplitInstanceBindRegions;
+} VkBindImageMemoryDeviceGroupInfo;
+
+typedef struct VkPhysicalDeviceGroupProperties {
+    VkStructureType     sType;
+    void*               pNext;
+    uint32_t            physicalDeviceCount;
+    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    VkBool32            subsetAllocation;
+} VkPhysicalDeviceGroupProperties;
+
+typedef struct VkDeviceGroupDeviceCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    uint32_t                   physicalDeviceCount;
+    const VkPhysicalDevice*    pPhysicalDevices;
+} VkDeviceGroupDeviceCreateInfo;
+
+typedef struct VkBufferMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           buffer;
+} VkBufferMemoryRequirementsInfo2;
+
+typedef struct VkImageMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+} VkImageMemoryRequirementsInfo2;
+
+typedef struct VkImageSparseMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+} VkImageSparseMemoryRequirementsInfo2;
+
+typedef struct VkMemoryRequirements2 {
+    VkStructureType         sType;
+    void*                   pNext;
+    VkMemoryRequirements    memoryRequirements;
+} VkMemoryRequirements2;
+
+typedef struct VkSparseImageMemoryRequirements2 {
+    VkStructureType                    sType;
+    void*                              pNext;
+    VkSparseImageMemoryRequirements    memoryRequirements;
+} VkSparseImageMemoryRequirements2;
+
+typedef struct VkPhysicalDeviceFeatures2 {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkPhysicalDeviceFeatures    features;
+} VkPhysicalDeviceFeatures2;
+
+typedef struct VkPhysicalDeviceProperties2 {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkPhysicalDeviceProperties    properties;
+} VkPhysicalDeviceProperties2;
+
+typedef struct VkFormatProperties2 {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkFormatProperties    formatProperties;
+} VkFormatProperties2;
+
+typedef struct VkImageFormatProperties2 {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkImageFormatProperties    imageFormatProperties;
+} VkImageFormatProperties2;
+
+typedef struct VkPhysicalDeviceImageFormatInfo2 {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkFormat              format;
+    VkImageType           type;
+    VkImageTiling         tiling;
+    VkImageUsageFlags     usage;
+    VkImageCreateFlags    flags;
+} VkPhysicalDeviceImageFormatInfo2;
+
+typedef struct VkQueueFamilyProperties2 {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkQueueFamilyProperties    queueFamilyProperties;
+} VkQueueFamilyProperties2;
+
+typedef struct VkPhysicalDeviceMemoryProperties2 {
+    VkStructureType                     sType;
+    void*                               pNext;
+    VkPhysicalDeviceMemoryProperties    memoryProperties;
+} VkPhysicalDeviceMemoryProperties2;
+
+typedef struct VkSparseImageFormatProperties2 {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkSparseImageFormatProperties    properties;
+} VkSparseImageFormatProperties2;
+
+typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkFormat                 format;
+    VkImageType              type;
+    VkSampleCountFlagBits    samples;
+    VkImageUsageFlags        usage;
+    VkImageTiling            tiling;
+} VkPhysicalDeviceSparseImageFormatInfo2;
+
+typedef struct VkPhysicalDevicePointClippingProperties {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkPointClippingBehavior    pointClippingBehavior;
+} VkPhysicalDevicePointClippingProperties;
+
+typedef struct VkInputAttachmentAspectReference {
+    uint32_t              subpass;
+    uint32_t              inputAttachmentIndex;
+    VkImageAspectFlags    aspectMask;
+} VkInputAttachmentAspectReference;
+
+typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   aspectReferenceCount;
+    const VkInputAttachmentAspectReference*    pAspectReferences;
+} VkRenderPassInputAttachmentAspectCreateInfo;
+
+typedef struct VkImageViewUsageCreateInfo {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkImageUsageFlags    usage;
+} VkImageViewUsageCreateInfo;
+
+typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkTessellationDomainOrigin    domainOrigin;
+} VkPipelineTessellationDomainOriginStateCreateInfo;
+
+typedef struct VkRenderPassMultiviewCreateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           subpassCount;
+    const uint32_t*    pViewMasks;
+    uint32_t           dependencyCount;
+    const int32_t*     pViewOffsets;
+    uint32_t           correlationMaskCount;
+    const uint32_t*    pCorrelationMasks;
+} VkRenderPassMultiviewCreateInfo;
+
+typedef struct VkPhysicalDeviceMultiviewFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           multiview;
+    VkBool32           multiviewGeometryShader;
+    VkBool32           multiviewTessellationShader;
+} VkPhysicalDeviceMultiviewFeatures;
+
+typedef struct VkPhysicalDeviceMultiviewProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxMultiviewViewCount;
+    uint32_t           maxMultiviewInstanceIndex;
+} VkPhysicalDeviceMultiviewProperties;
+
+typedef struct VkPhysicalDeviceVariablePointersFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           variablePointersStorageBuffer;
+    VkBool32           variablePointers;
+} VkPhysicalDeviceVariablePointersFeatures;
+
+typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
+
+typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           protectedMemory;
+} VkPhysicalDeviceProtectedMemoryFeatures;
+
+typedef struct VkPhysicalDeviceProtectedMemoryProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           protectedNoFault;
+} VkPhysicalDeviceProtectedMemoryProperties;
+
+typedef struct VkDeviceQueueInfo2 {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkDeviceQueueCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+    uint32_t                    queueIndex;
+} VkDeviceQueueInfo2;
+
+typedef struct VkProtectedSubmitInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           protectedSubmit;
+} VkProtectedSubmitInfo;
+
+typedef struct VkSamplerYcbcrConversionCreateInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkFormat                         format;
+    VkSamplerYcbcrModelConversion    ycbcrModel;
+    VkSamplerYcbcrRange              ycbcrRange;
+    VkComponentMapping               components;
+    VkChromaLocation                 xChromaOffset;
+    VkChromaLocation                 yChromaOffset;
+    VkFilter                         chromaFilter;
+    VkBool32                         forceExplicitReconstruction;
+} VkSamplerYcbcrConversionCreateInfo;
+
+typedef struct VkSamplerYcbcrConversionInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSamplerYcbcrConversion    conversion;
+} VkSamplerYcbcrConversionInfo;
+
+typedef struct VkBindImagePlaneMemoryInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    planeAspect;
+} VkBindImagePlaneMemoryInfo;
+
+typedef struct VkImagePlaneMemoryRequirementsInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    planeAspect;
+} VkImagePlaneMemoryRequirementsInfo;
+
+typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           samplerYcbcrConversion;
+} VkPhysicalDeviceSamplerYcbcrConversionFeatures;
+
+typedef struct VkSamplerYcbcrConversionImageFormatProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           combinedImageSamplerDescriptorCount;
+} VkSamplerYcbcrConversionImageFormatProperties;
+
+typedef struct VkDescriptorUpdateTemplateEntry {
+    uint32_t            dstBinding;
+    uint32_t            dstArrayElement;
+    uint32_t            descriptorCount;
+    VkDescriptorType    descriptorType;
+    size_t              offset;
+    size_t              stride;
+} VkDescriptorUpdateTemplateEntry;
+
+typedef struct VkDescriptorUpdateTemplateCreateInfo {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkDescriptorUpdateTemplateCreateFlags     flags;
+    uint32_t                                  descriptorUpdateEntryCount;
+    const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
+    VkDescriptorUpdateTemplateType            templateType;
+    VkDescriptorSetLayout                     descriptorSetLayout;
+    VkPipelineBindPoint                       pipelineBindPoint;
+    VkPipelineLayout                          pipelineLayout;
+    uint32_t                                  set;
+} VkDescriptorUpdateTemplateCreateInfo;
+
+typedef struct VkExternalMemoryProperties {
+    VkExternalMemoryFeatureFlags       externalMemoryFeatures;
+    VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
+} VkExternalMemoryProperties;
+
+typedef struct VkPhysicalDeviceExternalImageFormatInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalImageFormatInfo;
+
+typedef struct VkExternalImageFormatProperties {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkExternalMemoryProperties    externalMemoryProperties;
+} VkExternalImageFormatProperties;
+
+typedef struct VkPhysicalDeviceExternalBufferInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkBufferCreateFlags                   flags;
+    VkBufferUsageFlags                    usage;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalBufferInfo;
+
+typedef struct VkExternalBufferProperties {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkExternalMemoryProperties    externalMemoryProperties;
+} VkExternalBufferProperties;
+
+typedef struct VkPhysicalDeviceIDProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint8_t            deviceUUID[VK_UUID_SIZE];
+    uint8_t            driverUUID[VK_UUID_SIZE];
+    uint8_t            deviceLUID[VK_LUID_SIZE];
+    uint32_t           deviceNodeMask;
+    VkBool32           deviceLUIDValid;
+} VkPhysicalDeviceIDProperties;
+
+typedef struct VkExternalMemoryImageCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExternalMemoryImageCreateInfo;
+
+typedef struct VkExternalMemoryBufferCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExternalMemoryBufferCreateInfo;
+
+typedef struct VkExportMemoryAllocateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExportMemoryAllocateInfo;
+
+typedef struct VkPhysicalDeviceExternalFenceInfo {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalFenceInfo;
+
+typedef struct VkExternalFenceProperties {
+    VkStructureType                   sType;
+    void*                             pNext;
+    VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
+    VkExternalFenceFeatureFlags       externalFenceFeatures;
+} VkExternalFenceProperties;
+
+typedef struct VkExportFenceCreateInfo {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkExternalFenceHandleTypeFlags    handleTypes;
+} VkExportFenceCreateInfo;
+
+typedef struct VkExportSemaphoreCreateInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalSemaphoreHandleTypeFlags    handleTypes;
+} VkExportSemaphoreCreateInfo;
+
+typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalSemaphoreInfo;
+
+typedef struct VkExternalSemaphoreProperties {
+    VkStructureType                       sType;
+    void*                                 pNext;
+    VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
+    VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
+} VkExternalSemaphoreProperties;
+
+typedef struct VkPhysicalDeviceMaintenance3Properties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxPerSetDescriptors;
+    VkDeviceSize       maxMemoryAllocationSize;
+} VkPhysicalDeviceMaintenance3Properties;
+
+typedef struct VkDescriptorSetLayoutSupport {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           supported;
+} VkDescriptorSetLayoutSupport;
+
+typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderDrawParameters;
+} VkPhysicalDeviceShaderDrawParametersFeatures;
+
+typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
+typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
+    uint32_t*                                   pApiVersion);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindBufferMemoryInfo*               pBindInfos);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindImageMemoryInfo*                pBindInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
+    VkDevice                                    device,
+    uint32_t                                    heapIndex,
+    uint32_t                                    localDeviceIndex,
+    uint32_t                                    remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    deviceMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    baseGroupX,
+    uint32_t                                    baseGroupY,
+    uint32_t                                    baseGroupZ,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
+    VkDevice                                    device,
+    const VkImageMemoryRequirementsInfo2*       pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
+    VkDevice                                    device,
+    const VkBufferMemoryRequirementsInfo2*      pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
+    VkDevice                                    device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures2*                  pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties2*                pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties2*                        pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
+    VkImageFormatProperties2*                   pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2*                   pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties2*             pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolTrimFlags                      flags);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
+    VkDevice                                    device,
+    const VkDeviceQueueInfo2*                   pQueueInfo,
+    VkQueue*                                    pQueue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
+    VkDevice                                    device,
+    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSamplerYcbcrConversion*                   pYcbcrConversion);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
+    VkDevice                                    device,
+    VkSamplerYcbcrConversion                    ycbcrConversion,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
+    VkDevice                                    device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
+    VkDevice                                    device,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
+    VkDevice                                    device,
+    VkDescriptorSet                             descriptorSet,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const void*                                 pData);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
+    VkExternalBufferProperties*                 pExternalBufferProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
+    VkExternalFenceProperties*                  pExternalFenceProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    VkDescriptorSetLayoutSupport*               pSupport);
+#endif
+
+
+#define VK_VERSION_1_2 1
+// Vulkan 1.2 version number
+#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0
+
+#define VK_MAX_DRIVER_NAME_SIZE           256U
+#define VK_MAX_DRIVER_INFO_SIZE           256U
+
+typedef enum VkDriverId {
+    VK_DRIVER_ID_AMD_PROPRIETARY = 1,
+    VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,
+    VK_DRIVER_ID_MESA_RADV = 3,
+    VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,
+    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,
+    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,
+    VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,
+    VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,
+    VK_DRIVER_ID_ARM_PROPRIETARY = 9,
+    VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,
+    VK_DRIVER_ID_GGP_PROPRIETARY = 11,
+    VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,
+    VK_DRIVER_ID_MESA_LLVMPIPE = 13,
+    VK_DRIVER_ID_MOLTENVK = 14,
+    VK_DRIVER_ID_COREAVI_PROPRIETARY = 15,
+    VK_DRIVER_ID_JUICE_PROPRIETARY = 16,
+    VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17,
+    VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
+    VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
+    VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
+    VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
+    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
+    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
+    VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
+    VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
+    VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY,
+    VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
+    VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,
+    VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
+    VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF
+} VkDriverId;
+
+typedef enum VkShaderFloatControlsIndependence {
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
+} VkShaderFloatControlsIndependence;
+
+typedef enum VkSamplerReductionMode {
+    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
+    VK_SAMPLER_REDUCTION_MODE_MIN = 1,
+    VK_SAMPLER_REDUCTION_MODE_MAX = 2,
+    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
+    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
+    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
+    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerReductionMode;
+
+typedef enum VkSemaphoreType {
+    VK_SEMAPHORE_TYPE_BINARY = 0,
+    VK_SEMAPHORE_TYPE_TIMELINE = 1,
+    VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,
+    VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,
+    VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkSemaphoreType;
+
+typedef enum VkResolveModeFlagBits {
+    VK_RESOLVE_MODE_NONE = 0,
+    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,
+    VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
+    VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
+    VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
+    VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
+    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
+    VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
+    VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,
+    VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,
+    VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkResolveModeFlagBits;
+typedef VkFlags VkResolveModeFlags;
+
+typedef enum VkDescriptorBindingFlagBits {
+    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,
+    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,
+    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,
+    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,
+    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
+    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
+    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,
+    VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorBindingFlagBits;
+typedef VkFlags VkDescriptorBindingFlags;
+
+typedef enum VkSemaphoreWaitFlagBits {
+    VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,
+    VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
+    VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSemaphoreWaitFlagBits;
+typedef VkFlags VkSemaphoreWaitFlags;
+typedef struct VkPhysicalDeviceVulkan11Features {
+    VkStructureType    sType;
+    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;
+} VkPhysicalDeviceVulkan11Features;
+
+typedef struct VkPhysicalDeviceVulkan11Properties {
+    VkStructureType            sType;
+    void*                      pNext;
+    uint8_t                    deviceUUID[VK_UUID_SIZE];
+    uint8_t                    driverUUID[VK_UUID_SIZE];
+    uint8_t                    deviceLUID[VK_LUID_SIZE];
+    uint32_t                   deviceNodeMask;
+    VkBool32                   deviceLUIDValid;
+    uint32_t                   subgroupSize;
+    VkShaderStageFlags         subgroupSupportedStages;
+    VkSubgroupFeatureFlags     subgroupSupportedOperations;
+    VkBool32                   subgroupQuadOperationsInAllStages;
+    VkPointClippingBehavior    pointClippingBehavior;
+    uint32_t                   maxMultiviewViewCount;
+    uint32_t                   maxMultiviewInstanceIndex;
+    VkBool32                   protectedNoFault;
+    uint32_t                   maxPerSetDescriptors;
+    VkDeviceSize               maxMemoryAllocationSize;
+} VkPhysicalDeviceVulkan11Properties;
+
+typedef struct VkPhysicalDeviceVulkan12Features {
+    VkStructureType    sType;
+    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;
+} VkPhysicalDeviceVulkan12Features;
+
+typedef struct VkConformanceVersion {
+    uint8_t    major;
+    uint8_t    minor;
+    uint8_t    subminor;
+    uint8_t    patch;
+} VkConformanceVersion;
+
+typedef struct VkPhysicalDeviceVulkan12Properties {
+    VkStructureType                      sType;
+    void*                                pNext;
+    VkDriverId                           driverID;
+    char                                 driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char                                 driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion                 conformanceVersion;
+    VkShaderFloatControlsIndependence    denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence    roundingModeIndependence;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32                             shaderDenormPreserveFloat16;
+    VkBool32                             shaderDenormPreserveFloat32;
+    VkBool32                             shaderDenormPreserveFloat64;
+    VkBool32                             shaderDenormFlushToZeroFloat16;
+    VkBool32                             shaderDenormFlushToZeroFloat32;
+    VkBool32                             shaderDenormFlushToZeroFloat64;
+    VkBool32                             shaderRoundingModeRTEFloat16;
+    VkBool32                             shaderRoundingModeRTEFloat32;
+    VkBool32                             shaderRoundingModeRTEFloat64;
+    VkBool32                             shaderRoundingModeRTZFloat16;
+    VkBool32                             shaderRoundingModeRTZFloat32;
+    VkBool32                             shaderRoundingModeRTZFloat64;
+    uint32_t                             maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32                             shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32                             shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32                             shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32                             shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32                             shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32                             robustBufferAccessUpdateAfterBind;
+    VkBool32                             quadDivergentImplicitLod;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t                             maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t                             maxPerStageUpdateAfterBindResources;
+    uint32_t                             maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t                             maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t                             maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t                             maxDescriptorSetUpdateAfterBindInputAttachments;
+    VkResolveModeFlags                   supportedDepthResolveModes;
+    VkResolveModeFlags                   supportedStencilResolveModes;
+    VkBool32                             independentResolveNone;
+    VkBool32                             independentResolve;
+    VkBool32                             filterMinmaxSingleComponentFormats;
+    VkBool32                             filterMinmaxImageComponentMapping;
+    uint64_t                             maxTimelineSemaphoreValueDifference;
+    VkSampleCountFlags                   framebufferIntegerColorSampleCounts;
+} VkPhysicalDeviceVulkan12Properties;
+
+typedef struct VkImageFormatListCreateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           viewFormatCount;
+    const VkFormat*    pViewFormats;
+} VkImageFormatListCreateInfo;
+
+typedef struct VkAttachmentDescription2 {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkAttachmentDescriptionFlags    flags;
+    VkFormat                        format;
+    VkSampleCountFlagBits           samples;
+    VkAttachmentLoadOp              loadOp;
+    VkAttachmentStoreOp             storeOp;
+    VkAttachmentLoadOp              stencilLoadOp;
+    VkAttachmentStoreOp             stencilStoreOp;
+    VkImageLayout                   initialLayout;
+    VkImageLayout                   finalLayout;
+} VkAttachmentDescription2;
+
+typedef struct VkAttachmentReference2 {
+    VkStructureType       sType;
+    const void*           pNext;
+    uint32_t              attachment;
+    VkImageLayout         layout;
+    VkImageAspectFlags    aspectMask;
+} VkAttachmentReference2;
+
+typedef struct VkSubpassDescription2 {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkSubpassDescriptionFlags        flags;
+    VkPipelineBindPoint              pipelineBindPoint;
+    uint32_t                         viewMask;
+    uint32_t                         inputAttachmentCount;
+    const VkAttachmentReference2*    pInputAttachments;
+    uint32_t                         colorAttachmentCount;
+    const VkAttachmentReference2*    pColorAttachments;
+    const VkAttachmentReference2*    pResolveAttachments;
+    const VkAttachmentReference2*    pDepthStencilAttachment;
+    uint32_t                         preserveAttachmentCount;
+    const uint32_t*                  pPreserveAttachments;
+} VkSubpassDescription2;
+
+typedef struct VkSubpassDependency2 {
+    VkStructureType         sType;
+    const void*             pNext;
+    uint32_t                srcSubpass;
+    uint32_t                dstSubpass;
+    VkPipelineStageFlags    srcStageMask;
+    VkPipelineStageFlags    dstStageMask;
+    VkAccessFlags           srcAccessMask;
+    VkAccessFlags           dstAccessMask;
+    VkDependencyFlags       dependencyFlags;
+    int32_t                 viewOffset;
+} VkSubpassDependency2;
+
+typedef struct VkRenderPassCreateInfo2 {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkRenderPassCreateFlags            flags;
+    uint32_t                           attachmentCount;
+    const VkAttachmentDescription2*    pAttachments;
+    uint32_t                           subpassCount;
+    const VkSubpassDescription2*       pSubpasses;
+    uint32_t                           dependencyCount;
+    const VkSubpassDependency2*        pDependencies;
+    uint32_t                           correlatedViewMaskCount;
+    const uint32_t*                    pCorrelatedViewMasks;
+} VkRenderPassCreateInfo2;
+
+typedef struct VkSubpassBeginInfo {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkSubpassContents    contents;
+} VkSubpassBeginInfo;
+
+typedef struct VkSubpassEndInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkSubpassEndInfo;
+
+typedef struct VkPhysicalDevice8BitStorageFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           storageBuffer8BitAccess;
+    VkBool32           uniformAndStorageBuffer8BitAccess;
+    VkBool32           storagePushConstant8;
+} VkPhysicalDevice8BitStorageFeatures;
+
+typedef struct VkPhysicalDeviceDriverProperties {
+    VkStructureType         sType;
+    void*                   pNext;
+    VkDriverId              driverID;
+    char                    driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char                    driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion    conformanceVersion;
+} VkPhysicalDeviceDriverProperties;
+
+typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderBufferInt64Atomics;
+    VkBool32           shaderSharedInt64Atomics;
+} VkPhysicalDeviceShaderAtomicInt64Features;
+
+typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderFloat16;
+    VkBool32           shaderInt8;
+} VkPhysicalDeviceShaderFloat16Int8Features;
+
+typedef struct VkPhysicalDeviceFloatControlsProperties {
+    VkStructureType                      sType;
+    void*                                pNext;
+    VkShaderFloatControlsIndependence    denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence    roundingModeIndependence;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32                             shaderDenormPreserveFloat16;
+    VkBool32                             shaderDenormPreserveFloat32;
+    VkBool32                             shaderDenormPreserveFloat64;
+    VkBool32                             shaderDenormFlushToZeroFloat16;
+    VkBool32                             shaderDenormFlushToZeroFloat32;
+    VkBool32                             shaderDenormFlushToZeroFloat64;
+    VkBool32                             shaderRoundingModeRTEFloat16;
+    VkBool32                             shaderRoundingModeRTEFloat32;
+    VkBool32                             shaderRoundingModeRTEFloat64;
+    VkBool32                             shaderRoundingModeRTZFloat16;
+    VkBool32                             shaderRoundingModeRTZFloat32;
+    VkBool32                             shaderRoundingModeRTZFloat64;
+} VkPhysicalDeviceFloatControlsProperties;
+
+typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    uint32_t                           bindingCount;
+    const VkDescriptorBindingFlags*    pBindingFlags;
+} VkDescriptorSetLayoutBindingFlagsCreateInfo;
+
+typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
+    VkStructureType    sType;
+    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;
+} VkPhysicalDeviceDescriptorIndexingFeatures;
+
+typedef struct VkPhysicalDeviceDescriptorIndexingProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32           robustBufferAccessUpdateAfterBind;
+    VkBool32           quadDivergentImplicitLod;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t           maxPerStageUpdateAfterBindResources;
+    uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
+} VkPhysicalDeviceDescriptorIndexingProperties;
+
+typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           descriptorSetCount;
+    const uint32_t*    pDescriptorCounts;
+} VkDescriptorSetVariableDescriptorCountAllocateInfo;
+
+typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVariableDescriptorCount;
+} VkDescriptorSetVariableDescriptorCountLayoutSupport;
+
+typedef struct VkSubpassDescriptionDepthStencilResolve {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkResolveModeFlagBits            depthResolveMode;
+    VkResolveModeFlagBits            stencilResolveMode;
+    const VkAttachmentReference2*    pDepthStencilResolveAttachment;
+} VkSubpassDescriptionDepthStencilResolve;
+
+typedef struct VkPhysicalDeviceDepthStencilResolveProperties {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkResolveModeFlags    supportedDepthResolveModes;
+    VkResolveModeFlags    supportedStencilResolveModes;
+    VkBool32              independentResolveNone;
+    VkBool32              independentResolve;
+} VkPhysicalDeviceDepthStencilResolveProperties;
+
+typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           scalarBlockLayout;
+} VkPhysicalDeviceScalarBlockLayoutFeatures;
+
+typedef struct VkImageStencilUsageCreateInfo {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkImageUsageFlags    stencilUsage;
+} VkImageStencilUsageCreateInfo;
+
+typedef struct VkSamplerReductionModeCreateInfo {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkSamplerReductionMode    reductionMode;
+} VkSamplerReductionModeCreateInfo;
+
+typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           filterMinmaxSingleComponentFormats;
+    VkBool32           filterMinmaxImageComponentMapping;
+} VkPhysicalDeviceSamplerFilterMinmaxProperties;
+
+typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           vulkanMemoryModel;
+    VkBool32           vulkanMemoryModelDeviceScope;
+    VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
+} VkPhysicalDeviceVulkanMemoryModelFeatures;
+
+typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           imagelessFramebuffer;
+} VkPhysicalDeviceImagelessFramebufferFeatures;
+
+typedef struct VkFramebufferAttachmentImageInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkImageCreateFlags    flags;
+    VkImageUsageFlags     usage;
+    uint32_t              width;
+    uint32_t              height;
+    uint32_t              layerCount;
+    uint32_t              viewFormatCount;
+    const VkFormat*       pViewFormats;
+} VkFramebufferAttachmentImageInfo;
+
+typedef struct VkFramebufferAttachmentsCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   attachmentImageInfoCount;
+    const VkFramebufferAttachmentImageInfo*    pAttachmentImageInfos;
+} VkFramebufferAttachmentsCreateInfo;
+
+typedef struct VkRenderPassAttachmentBeginInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    uint32_t              attachmentCount;
+    const VkImageView*    pAttachments;
+} VkRenderPassAttachmentBeginInfo;
+
+typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           uniformBufferStandardLayout;
+} VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
+
+typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSubgroupExtendedTypes;
+} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+
+typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           separateDepthStencilLayouts;
+} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+
+typedef struct VkAttachmentReferenceStencilLayout {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilLayout;
+} VkAttachmentReferenceStencilLayout;
+
+typedef struct VkAttachmentDescriptionStencilLayout {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilInitialLayout;
+    VkImageLayout      stencilFinalLayout;
+} VkAttachmentDescriptionStencilLayout;
+
+typedef struct VkPhysicalDeviceHostQueryResetFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           hostQueryReset;
+} VkPhysicalDeviceHostQueryResetFeatures;
+
+typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           timelineSemaphore;
+} VkPhysicalDeviceTimelineSemaphoreFeatures;
+
+typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           maxTimelineSemaphoreValueDifference;
+} VkPhysicalDeviceTimelineSemaphoreProperties;
+
+typedef struct VkSemaphoreTypeCreateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSemaphoreType    semaphoreType;
+    uint64_t           initialValue;
+} VkSemaphoreTypeCreateInfo;
+
+typedef struct VkTimelineSemaphoreSubmitInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValueCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValueCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkTimelineSemaphoreSubmitInfo;
+
+typedef struct VkSemaphoreWaitInfo {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkSemaphoreWaitFlags    flags;
+    uint32_t                semaphoreCount;
+    const VkSemaphore*      pSemaphores;
+    const uint64_t*         pValues;
+} VkSemaphoreWaitInfo;
+
+typedef struct VkSemaphoreSignalInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSemaphore        semaphore;
+    uint64_t           value;
+} VkSemaphoreSignalInfo;
+
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           bufferDeviceAddress;
+    VkBool32           bufferDeviceAddressCaptureReplay;
+    VkBool32           bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeatures;
+
+typedef struct VkBufferDeviceAddressInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           buffer;
+} VkBufferDeviceAddressInfo;
+
+typedef struct VkBufferOpaqueCaptureAddressCreateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint64_t           opaqueCaptureAddress;
+} VkBufferOpaqueCaptureAddressCreateInfo;
+
+typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint64_t           opaqueCaptureAddress;
+} VkMemoryOpaqueCaptureAddressAllocateInfo;
+
+typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkDeviceMemoryOpaqueCaptureAddressInfo;
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
+typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
+typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
+typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(
+    VkDevice                                    device,
+    const VkRenderPassCreateInfo2*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkRenderPass*                               pRenderPass);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    const VkSubpassBeginInfo*                   pSubpassBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(
+    VkCommandBuffer                             commandBuffer,
+    const VkSubpassBeginInfo*                   pSubpassBeginInfo,
+    const VkSubpassEndInfo*                     pSubpassEndInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(
+    VkCommandBuffer                             commandBuffer,
+    const VkSubpassEndInfo*                     pSubpassEndInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(
+    VkDevice                                    device,
+    VkSemaphore                                 semaphore,
+    uint64_t*                                   pValue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(
+    VkDevice                                    device,
+    const VkSemaphoreWaitInfo*                  pWaitInfo,
+    uint64_t                                    timeout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(
+    VkDevice                                    device,
+    const VkSemaphoreSignalInfo*                pSignalInfo);
+
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(
+    VkDevice                                    device,
+    const VkBufferDeviceAddressInfo*            pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(
+    VkDevice                                    device,
+    const VkBufferDeviceAddressInfo*            pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(
+    VkDevice                                    device,
+    const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+#endif
+
+
+#define VK_KHR_surface 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+#define VK_KHR_SURFACE_SPEC_VERSION       25
+#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
+
+typedef enum VkPresentModeKHR {
+    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
+    VK_PRESENT_MODE_MAILBOX_KHR = 1,
+    VK_PRESENT_MODE_FIFO_KHR = 2,
+    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
+    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
+    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
+    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPresentModeKHR;
+
+typedef enum VkColorSpaceKHR {
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
+    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
+    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
+    VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
+    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
+    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
+    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
+    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
+    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
+    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
+    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
+    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
+    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
+    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
+    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
+    VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
+    VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
+    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkColorSpaceKHR;
+
+typedef enum VkSurfaceTransformFlagBitsKHR {
+    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
+    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
+    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
+    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
+    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSurfaceTransformFlagBitsKHR;
+
+typedef enum VkCompositeAlphaFlagBitsKHR {
+    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
+    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
+    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
+    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkCompositeAlphaFlagBitsKHR;
+typedef VkFlags VkCompositeAlphaFlagsKHR;
+typedef VkFlags VkSurfaceTransformFlagsKHR;
+typedef struct VkSurfaceCapabilitiesKHR {
+    uint32_t                         minImageCount;
+    uint32_t                         maxImageCount;
+    VkExtent2D                       currentExtent;
+    VkExtent2D                       minImageExtent;
+    VkExtent2D                       maxImageExtent;
+    uint32_t                         maxImageArrayLayers;
+    VkSurfaceTransformFlagsKHR       supportedTransforms;
+    VkSurfaceTransformFlagBitsKHR    currentTransform;
+    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
+    VkImageUsageFlags                supportedUsageFlags;
+} VkSurfaceCapabilitiesKHR;
+
+typedef struct VkSurfaceFormatKHR {
+    VkFormat           format;
+    VkColorSpaceKHR    colorSpace;
+} VkSurfaceFormatKHR;
+
+typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
+    VkInstance                                  instance,
+    VkSurfaceKHR                                surface,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    VkSurfaceKHR                                surface,
+    VkBool32*                                   pSupported);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pSurfaceFormatCount,
+    VkSurfaceFormatKHR*                         pSurfaceFormats);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pPresentModeCount,
+    VkPresentModeKHR*                           pPresentModes);
+#endif
+
+
+#define VK_KHR_swapchain 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+#define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
+#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
+
+typedef enum VkSwapchainCreateFlagBitsKHR {
+    VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
+    VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
+    VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
+    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSwapchainCreateFlagBitsKHR;
+typedef VkFlags VkSwapchainCreateFlagsKHR;
+
+typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
+    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
+    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
+    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
+    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
+    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkDeviceGroupPresentModeFlagBitsKHR;
+typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
+typedef struct VkSwapchainCreateInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkSwapchainCreateFlagsKHR        flags;
+    VkSurfaceKHR                     surface;
+    uint32_t                         minImageCount;
+    VkFormat                         imageFormat;
+    VkColorSpaceKHR                  imageColorSpace;
+    VkExtent2D                       imageExtent;
+    uint32_t                         imageArrayLayers;
+    VkImageUsageFlags                imageUsage;
+    VkSharingMode                    imageSharingMode;
+    uint32_t                         queueFamilyIndexCount;
+    const uint32_t*                  pQueueFamilyIndices;
+    VkSurfaceTransformFlagBitsKHR    preTransform;
+    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
+    VkPresentModeKHR                 presentMode;
+    VkBool32                         clipped;
+    VkSwapchainKHR                   oldSwapchain;
+} VkSwapchainCreateInfoKHR;
+
+typedef struct VkPresentInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 waitSemaphoreCount;
+    const VkSemaphore*       pWaitSemaphores;
+    uint32_t                 swapchainCount;
+    const VkSwapchainKHR*    pSwapchains;
+    const uint32_t*          pImageIndices;
+    VkResult*                pResults;
+} VkPresentInfoKHR;
+
+typedef struct VkImageSwapchainCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+} VkImageSwapchainCreateInfoKHR;
+
+typedef struct VkBindImageMemorySwapchainInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+    uint32_t           imageIndex;
+} VkBindImageMemorySwapchainInfoKHR;
+
+typedef struct VkAcquireNextImageInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+    uint64_t           timeout;
+    VkSemaphore        semaphore;
+    VkFence            fence;
+    uint32_t           deviceMask;
+} VkAcquireNextImageInfoKHR;
+
+typedef struct VkDeviceGroupPresentCapabilitiesKHR {
+    VkStructureType                     sType;
+    void*                               pNext;
+    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    VkDeviceGroupPresentModeFlagsKHR    modes;
+} VkDeviceGroupPresentCapabilitiesKHR;
+
+typedef struct VkDeviceGroupPresentInfoKHR {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    uint32_t                               swapchainCount;
+    const uint32_t*                        pDeviceMasks;
+    VkDeviceGroupPresentModeFlagBitsKHR    mode;
+} VkDeviceGroupPresentInfoKHR;
+
+typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkDeviceGroupPresentModeFlagsKHR    modes;
+} VkDeviceGroupSwapchainCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
+typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
+    VkDevice                                    device,
+    const VkSwapchainCreateInfoKHR*             pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSwapchainKHR*                             pSwapchain);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint32_t*                                   pSwapchainImageCount,
+    VkImage*                                    pSwapchainImages);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint64_t                                    timeout,
+    VkSemaphore                                 semaphore,
+    VkFence                                     fence,
+    uint32_t*                                   pImageIndex);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
+    VkQueue                                     queue,
+    const VkPresentInfoKHR*                     pPresentInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice                                    device,
+    VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
+    VkDevice                                    device,
+    VkSurfaceKHR                                surface,
+    VkDeviceGroupPresentModeFlagsKHR*           pModes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pRectCount,
+    VkRect2D*                                   pRects);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
+    VkDevice                                    device,
+    const VkAcquireNextImageInfoKHR*            pAcquireInfo,
+    uint32_t*                                   pImageIndex);
+#endif
+
+
+#define VK_KHR_display 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+#define VK_KHR_DISPLAY_SPEC_VERSION       23
+#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
+typedef VkFlags VkDisplayModeCreateFlagsKHR;
+
+typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
+    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
+    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkDisplayPlaneAlphaFlagBitsKHR;
+typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+typedef struct VkDisplayModeParametersKHR {
+    VkExtent2D    visibleRegion;
+    uint32_t      refreshRate;
+} VkDisplayModeParametersKHR;
+
+typedef struct VkDisplayModeCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkDisplayModeCreateFlagsKHR    flags;
+    VkDisplayModeParametersKHR     parameters;
+} VkDisplayModeCreateInfoKHR;
+
+typedef struct VkDisplayModePropertiesKHR {
+    VkDisplayModeKHR              displayMode;
+    VkDisplayModeParametersKHR    parameters;
+} VkDisplayModePropertiesKHR;
+
+typedef struct VkDisplayPlaneCapabilitiesKHR {
+    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
+    VkOffset2D                     minSrcPosition;
+    VkOffset2D                     maxSrcPosition;
+    VkExtent2D                     minSrcExtent;
+    VkExtent2D                     maxSrcExtent;
+    VkOffset2D                     minDstPosition;
+    VkOffset2D                     maxDstPosition;
+    VkExtent2D                     minDstExtent;
+    VkExtent2D                     maxDstExtent;
+} VkDisplayPlaneCapabilitiesKHR;
+
+typedef struct VkDisplayPlanePropertiesKHR {
+    VkDisplayKHR    currentDisplay;
+    uint32_t        currentStackIndex;
+} VkDisplayPlanePropertiesKHR;
+
+typedef struct VkDisplayPropertiesKHR {
+    VkDisplayKHR                  display;
+    const char*                   displayName;
+    VkExtent2D                    physicalDimensions;
+    VkExtent2D                    physicalResolution;
+    VkSurfaceTransformFlagsKHR    supportedTransforms;
+    VkBool32                      planeReorderPossible;
+    VkBool32                      persistentContent;
+} VkDisplayPropertiesKHR;
+
+typedef struct VkDisplaySurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkDisplaySurfaceCreateFlagsKHR    flags;
+    VkDisplayModeKHR                  displayMode;
+    uint32_t                          planeIndex;
+    uint32_t                          planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR     transform;
+    float                             globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
+    VkExtent2D                        imageExtent;
+} VkDisplaySurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPropertiesKHR*                     pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPlanePropertiesKHR*                pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    planeIndex,
+    uint32_t*                                   pDisplayCount,
+    VkDisplayKHR*                               pDisplays);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayModePropertiesKHR*                 pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDisplayModeKHR*                           pMode);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayModeKHR                            mode,
+    uint32_t                                    planeIndex,
+    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+    VkInstance                                  instance,
+    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_KHR_display_swapchain 1
+#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
+#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+typedef struct VkDisplayPresentInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkRect2D           srcRect;
+    VkRect2D           dstRect;
+    VkBool32           persistent;
+} VkDisplayPresentInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
+    VkDevice                                    device,
+    uint32_t                                    swapchainCount,
+    const VkSwapchainCreateInfoKHR*             pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSwapchainKHR*                             pSwapchains);
+#endif
+
+
+#define VK_KHR_sampler_mirror_clamp_to_edge 1
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
+
+
+#define VK_KHR_multiview 1
+#define VK_KHR_MULTIVIEW_SPEC_VERSION     1
+#define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
+typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
+
+typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
+
+typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
+
+
+
+#define VK_KHR_get_physical_device_properties2 1
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
+typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
+
+typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
+
+typedef VkFormatProperties2 VkFormatProperties2KHR;
+
+typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
+
+typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
+
+typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
+
+typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
+
+typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
+
+typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures2*                  pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties2*                pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties2*                        pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
+    VkImageFormatProperties2*                   pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2*                   pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties2*             pProperties);
+#endif
+
+
+#define VK_KHR_device_group 1
+#define VK_KHR_DEVICE_GROUP_SPEC_VERSION  4
+#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
+typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
+
+typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
+
+typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
+
+typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
+
+typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
+
+typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
+
+typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
+
+typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
+
+typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
+
+typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
+
+typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice                                    device,
+    uint32_t                                    heapIndex,
+    uint32_t                                    localDeviceIndex,
+    uint32_t                                    remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    deviceMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    baseGroupX,
+    uint32_t                                    baseGroupY,
+    uint32_t                                    baseGroupZ,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+#endif
+
+
+#define VK_KHR_shader_draw_parameters 1
+#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
+#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
+
+
+#define VK_KHR_maintenance1 1
+#define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
+#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
+typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
+
+typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolTrimFlags                      flags);
+#endif
+
+
+#define VK_KHR_device_group_creation 1
+#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
+#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
+#define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
+typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
+
+typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
+#endif
+
+
+#define VK_KHR_external_memory_capabilities 1
+#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
+#define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
+typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
+
+typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
+
+typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
+
+typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
+
+typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
+
+typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
+
+typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
+
+typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
+
+typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
+
+typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
+    VkExternalBufferProperties*                 pExternalBufferProperties);
+#endif
+
+
+#define VK_KHR_external_memory 1
+#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
+#define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
+typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
+
+typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
+
+typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
+
+
+
+#define VK_KHR_external_memory_fd 1
+#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
+typedef struct VkImportMemoryFdInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    int                                   fd;
+} VkImportMemoryFdInfoKHR;
+
+typedef struct VkMemoryFdPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryFdPropertiesKHR;
+
+typedef struct VkMemoryGetFdInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetFdInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
+    VkDevice                                    device,
+    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
+    int*                                        pFd);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    int                                         fd,
+    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
+#endif
+
+
+#define VK_KHR_external_semaphore_capabilities 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
+typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
+
+typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
+
+typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
+
+typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
+
+typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
+
+typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
+#endif
+
+
+#define VK_KHR_external_semaphore 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
+typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
+
+typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
+
+typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_fd 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
+typedef struct VkImportSemaphoreFdInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    int                                      fd;
+} VkImportSemaphoreFdInfoKHR;
+
+typedef struct VkSemaphoreGetFdInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetFdInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
+    int*                                        pFd);
+#endif
+
+
+#define VK_KHR_push_descriptor 1
+#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
+#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
+typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxPushDescriptors;
+} VkPhysicalDevicePushDescriptorPropertiesKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipelineLayout                            layout,
+    uint32_t                                    set,
+    uint32_t                                    descriptorWriteCount,
+    const VkWriteDescriptorSet*                 pDescriptorWrites);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    VkPipelineLayout                            layout,
+    uint32_t                                    set,
+    const void*                                 pData);
+#endif
+
+
+#define VK_KHR_shader_float16_int8 1
+#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
+typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
+
+typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
+
+
+
+#define VK_KHR_16bit_storage 1
+#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
+#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
+typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
+
+
+
+#define VK_KHR_incremental_present 1
+#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2
+#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
+typedef struct VkRectLayerKHR {
+    VkOffset2D    offset;
+    VkExtent2D    extent;
+    uint32_t      layer;
+} VkRectLayerKHR;
+
+typedef struct VkPresentRegionKHR {
+    uint32_t                 rectangleCount;
+    const VkRectLayerKHR*    pRectangles;
+} VkPresentRegionKHR;
+
+typedef struct VkPresentRegionsKHR {
+    VkStructureType              sType;
+    const void*                  pNext;
+    uint32_t                     swapchainCount;
+    const VkPresentRegionKHR*    pRegions;
+} VkPresentRegionsKHR;
+
+
+
+#define VK_KHR_descriptor_update_template 1
+typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
+
+#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
+#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
+typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
+
+typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
+
+typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
+
+typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
+    VkDevice                                    device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
+    VkDevice                                    device,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
+    VkDevice                                    device,
+    VkDescriptorSet                             descriptorSet,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const void*                                 pData);
+#endif
+
+
+#define VK_KHR_imageless_framebuffer 1
+#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
+#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
+typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
+
+typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;
+
+typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;
+
+typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
+
+
+
+#define VK_KHR_create_renderpass2 1
+#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
+#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
+typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
+
+typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
+
+typedef VkAttachmentReference2 VkAttachmentReference2KHR;
+
+typedef VkSubpassDescription2 VkSubpassDescription2KHR;
+
+typedef VkSubpassDependency2 VkSubpassDependency2KHR;
+
+typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
+
+typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
+    VkDevice                                    device,
+    const VkRenderPassCreateInfo2*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkRenderPass*                               pRenderPass);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    const VkSubpassBeginInfo*                   pSubpassBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkSubpassBeginInfo*                   pSubpassBeginInfo,
+    const VkSubpassEndInfo*                     pSubpassEndInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkSubpassEndInfo*                     pSubpassEndInfo);
+#endif
+
+
+#define VK_KHR_shared_presentable_image 1
+#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
+#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
+typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
+    VkStructureType      sType;
+    void*                pNext;
+    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
+} VkSharedPresentSurfaceCapabilitiesKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+#endif
+
+
+#define VK_KHR_external_fence_capabilities 1
+#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
+typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
+
+typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
+
+typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
+
+typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
+
+typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
+
+typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
+    VkExternalFenceProperties*                  pExternalFenceProperties);
+#endif
+
+
+#define VK_KHR_external_fence 1
+#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
+typedef VkFenceImportFlags VkFenceImportFlagsKHR;
+
+typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
+
+typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
+
+
+
+#define VK_KHR_external_fence_fd 1
+#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
+typedef struct VkImportFenceFdInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    int                                  fd;
+} VkImportFenceFdInfoKHR;
+
+typedef struct VkFenceGetFdInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetFdInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
+    VkDevice                                    device,
+    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
+    VkDevice                                    device,
+    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
+    int*                                        pFd);
+#endif
+
+
+#define VK_KHR_performance_query 1
+#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
+#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
+
+typedef enum VkPerformanceCounterUnitKHR {
+    VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
+    VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
+    VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
+    VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
+    VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
+    VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
+    VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
+    VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
+    VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
+    VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
+    VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
+    VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterUnitKHR;
+
+typedef enum VkPerformanceCounterScopeKHR {
+    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
+    VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
+    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
+    VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
+    VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
+    VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
+    VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterScopeKHR;
+
+typedef enum VkPerformanceCounterStorageKHR {
+    VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
+    VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
+    VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
+    VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
+    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
+    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
+    VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterStorageKHR;
+
+typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterDescriptionFlagBitsKHR;
+typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
+
+typedef enum VkAcquireProfilingLockFlagBitsKHR {
+    VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAcquireProfilingLockFlagBitsKHR;
+typedef VkFlags VkAcquireProfilingLockFlagsKHR;
+typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           performanceCounterQueryPools;
+    VkBool32           performanceCounterMultipleQueryPools;
+} VkPhysicalDevicePerformanceQueryFeaturesKHR;
+
+typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           allowCommandBufferQueryCopies;
+} VkPhysicalDevicePerformanceQueryPropertiesKHR;
+
+typedef struct VkPerformanceCounterKHR {
+    VkStructureType                   sType;
+    void*                             pNext;
+    VkPerformanceCounterUnitKHR       unit;
+    VkPerformanceCounterScopeKHR      scope;
+    VkPerformanceCounterStorageKHR    storage;
+    uint8_t                           uuid[VK_UUID_SIZE];
+} VkPerformanceCounterKHR;
+
+typedef struct VkPerformanceCounterDescriptionKHR {
+    VkStructureType                            sType;
+    void*                                      pNext;
+    VkPerformanceCounterDescriptionFlagsKHR    flags;
+    char                                       name[VK_MAX_DESCRIPTION_SIZE];
+    char                                       category[VK_MAX_DESCRIPTION_SIZE];
+    char                                       description[VK_MAX_DESCRIPTION_SIZE];
+} VkPerformanceCounterDescriptionKHR;
+
+typedef struct VkQueryPoolPerformanceCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           queueFamilyIndex;
+    uint32_t           counterIndexCount;
+    const uint32_t*    pCounterIndices;
+} VkQueryPoolPerformanceCreateInfoKHR;
+
+typedef union VkPerformanceCounterResultKHR {
+    int32_t     int32;
+    int64_t     int64;
+    uint32_t    uint32;
+    uint64_t    uint64;
+    float       float32;
+    double      float64;
+} VkPerformanceCounterResultKHR;
+
+typedef struct VkAcquireProfilingLockInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAcquireProfilingLockFlagsKHR    flags;
+    uint64_t                          timeout;
+} VkAcquireProfilingLockInfoKHR;
+
+typedef struct VkPerformanceQuerySubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           counterPassIndex;
+} VkPerformanceQuerySubmitInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    uint32_t*                                   pCounterCount,
+    VkPerformanceCounterKHR*                    pCounters,
+    VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
+    uint32_t*                                   pNumPasses);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
+    VkDevice                                    device,
+    const VkAcquireProfilingLockInfoKHR*        pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
+    VkDevice                                    device);
+#endif
+
+
+#define VK_KHR_maintenance2 1
+#define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
+#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
+typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
+
+typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
+
+typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
+
+typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
+
+typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
+
+typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
+
+typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
+
+
+
+#define VK_KHR_get_surface_capabilities2 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
+typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSurfaceKHR       surface;
+} VkPhysicalDeviceSurfaceInfo2KHR;
+
+typedef struct VkSurfaceCapabilities2KHR {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
+} VkSurfaceCapabilities2KHR;
+
+typedef struct VkSurfaceFormat2KHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkSurfaceFormatKHR    surfaceFormat;
+} VkSurfaceFormat2KHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    uint32_t*                                   pSurfaceFormatCount,
+    VkSurfaceFormat2KHR*                        pSurfaceFormats);
+#endif
+
+
+#define VK_KHR_variable_pointers 1
+#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
+#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
+typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
+
+typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
+
+
+
+#define VK_KHR_get_display_properties2 1
+#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
+typedef struct VkDisplayProperties2KHR {
+    VkStructureType           sType;
+    void*                     pNext;
+    VkDisplayPropertiesKHR    displayProperties;
+} VkDisplayProperties2KHR;
+
+typedef struct VkDisplayPlaneProperties2KHR {
+    VkStructureType                sType;
+    void*                          pNext;
+    VkDisplayPlanePropertiesKHR    displayPlaneProperties;
+} VkDisplayPlaneProperties2KHR;
+
+typedef struct VkDisplayModeProperties2KHR {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkDisplayModePropertiesKHR    displayModeProperties;
+} VkDisplayModeProperties2KHR;
+
+typedef struct VkDisplayPlaneInfo2KHR {
+    VkStructureType     sType;
+    const void*         pNext;
+    VkDisplayModeKHR    mode;
+    uint32_t            planeIndex;
+} VkDisplayPlaneInfo2KHR;
+
+typedef struct VkDisplayPlaneCapabilities2KHR {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkDisplayPlaneCapabilitiesKHR    capabilities;
+} VkDisplayPlaneCapabilities2KHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayProperties2KHR*                    pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPlaneProperties2KHR*               pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayModeProperties2KHR*                pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
+    VkDisplayPlaneCapabilities2KHR*             pCapabilities);
+#endif
+
+
+#define VK_KHR_dedicated_allocation 1
+#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
+#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
+typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
+
+typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
+
+
+
+#define VK_KHR_storage_buffer_storage_class 1
+#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
+#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
+
+
+#define VK_KHR_relaxed_block_layout 1
+#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
+
+
+#define VK_KHR_get_memory_requirements2 1
+#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
+#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
+typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
+
+typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
+
+typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
+
+typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
+
+typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkImageMemoryRequirementsInfo2*       pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkBufferMemoryRequirementsInfo2*      pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
+#endif
+
+
+#define VK_KHR_image_format_list 1
+#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
+#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
+typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
+
+
+
+#define VK_KHR_sampler_ycbcr_conversion 1
+typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
+
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
+typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
+
+typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
+
+typedef VkChromaLocation VkChromaLocationKHR;
+
+typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
+
+typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
+
+typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
+
+typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
+
+typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
+
+typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
+typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
+    VkDevice                                    device,
+    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSamplerYcbcrConversion*                   pYcbcrConversion);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
+    VkDevice                                    device,
+    VkSamplerYcbcrConversion                    ycbcrConversion,
+    const VkAllocationCallbacks*                pAllocator);
+#endif
+
+
+#define VK_KHR_bind_memory2 1
+#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
+#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
+typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
+
+typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindBufferMemoryInfo*               pBindInfos);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindImageMemoryInfo*                pBindInfos);
+#endif
+
+
+#define VK_KHR_maintenance3 1
+#define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
+#define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
+typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
+
+typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
+
+typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    VkDescriptorSetLayoutSupport*               pSupport);
+#endif
+
+
+#define VK_KHR_draw_indirect_count 1
+#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
+#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+
+#define VK_KHR_shader_subgroup_extended_types 1
+#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
+#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
+typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+
+
+
+#define VK_KHR_8bit_storage 1
+#define VK_KHR_8BIT_STORAGE_SPEC_VERSION  1
+#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
+typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;
+
+
+
+#define VK_KHR_shader_atomic_int64 1
+#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
+#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
+typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
+
+
+
+#define VK_KHR_shader_clock 1
+#define VK_KHR_SHADER_CLOCK_SPEC_VERSION  1
+#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
+typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSubgroupClock;
+    VkBool32           shaderDeviceClock;
+} VkPhysicalDeviceShaderClockFeaturesKHR;
+
+
+
+#define VK_KHR_driver_properties 1
+#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
+#define VK_MAX_DRIVER_NAME_SIZE_KHR       VK_MAX_DRIVER_NAME_SIZE
+#define VK_MAX_DRIVER_INFO_SIZE_KHR       VK_MAX_DRIVER_INFO_SIZE
+typedef VkDriverId VkDriverIdKHR;
+
+typedef VkConformanceVersion VkConformanceVersionKHR;
+
+typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;
+
+
+
+#define VK_KHR_shader_float_controls 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
+#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
+typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;
+
+typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;
+
+
+
+#define VK_KHR_depth_stencil_resolve 1
+#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
+#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
+typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;
+
+typedef VkResolveModeFlags VkResolveModeFlagsKHR;
+
+typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;
+
+typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
+
+
+
+#define VK_KHR_swapchain_mutable_format 1
+#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
+#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
+
+
+#define VK_KHR_timeline_semaphore 1
+#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
+#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
+typedef VkSemaphoreType VkSemaphoreTypeKHR;
+
+typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;
+
+typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;
+
+typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
+
+typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
+
+typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
+
+typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
+
+typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
+
+typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
+typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
+typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(
+    VkDevice                                    device,
+    VkSemaphore                                 semaphore,
+    uint64_t*                                   pValue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(
+    VkDevice                                    device,
+    const VkSemaphoreWaitInfo*                  pWaitInfo,
+    uint64_t                                    timeout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(
+    VkDevice                                    device,
+    const VkSemaphoreSignalInfo*                pSignalInfo);
+#endif
+
+
+#define VK_KHR_vulkan_memory_model 1
+#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
+#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
+typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
+
+
+
+#define VK_KHR_shader_terminate_invocation 1
+#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1
+#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation"
+typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderTerminateInvocation;
+} VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
+
+
+
+#define VK_KHR_fragment_shading_rate 1
+#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 1
+#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate"
+
+typedef enum VkFragmentShadingRateCombinerOpKHR {
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0,
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1,
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2,
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3,
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4,
+    VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkFragmentShadingRateCombinerOpKHR;
+typedef struct VkFragmentShadingRateAttachmentInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    const VkAttachmentReference2*    pFragmentShadingRateAttachment;
+    VkExtent2D                       shadingRateAttachmentTexelSize;
+} VkFragmentShadingRateAttachmentInfoKHR;
+
+typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExtent2D                            fragmentSize;
+    VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
+} VkPipelineFragmentShadingRateStateCreateInfoKHR;
+
+typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           pipelineFragmentShadingRate;
+    VkBool32           primitiveFragmentShadingRate;
+    VkBool32           attachmentFragmentShadingRate;
+} VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
+
+typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
+    VkStructureType          sType;
+    void*                    pNext;
+    VkExtent2D               minFragmentShadingRateAttachmentTexelSize;
+    VkExtent2D               maxFragmentShadingRateAttachmentTexelSize;
+    uint32_t                 maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    VkBool32                 primitiveFragmentShadingRateWithMultipleViewports;
+    VkBool32                 layeredShadingRateAttachments;
+    VkBool32                 fragmentShadingRateNonTrivialCombinerOps;
+    VkExtent2D               maxFragmentSize;
+    uint32_t                 maxFragmentSizeAspectRatio;
+    uint32_t                 maxFragmentShadingRateCoverageSamples;
+    VkSampleCountFlagBits    maxFragmentShadingRateRasterizationSamples;
+    VkBool32                 fragmentShadingRateWithShaderDepthStencilWrites;
+    VkBool32                 fragmentShadingRateWithSampleMask;
+    VkBool32                 fragmentShadingRateWithShaderSampleMask;
+    VkBool32                 fragmentShadingRateWithConservativeRasterization;
+    VkBool32                 fragmentShadingRateWithFragmentShaderInterlock;
+    VkBool32                 fragmentShadingRateWithCustomSampleLocations;
+    VkBool32                 fragmentShadingRateStrictMultiplyCombiner;
+} VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
+
+typedef struct VkPhysicalDeviceFragmentShadingRateKHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkSampleCountFlags    sampleCounts;
+    VkExtent2D            fragmentSize;
+} VkPhysicalDeviceFragmentShadingRateKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
+typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer           commandBuffer, const VkExtent2D*                           pFragmentSize, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pFragmentShadingRateCount,
+    VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkExtent2D*                           pFragmentSize,
+    const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
+#endif
+
+
+#define VK_KHR_spirv_1_4 1
+#define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
+#define VK_KHR_SPIRV_1_4_EXTENSION_NAME   "VK_KHR_spirv_1_4"
+
+
+#define VK_KHR_surface_protected_capabilities 1
+#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
+typedef struct VkSurfaceProtectedCapabilitiesKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           supportsProtected;
+} VkSurfaceProtectedCapabilitiesKHR;
+
+
+
+#define VK_KHR_separate_depth_stencil_layouts 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
+typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+
+typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;
+
+typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;
+
+
+
+#define VK_KHR_present_wait 1
+#define VK_KHR_PRESENT_WAIT_SPEC_VERSION  1
+#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait"
+typedef struct VkPhysicalDevicePresentWaitFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           presentWait;
+} VkPhysicalDevicePresentWaitFeaturesKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint64_t                                    presentId,
+    uint64_t                                    timeout);
+#endif
+
+
+#define VK_KHR_uniform_buffer_standard_layout 1
+#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
+typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
+
+
+
+#define VK_KHR_buffer_device_address 1
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
+typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
+
+typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;
+
+typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
+
+typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
+
+typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
+
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
+    VkDevice                                    device,
+    const VkBufferDeviceAddressInfo*            pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
+    VkDevice                                    device,
+    const VkBufferDeviceAddressInfo*            pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+    VkDevice                                    device,
+    const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+#endif
+
+
+#define VK_KHR_deferred_host_operations 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR)
+#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4
+#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);
+typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator);
+typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation);
+typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(
+    VkDevice                                    device,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDeferredOperationKHR*                     pDeferredOperation);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      operation,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      operation);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      operation);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      operation);
+#endif
+
+
+#define VK_KHR_pipeline_executable_properties 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
+
+typedef enum VkPipelineExecutableStatisticFormatKHR {
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPipelineExecutableStatisticFormatKHR;
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
+typedef struct VkPipelineInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkPipeline         pipeline;
+} VkPipelineInfoKHR;
+
+typedef struct VkPipelineExecutablePropertiesKHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkShaderStageFlags    stages;
+    char                  name[VK_MAX_DESCRIPTION_SIZE];
+    char                  description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t              subgroupSize;
+} VkPipelineExecutablePropertiesKHR;
+
+typedef struct VkPipelineExecutableInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkPipeline         pipeline;
+    uint32_t           executableIndex;
+} VkPipelineExecutableInfoKHR;
+
+typedef union VkPipelineExecutableStatisticValueKHR {
+    VkBool32    b32;
+    int64_t     i64;
+    uint64_t    u64;
+    double      f64;
+} VkPipelineExecutableStatisticValueKHR;
+
+typedef struct VkPipelineExecutableStatisticKHR {
+    VkStructureType                           sType;
+    void*                                     pNext;
+    char                                      name[VK_MAX_DESCRIPTION_SIZE];
+    char                                      description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR    format;
+    VkPipelineExecutableStatisticValueKHR     value;
+} VkPipelineExecutableStatisticKHR;
+
+typedef struct VkPipelineExecutableInternalRepresentationKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    char               name[VK_MAX_DESCRIPTION_SIZE];
+    char               description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32           isText;
+    size_t             dataSize;
+    void*              pData;
+} VkPipelineExecutableInternalRepresentationKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+#endif
+
+
+#define VK_KHR_pipeline_library 1
+#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"
+typedef struct VkPipelineLibraryCreateInfoKHR {
+    VkStructureType      sType;
+    const void*          pNext;
+    uint32_t             libraryCount;
+    const VkPipeline*    pLibraries;
+} VkPipelineLibraryCreateInfoKHR;
+
+
+
+#define VK_KHR_shader_non_semantic_info 1
+#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1
+#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"
+
+
+#define VK_KHR_present_id 1
+#define VK_KHR_PRESENT_ID_SPEC_VERSION    1
+#define VK_KHR_PRESENT_ID_EXTENSION_NAME  "VK_KHR_present_id"
+typedef struct VkPresentIdKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           swapchainCount;
+    const uint64_t*    pPresentIds;
+} VkPresentIdKHR;
+
+typedef struct VkPhysicalDevicePresentIdFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           presentId;
+} VkPhysicalDevicePresentIdFeaturesKHR;
+
+
+
+#define VK_KHR_synchronization2 1
+typedef uint64_t VkFlags64;
+#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1
+#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2"
+typedef VkFlags64 VkPipelineStageFlags2KHR;
+
+// Flag bits for VkPipelineStageFlagBits2KHR
+typedef VkFlags64 VkPipelineStageFlagBits2KHR;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;
+#endif
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL;
+static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL;
+
+typedef VkFlags64 VkAccessFlags2KHR;
+
+// Flag bits for VkAccessFlagBits2KHR
+typedef VkFlags64 VkAccessFlagBits2KHR;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR = 0ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
+#endif
+static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;
+static const VkAccessFlagBits2KHR VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL;
+
+
+typedef enum VkSubmitFlagBitsKHR {
+    VK_SUBMIT_PROTECTED_BIT_KHR = 0x00000001,
+    VK_SUBMIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSubmitFlagBitsKHR;
+typedef VkFlags VkSubmitFlagsKHR;
+typedef struct VkMemoryBarrier2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkPipelineStageFlags2KHR    srcStageMask;
+    VkAccessFlags2KHR           srcAccessMask;
+    VkPipelineStageFlags2KHR    dstStageMask;
+    VkAccessFlags2KHR           dstAccessMask;
+} VkMemoryBarrier2KHR;
+
+typedef struct VkBufferMemoryBarrier2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkPipelineStageFlags2KHR    srcStageMask;
+    VkAccessFlags2KHR           srcAccessMask;
+    VkPipelineStageFlags2KHR    dstStageMask;
+    VkAccessFlags2KHR           dstAccessMask;
+    uint32_t                    srcQueueFamilyIndex;
+    uint32_t                    dstQueueFamilyIndex;
+    VkBuffer                    buffer;
+    VkDeviceSize                offset;
+    VkDeviceSize                size;
+} VkBufferMemoryBarrier2KHR;
+
+typedef struct VkImageMemoryBarrier2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkPipelineStageFlags2KHR    srcStageMask;
+    VkAccessFlags2KHR           srcAccessMask;
+    VkPipelineStageFlags2KHR    dstStageMask;
+    VkAccessFlags2KHR           dstAccessMask;
+    VkImageLayout               oldLayout;
+    VkImageLayout               newLayout;
+    uint32_t                    srcQueueFamilyIndex;
+    uint32_t                    dstQueueFamilyIndex;
+    VkImage                     image;
+    VkImageSubresourceRange     subresourceRange;
+} VkImageMemoryBarrier2KHR;
+
+typedef struct VkDependencyInfoKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkDependencyFlags                   dependencyFlags;
+    uint32_t                            memoryBarrierCount;
+    const VkMemoryBarrier2KHR*          pMemoryBarriers;
+    uint32_t                            bufferMemoryBarrierCount;
+    const VkBufferMemoryBarrier2KHR*    pBufferMemoryBarriers;
+    uint32_t                            imageMemoryBarrierCount;
+    const VkImageMemoryBarrier2KHR*     pImageMemoryBarriers;
+} VkDependencyInfoKHR;
+
+typedef struct VkSemaphoreSubmitInfoKHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSemaphore                 semaphore;
+    uint64_t                    value;
+    VkPipelineStageFlags2KHR    stageMask;
+    uint32_t                    deviceIndex;
+} VkSemaphoreSubmitInfoKHR;
+
+typedef struct VkCommandBufferSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkCommandBuffer    commandBuffer;
+    uint32_t           deviceMask;
+} VkCommandBufferSubmitInfoKHR;
+
+typedef struct VkSubmitInfo2KHR {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkSubmitFlagsKHR                       flags;
+    uint32_t                               waitSemaphoreInfoCount;
+    const VkSemaphoreSubmitInfoKHR*        pWaitSemaphoreInfos;
+    uint32_t                               commandBufferInfoCount;
+    const VkCommandBufferSubmitInfoKHR*    pCommandBufferInfos;
+    uint32_t                               signalSemaphoreInfoCount;
+    const VkSemaphoreSubmitInfoKHR*        pSignalSemaphoreInfos;
+} VkSubmitInfo2KHR;
+
+typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           synchronization2;
+} VkPhysicalDeviceSynchronization2FeaturesKHR;
+
+typedef struct VkQueueFamilyCheckpointProperties2NV {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkPipelineStageFlags2KHR    checkpointExecutionStageMask;
+} VkQueueFamilyCheckpointProperties2NV;
+
+typedef struct VkCheckpointData2NV {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkPipelineStageFlags2KHR    stage;
+    void*                       pCheckpointMarker;
+} VkCheckpointData2NV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfoKHR*                          pDependencyInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2KHR                            stageMask);
+typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfoKHR*         pDependencyInfos);
+typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer                   commandBuffer, const VkDependencyInfoKHR*                                pDependencyInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkQueryPool                                         queryPool, uint32_t                                            query);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2KHR*           pSubmits, VkFence           fence);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker);
+typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    const VkDependencyInfoKHR*                  pDependencyInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    VkPipelineStageFlags2KHR                    stageMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    eventCount,
+    const VkEvent*                              pEvents,
+    const VkDependencyInfoKHR*                  pDependencyInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkDependencyInfoKHR*                  pDependencyInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlags2KHR                    stage,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(
+    VkQueue                                     queue,
+    uint32_t                                    submitCount,
+    const VkSubmitInfo2KHR*                     pSubmits,
+    VkFence                                     fence);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlags2KHR                    stage,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    uint32_t                                    marker);
+
+VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(
+    VkQueue                                     queue,
+    uint32_t*                                   pCheckpointDataCount,
+    VkCheckpointData2NV*                        pCheckpointData);
+#endif
+
+
+#define VK_KHR_shader_subgroup_uniform_control_flow 1
+#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1
+#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow"
+typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSubgroupUniformControlFlow;
+} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
+
+
+
+#define VK_KHR_zero_initialize_workgroup_memory 1
+#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1
+#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory"
+typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderZeroInitializeWorkgroupMemory;
+} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
+
+
+
+#define VK_KHR_workgroup_memory_explicit_layout 1
+#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout"
+typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           workgroupMemoryExplicitLayout;
+    VkBool32           workgroupMemoryExplicitLayoutScalarBlockLayout;
+    VkBool32           workgroupMemoryExplicitLayout8BitAccess;
+    VkBool32           workgroupMemoryExplicitLayout16BitAccess;
+} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
+
+
+
+#define VK_KHR_copy_commands2 1
+#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1
+#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2"
+typedef struct VkBufferCopy2KHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceSize       srcOffset;
+    VkDeviceSize       dstOffset;
+    VkDeviceSize       size;
+} VkBufferCopy2KHR;
+
+typedef struct VkCopyBufferInfo2KHR {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkBuffer                   srcBuffer;
+    VkBuffer                   dstBuffer;
+    uint32_t                   regionCount;
+    const VkBufferCopy2KHR*    pRegions;
+} VkCopyBufferInfo2KHR;
+
+typedef struct VkImageCopy2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageCopy2KHR;
+
+typedef struct VkCopyImageInfo2KHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkImage                   srcImage;
+    VkImageLayout             srcImageLayout;
+    VkImage                   dstImage;
+    VkImageLayout             dstImageLayout;
+    uint32_t                  regionCount;
+    const VkImageCopy2KHR*    pRegions;
+} VkCopyImageInfo2KHR;
+
+typedef struct VkBufferImageCopy2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkDeviceSize                bufferOffset;
+    uint32_t                    bufferRowLength;
+    uint32_t                    bufferImageHeight;
+    VkImageSubresourceLayers    imageSubresource;
+    VkOffset3D                  imageOffset;
+    VkExtent3D                  imageExtent;
+} VkBufferImageCopy2KHR;
+
+typedef struct VkCopyBufferToImageInfo2KHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkBuffer                        srcBuffer;
+    VkImage                         dstImage;
+    VkImageLayout                   dstImageLayout;
+    uint32_t                        regionCount;
+    const VkBufferImageCopy2KHR*    pRegions;
+} VkCopyBufferToImageInfo2KHR;
+
+typedef struct VkCopyImageToBufferInfo2KHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkImage                         srcImage;
+    VkImageLayout                   srcImageLayout;
+    VkBuffer                        dstBuffer;
+    uint32_t                        regionCount;
+    const VkBufferImageCopy2KHR*    pRegions;
+} VkCopyImageToBufferInfo2KHR;
+
+typedef struct VkImageBlit2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffsets[2];
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffsets[2];
+} VkImageBlit2KHR;
+
+typedef struct VkBlitImageInfo2KHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkImage                   srcImage;
+    VkImageLayout             srcImageLayout;
+    VkImage                   dstImage;
+    VkImageLayout             dstImageLayout;
+    uint32_t                  regionCount;
+    const VkImageBlit2KHR*    pRegions;
+    VkFilter                  filter;
+} VkBlitImageInfo2KHR;
+
+typedef struct VkImageResolve2KHR {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageResolve2KHR;
+
+typedef struct VkResolveImageInfo2KHR {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkImage                      srcImage;
+    VkImageLayout                srcImageLayout;
+    VkImage                      dstImage;
+    VkImageLayout                dstImageLayout;
+    uint32_t                     regionCount;
+    const VkImageResolve2KHR*    pRegions;
+} VkResolveImageInfo2KHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyImageInfo2KHR*                  pCopyImageInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkBlitImageInfo2KHR*                  pBlitImageInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkResolveImageInfo2KHR*               pResolveImageInfo);
+#endif
+
+
+#define VK_EXT_debug_report 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
+#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  10
+#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
+
+typedef enum VkDebugReportObjectTypeEXT {
+    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
+    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
+    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
+    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
+    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
+    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
+    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
+    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
+    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
+    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
+    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
+    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
+    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001,
+    VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugReportObjectTypeEXT;
+
+typedef enum VkDebugReportFlagBitsEXT {
+    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
+    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
+    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
+    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
+    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
+    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugReportFlagBitsEXT;
+typedef VkFlags VkDebugReportFlagsEXT;
+typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
+    VkDebugReportFlagsEXT                       flags,
+    VkDebugReportObjectTypeEXT                  objectType,
+    uint64_t                                    object,
+    size_t                                      location,
+    int32_t                                     messageCode,
+    const char*                                 pLayerPrefix,
+    const char*                                 pMessage,
+    void*                                       pUserData);
+
+typedef struct VkDebugReportCallbackCreateInfoEXT {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkDebugReportFlagsEXT           flags;
+    PFN_vkDebugReportCallbackEXT    pfnCallback;
+    void*                           pUserData;
+} VkDebugReportCallbackCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
+typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
+    VkInstance                                  instance,
+    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDebugReportCallbackEXT*                   pCallback);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
+    VkInstance                                  instance,
+    VkDebugReportCallbackEXT                    callback,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
+    VkInstance                                  instance,
+    VkDebugReportFlagsEXT                       flags,
+    VkDebugReportObjectTypeEXT                  objectType,
+    uint64_t                                    object,
+    size_t                                      location,
+    int32_t                                     messageCode,
+    const char*                                 pLayerPrefix,
+    const char*                                 pMessage);
+#endif
+
+
+#define VK_NV_glsl_shader 1
+#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
+#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
+
+
+#define VK_EXT_depth_range_unrestricted 1
+#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
+#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
+
+
+#define VK_IMG_filter_cubic 1
+#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
+#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
+
+
+#define VK_AMD_rasterization_order 1
+#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
+#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
+
+typedef enum VkRasterizationOrderAMD {
+    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
+    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
+    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkRasterizationOrderAMD;
+typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkRasterizationOrderAMD    rasterizationOrder;
+} VkPipelineRasterizationStateRasterizationOrderAMD;
+
+
+
+#define VK_AMD_shader_trinary_minmax 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
+
+
+#define VK_AMD_shader_explicit_vertex_parameter 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
+
+
+#define VK_EXT_debug_marker 1
+#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
+#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
+typedef struct VkDebugMarkerObjectNameInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    const char*                   pObjectName;
+} VkDebugMarkerObjectNameInfoEXT;
+
+typedef struct VkDebugMarkerObjectTagInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    uint64_t                      tagName;
+    size_t                        tagSize;
+    const void*                   pTag;
+} VkDebugMarkerObjectTagInfoEXT;
+
+typedef struct VkDebugMarkerMarkerInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pMarkerName;
+    float              color[4];
+} VkDebugMarkerMarkerInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
+    VkDevice                                    device,
+    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
+    VkDevice                                    device,
+    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
+#endif
+
+
+#define VK_AMD_gcn_shader 1
+#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
+#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
+
+
+#define VK_NV_dedicated_allocation 1
+#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
+#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
+typedef struct VkDedicatedAllocationImageCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationImageCreateInfoNV;
+
+typedef struct VkDedicatedAllocationBufferCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationBufferCreateInfoNV;
+
+typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkBuffer           buffer;
+} VkDedicatedAllocationMemoryAllocateInfoNV;
+
+
+
+#define VK_EXT_transform_feedback 1
+#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
+#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
+typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
+typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           transformFeedback;
+    VkBool32           geometryStreams;
+} VkPhysicalDeviceTransformFeedbackFeaturesEXT;
+
+typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxTransformFeedbackStreams;
+    uint32_t           maxTransformFeedbackBuffers;
+    VkDeviceSize       maxTransformFeedbackBufferSize;
+    uint32_t           maxTransformFeedbackStreamDataSize;
+    uint32_t           maxTransformFeedbackBufferDataSize;
+    uint32_t           maxTransformFeedbackBufferDataStride;
+    VkBool32           transformFeedbackQueries;
+    VkBool32           transformFeedbackStreamsLinesTriangles;
+    VkBool32           transformFeedbackRasterizationStreamSelect;
+    VkBool32           transformFeedbackDraw;
+} VkPhysicalDeviceTransformFeedbackPropertiesEXT;
+
+typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
+    uint32_t                                            rasterizationStream;
+} VkPipelineRasterizationStateStreamCreateInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
+typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkDeviceSize*                         pOffsets,
+    const VkDeviceSize*                         pSizes);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstCounterBuffer,
+    uint32_t                                    counterBufferCount,
+    const VkBuffer*                             pCounterBuffers,
+    const VkDeviceSize*                         pCounterBufferOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstCounterBuffer,
+    uint32_t                                    counterBufferCount,
+    const VkBuffer*                             pCounterBuffers,
+    const VkDeviceSize*                         pCounterBufferOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query,
+    VkQueryControlFlags                         flags,
+    uint32_t                                    index);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query,
+    uint32_t                                    index);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstInstance,
+    VkBuffer                                    counterBuffer,
+    VkDeviceSize                                counterBufferOffset,
+    uint32_t                                    counterOffset,
+    uint32_t                                    vertexStride);
+#endif
+
+
+#define VK_NVX_binary_import 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX)
+#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1
+#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import"
+typedef struct VkCuModuleCreateInfoNVX {
+    VkStructureType    sType;
+    const void*        pNext;
+    size_t             dataSize;
+    const void*        pData;
+} VkCuModuleCreateInfoNVX;
+
+typedef struct VkCuFunctionCreateInfoNVX {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkCuModuleNVX      module;
+    const char*        pName;
+} VkCuFunctionCreateInfoNVX;
+
+typedef struct VkCuLaunchInfoNVX {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkCuFunctionNVX        function;
+    uint32_t               gridDimX;
+    uint32_t               gridDimY;
+    uint32_t               gridDimZ;
+    uint32_t               blockDimX;
+    uint32_t               blockDimY;
+    uint32_t               blockDimZ;
+    uint32_t               sharedMemBytes;
+    size_t                 paramCount;
+    const void* const *    pParams;
+    size_t                 extraCount;
+    const void* const *    pExtras;
+} VkCuLaunchInfoNVX;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);
+typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(
+    VkDevice                                    device,
+    const VkCuModuleCreateInfoNVX*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCuModuleNVX*                              pModule);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(
+    VkDevice                                    device,
+    const VkCuFunctionCreateInfoNVX*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCuFunctionNVX*                            pFunction);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(
+    VkDevice                                    device,
+    VkCuModuleNVX                               module,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(
+    VkDevice                                    device,
+    VkCuFunctionNVX                             function,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(
+    VkCommandBuffer                             commandBuffer,
+    const VkCuLaunchInfoNVX*                    pLaunchInfo);
+#endif
+
+
+#define VK_NVX_image_view_handle 1
+#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2
+#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
+typedef struct VkImageViewHandleInfoNVX {
+    VkStructureType     sType;
+    const void*         pNext;
+    VkImageView         imageView;
+    VkDescriptorType    descriptorType;
+    VkSampler           sampler;
+} VkImageViewHandleInfoNVX;
+
+typedef struct VkImageViewAddressPropertiesNVX {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceAddress    deviceAddress;
+    VkDeviceSize       size;
+} VkImageViewAddressPropertiesNVX;
+
+typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
+    VkDevice                                    device,
+    const VkImageViewHandleInfoNVX*             pInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(
+    VkDevice                                    device,
+    VkImageView                                 imageView,
+    VkImageViewAddressPropertiesNVX*            pProperties);
+#endif
+
+
+#define VK_AMD_draw_indirect_count 1
+#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
+#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+
+#define VK_AMD_negative_viewport_height 1
+#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
+#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
+
+
+#define VK_AMD_gpu_shader_half_float 1
+#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
+#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
+
+
+#define VK_AMD_shader_ballot 1
+#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
+#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
+
+
+#define VK_AMD_texture_gather_bias_lod 1
+#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
+#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
+typedef struct VkTextureLODGatherFormatPropertiesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           supportsTextureGatherLODBiasAMD;
+} VkTextureLODGatherFormatPropertiesAMD;
+
+
+
+#define VK_AMD_shader_info 1
+#define VK_AMD_SHADER_INFO_SPEC_VERSION   1
+#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
+
+typedef enum VkShaderInfoTypeAMD {
+    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
+    VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
+    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
+    VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkShaderInfoTypeAMD;
+typedef struct VkShaderResourceUsageAMD {
+    uint32_t    numUsedVgprs;
+    uint32_t    numUsedSgprs;
+    uint32_t    ldsSizePerLocalWorkGroup;
+    size_t      ldsUsageSizeInBytes;
+    size_t      scratchMemUsageInBytes;
+} VkShaderResourceUsageAMD;
+
+typedef struct VkShaderStatisticsInfoAMD {
+    VkShaderStageFlags          shaderStageMask;
+    VkShaderResourceUsageAMD    resourceUsage;
+    uint32_t                    numPhysicalVgprs;
+    uint32_t                    numPhysicalSgprs;
+    uint32_t                    numAvailableVgprs;
+    uint32_t                    numAvailableSgprs;
+    uint32_t                    computeWorkGroupSize[3];
+} VkShaderStatisticsInfoAMD;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    VkShaderStageFlagBits                       shaderStage,
+    VkShaderInfoTypeAMD                         infoType,
+    size_t*                                     pInfoSize,
+    void*                                       pInfo);
+#endif
+
+
+#define VK_AMD_shader_image_load_store_lod 1
+#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
+#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
+
+
+#define VK_NV_corner_sampled_image 1
+#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
+#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
+typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cornerSampledImage;
+} VkPhysicalDeviceCornerSampledImageFeaturesNV;
+
+
+
+#define VK_IMG_format_pvrtc 1
+#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
+#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
+
+
+#define VK_NV_external_memory_capabilities 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
+
+typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBitsNV;
+typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
+
+typedef enum VkExternalMemoryFeatureFlagBitsNV {
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBitsNV;
+typedef VkFlags VkExternalMemoryFeatureFlagsNV;
+typedef struct VkExternalImageFormatPropertiesNV {
+    VkImageFormatProperties              imageFormatProperties;
+    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
+    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
+    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
+} VkExternalImageFormatPropertiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkImageTiling                               tiling,
+    VkImageUsageFlags                           usage,
+    VkImageCreateFlags                          flags,
+    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
+    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
+#endif
+
+
+#define VK_NV_external_memory 1
+#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
+typedef struct VkExternalMemoryImageCreateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExternalMemoryImageCreateInfoNV;
+
+typedef struct VkExportMemoryAllocateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExportMemoryAllocateInfoNV;
+
+
+
+#define VK_EXT_validation_flags 1
+#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
+#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
+
+typedef enum VkValidationCheckEXT {
+    VK_VALIDATION_CHECK_ALL_EXT = 0,
+    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
+    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationCheckEXT;
+typedef struct VkValidationFlagsEXT {
+    VkStructureType                sType;
+    const void*                    pNext;
+    uint32_t                       disabledValidationCheckCount;
+    const VkValidationCheckEXT*    pDisabledValidationChecks;
+} VkValidationFlagsEXT;
+
+
+
+#define VK_EXT_shader_subgroup_ballot 1
+#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
+#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
+
+
+#define VK_EXT_shader_subgroup_vote 1
+#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
+#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
+
+
+#define VK_EXT_texture_compression_astc_hdr 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
+typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           textureCompressionASTC_HDR;
+} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+
+
+
+#define VK_EXT_astc_decode_mode 1
+#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
+#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
+typedef struct VkImageViewASTCDecodeModeEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkFormat           decodeMode;
+} VkImageViewASTCDecodeModeEXT;
+
+typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           decodeModeSharedExponent;
+} VkPhysicalDeviceASTCDecodeFeaturesEXT;
+
+
+
+#define VK_EXT_conditional_rendering 1
+#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
+#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
+
+typedef enum VkConditionalRenderingFlagBitsEXT {
+    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
+    VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkConditionalRenderingFlagBitsEXT;
+typedef VkFlags VkConditionalRenderingFlagsEXT;
+typedef struct VkConditionalRenderingBeginInfoEXT {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkBuffer                          buffer;
+    VkDeviceSize                      offset;
+    VkConditionalRenderingFlagsEXT    flags;
+} VkConditionalRenderingBeginInfoEXT;
+
+typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           conditionalRendering;
+    VkBool32           inheritedConditionalRendering;
+} VkPhysicalDeviceConditionalRenderingFeaturesEXT;
+
+typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           conditionalRenderingEnable;
+} VkCommandBufferInheritanceConditionalRenderingInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
+    VkCommandBuffer                             commandBuffer);
+#endif
+
+
+#define VK_NV_clip_space_w_scaling 1
+#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
+#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
+typedef struct VkViewportWScalingNV {
+    float    xcoeff;
+    float    ycoeff;
+} VkViewportWScalingNV;
+
+typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkBool32                       viewportWScalingEnable;
+    uint32_t                       viewportCount;
+    const VkViewportWScalingNV*    pViewportWScalings;
+} VkPipelineViewportWScalingStateCreateInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkViewportWScalingNV*                 pViewportWScalings);
+#endif
+
+
+#define VK_EXT_direct_mode_display 1
+#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
+typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display);
+#endif
+
+
+#define VK_EXT_display_surface_counter 1
+#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
+#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
+
+typedef enum VkSurfaceCounterFlagBitsEXT {
+    VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001,
+    VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT,
+    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkSurfaceCounterFlagBitsEXT;
+typedef VkFlags VkSurfaceCounterFlagsEXT;
+typedef struct VkSurfaceCapabilities2EXT {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         minImageCount;
+    uint32_t                         maxImageCount;
+    VkExtent2D                       currentExtent;
+    VkExtent2D                       minImageExtent;
+    VkExtent2D                       maxImageExtent;
+    uint32_t                         maxImageArrayLayers;
+    VkSurfaceTransformFlagsKHR       supportedTransforms;
+    VkSurfaceTransformFlagBitsKHR    currentTransform;
+    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
+    VkImageUsageFlags                supportedUsageFlags;
+    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
+} VkSurfaceCapabilities2EXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
+#endif
+
+
+#define VK_EXT_display_control 1
+#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
+#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
+
+typedef enum VkDisplayPowerStateEXT {
+    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
+    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
+    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
+    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDisplayPowerStateEXT;
+
+typedef enum VkDeviceEventTypeEXT {
+    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
+    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDeviceEventTypeEXT;
+
+typedef enum VkDisplayEventTypeEXT {
+    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
+    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDisplayEventTypeEXT;
+typedef struct VkDisplayPowerInfoEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkDisplayPowerStateEXT    powerState;
+} VkDisplayPowerInfoEXT;
+
+typedef struct VkDeviceEventInfoEXT {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkDeviceEventTypeEXT    deviceEvent;
+} VkDeviceEventInfoEXT;
+
+typedef struct VkDisplayEventInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkDisplayEventTypeEXT    displayEvent;
+} VkDisplayEventInfoEXT;
+
+typedef struct VkSwapchainCounterCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSurfaceCounterFlagsEXT    surfaceCounters;
+} VkSwapchainCounterCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
+    VkDevice                                    device,
+    VkDisplayKHR                                display,
+    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
+    VkDevice                                    device,
+    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
+    VkDevice                                    device,
+    VkDisplayKHR                                display,
+    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    VkSurfaceCounterFlagBitsEXT                 counter,
+    uint64_t*                                   pCounterValue);
+#endif
+
+
+#define VK_GOOGLE_display_timing 1
+#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
+#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
+typedef struct VkRefreshCycleDurationGOOGLE {
+    uint64_t    refreshDuration;
+} VkRefreshCycleDurationGOOGLE;
+
+typedef struct VkPastPresentationTimingGOOGLE {
+    uint32_t    presentID;
+    uint64_t    desiredPresentTime;
+    uint64_t    actualPresentTime;
+    uint64_t    earliestPresentTime;
+    uint64_t    presentMargin;
+} VkPastPresentationTimingGOOGLE;
+
+typedef struct VkPresentTimeGOOGLE {
+    uint32_t    presentID;
+    uint64_t    desiredPresentTime;
+} VkPresentTimeGOOGLE;
+
+typedef struct VkPresentTimesInfoGOOGLE {
+    VkStructureType               sType;
+    const void*                   pNext;
+    uint32_t                      swapchainCount;
+    const VkPresentTimeGOOGLE*    pTimes;
+} VkPresentTimesInfoGOOGLE;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint32_t*                                   pPresentationTimingCount,
+    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
+#endif
+
+
+#define VK_NV_sample_mask_override_coverage 1
+#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
+#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
+
+
+#define VK_NV_geometry_shader_passthrough 1
+#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
+#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
+
+
+#define VK_NV_viewport_array2 1
+#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
+#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
+
+
+#define VK_NVX_multiview_per_view_attributes 1
+#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
+#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
+typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           perViewPositionAllComponents;
+} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+
+
+
+#define VK_NV_viewport_swizzle 1
+#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
+#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
+
+typedef enum VkViewportCoordinateSwizzleNV {
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkViewportCoordinateSwizzleNV;
+typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
+typedef struct VkViewportSwizzleNV {
+    VkViewportCoordinateSwizzleNV    x;
+    VkViewportCoordinateSwizzleNV    y;
+    VkViewportCoordinateSwizzleNV    z;
+    VkViewportCoordinateSwizzleNV    w;
+} VkViewportSwizzleNV;
+
+typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
+    uint32_t                                       viewportCount;
+    const VkViewportSwizzleNV*                     pViewportSwizzles;
+} VkPipelineViewportSwizzleStateCreateInfoNV;
+
+
+
+#define VK_EXT_discard_rectangles 1
+#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
+#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
+
+typedef enum VkDiscardRectangleModeEXT {
+    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
+    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
+    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDiscardRectangleModeEXT;
+typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
+typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxDiscardRectangles;
+} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
+
+typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
+    VkDiscardRectangleModeEXT                        discardRectangleMode;
+    uint32_t                                         discardRectangleCount;
+    const VkRect2D*                                  pDiscardRectangles;
+} VkPipelineDiscardRectangleStateCreateInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstDiscardRectangle,
+    uint32_t                                    discardRectangleCount,
+    const VkRect2D*                             pDiscardRectangles);
+#endif
+
+
+#define VK_EXT_conservative_rasterization 1
+#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
+#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
+
+typedef enum VkConservativeRasterizationModeEXT {
+    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkConservativeRasterizationModeEXT;
+typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
+typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    float              primitiveOverestimationSize;
+    float              maxExtraPrimitiveOverestimationSize;
+    float              extraPrimitiveOverestimationSizeGranularity;
+    VkBool32           primitiveUnderestimation;
+    VkBool32           conservativePointAndLineRasterization;
+    VkBool32           degenerateTrianglesRasterized;
+    VkBool32           degenerateLinesRasterized;
+    VkBool32           fullyCoveredFragmentShaderInputVariable;
+    VkBool32           conservativeRasterizationPostDepthCoverage;
+} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
+
+typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
+    VkStructureType                                           sType;
+    const void*                                               pNext;
+    VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
+    VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
+    float                                                     extraPrimitiveOverestimationSize;
+} VkPipelineRasterizationConservativeStateCreateInfoEXT;
+
+
+
+#define VK_EXT_depth_clip_enable 1
+#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
+#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
+typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
+typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           depthClipEnable;
+} VkPhysicalDeviceDepthClipEnableFeaturesEXT;
+
+typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
+    VkBool32                                               depthClipEnable;
+} VkPipelineRasterizationDepthClipStateCreateInfoEXT;
+
+
+
+#define VK_EXT_swapchain_colorspace 1
+#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
+#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
+
+
+#define VK_EXT_hdr_metadata 1
+#define VK_EXT_HDR_METADATA_SPEC_VERSION  2
+#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
+typedef struct VkXYColorEXT {
+    float    x;
+    float    y;
+} VkXYColorEXT;
+
+typedef struct VkHdrMetadataEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkXYColorEXT       displayPrimaryRed;
+    VkXYColorEXT       displayPrimaryGreen;
+    VkXYColorEXT       displayPrimaryBlue;
+    VkXYColorEXT       whitePoint;
+    float              maxLuminance;
+    float              minLuminance;
+    float              maxContentLightLevel;
+    float              maxFrameAverageLightLevel;
+} VkHdrMetadataEXT;
+
+typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
+    VkDevice                                    device,
+    uint32_t                                    swapchainCount,
+    const VkSwapchainKHR*                       pSwapchains,
+    const VkHdrMetadataEXT*                     pMetadata);
+#endif
+
+
+#define VK_EXT_external_memory_dma_buf 1
+#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
+
+
+#define VK_EXT_queue_family_foreign 1
+#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
+#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
+#define VK_QUEUE_FAMILY_FOREIGN_EXT       (~2U)
+
+
+#define VK_EXT_debug_utils 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
+#define VK_EXT_DEBUG_UTILS_SPEC_VERSION   2
+#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
+typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
+
+typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugUtilsMessageSeverityFlagBitsEXT;
+
+typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
+    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugUtilsMessageTypeFlagBitsEXT;
+typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
+typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
+typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
+typedef struct VkDebugUtilsLabelEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pLabelName;
+    float              color[4];
+} VkDebugUtilsLabelEXT;
+
+typedef struct VkDebugUtilsObjectNameInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkObjectType       objectType;
+    uint64_t           objectHandle;
+    const char*        pObjectName;
+} VkDebugUtilsObjectNameInfoEXT;
+
+typedef struct VkDebugUtilsMessengerCallbackDataEXT {
+    VkStructureType                              sType;
+    const void*                                  pNext;
+    VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
+    const char*                                  pMessageIdName;
+    int32_t                                      messageIdNumber;
+    const char*                                  pMessage;
+    uint32_t                                     queueLabelCount;
+    const VkDebugUtilsLabelEXT*                  pQueueLabels;
+    uint32_t                                     cmdBufLabelCount;
+    const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
+    uint32_t                                     objectCount;
+    const VkDebugUtilsObjectNameInfoEXT*         pObjects;
+} VkDebugUtilsMessengerCallbackDataEXT;
+
+typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
+    VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
+    const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
+    void*                                            pUserData);
+
+typedef struct VkDebugUtilsMessengerCreateInfoEXT {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkDebugUtilsMessengerCreateFlagsEXT     flags;
+    VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT         messageType;
+    PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
+    void*                                   pUserData;
+} VkDebugUtilsMessengerCreateInfoEXT;
+
+typedef struct VkDebugUtilsObjectTagInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkObjectType       objectType;
+    uint64_t           objectHandle;
+    uint64_t           tagName;
+    size_t             tagSize;
+    const void*        pTag;
+} VkDebugUtilsObjectTagInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
+typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
+typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
+    VkDevice                                    device,
+    const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
+    VkDevice                                    device,
+    const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
+    VkQueue                                     queue,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
+    VkQueue                                     queue);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
+    VkQueue                                     queue,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
+    VkInstance                                  instance,
+    const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDebugUtilsMessengerEXT*                   pMessenger);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
+    VkInstance                                  instance,
+    VkDebugUtilsMessengerEXT                    messenger,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
+    VkInstance                                  instance,
+    VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
+    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+
+
+#define VK_EXT_sampler_filter_minmax 1
+#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
+#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
+typedef VkSamplerReductionMode VkSamplerReductionModeEXT;
+
+typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;
+
+typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+
+
+
+#define VK_AMD_gpu_shader_int16 1
+#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
+#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
+
+
+#define VK_AMD_mixed_attachment_samples 1
+#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
+#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
+
+
+#define VK_AMD_shader_fragment_mask 1
+#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
+#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
+
+
+#define VK_EXT_inline_uniform_block 1
+#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
+#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
+typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           inlineUniformBlock;
+    VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
+} VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
+
+typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxInlineUniformBlockSize;
+    uint32_t           maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t           maxDescriptorSetInlineUniformBlocks;
+    uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+} VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
+
+typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           dataSize;
+    const void*        pData;
+} VkWriteDescriptorSetInlineUniformBlockEXT;
+
+typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           maxInlineUniformBlockBindings;
+} VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
+
+
+
+#define VK_EXT_shader_stencil_export 1
+#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
+#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
+
+
+#define VK_EXT_sample_locations 1
+#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
+#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
+typedef struct VkSampleLocationEXT {
+    float    x;
+    float    y;
+} VkSampleLocationEXT;
+
+typedef struct VkSampleLocationsInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkSampleCountFlagBits         sampleLocationsPerPixel;
+    VkExtent2D                    sampleLocationGridSize;
+    uint32_t                      sampleLocationsCount;
+    const VkSampleLocationEXT*    pSampleLocations;
+} VkSampleLocationsInfoEXT;
+
+typedef struct VkAttachmentSampleLocationsEXT {
+    uint32_t                    attachmentIndex;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkAttachmentSampleLocationsEXT;
+
+typedef struct VkSubpassSampleLocationsEXT {
+    uint32_t                    subpassIndex;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkSubpassSampleLocationsEXT;
+
+typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    uint32_t                                 attachmentInitialSampleLocationsCount;
+    const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
+    uint32_t                                 postSubpassSampleLocationsCount;
+    const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
+} VkRenderPassSampleLocationsBeginInfoEXT;
+
+typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkBool32                    sampleLocationsEnable;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkPipelineSampleLocationsStateCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkSampleCountFlags    sampleLocationSampleCounts;
+    VkExtent2D            maxSampleLocationGridSize;
+    float                 sampleLocationCoordinateRange[2];
+    uint32_t              sampleLocationSubPixelBits;
+    VkBool32              variableSampleLocations;
+} VkPhysicalDeviceSampleLocationsPropertiesEXT;
+
+typedef struct VkMultisamplePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         maxSampleLocationGridSize;
+} VkMultisamplePropertiesEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkSampleCountFlagBits                       samples,
+    VkMultisamplePropertiesEXT*                 pMultisampleProperties);
+#endif
+
+
+#define VK_EXT_blend_operation_advanced 1
+#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
+#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
+
+typedef enum VkBlendOverlapEXT {
+    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
+    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
+    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
+    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkBlendOverlapEXT;
+typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           advancedBlendCoherentOperations;
+} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+
+typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           advancedBlendMaxColorAttachments;
+    VkBool32           advancedBlendIndependentBlend;
+    VkBool32           advancedBlendNonPremultipliedSrcColor;
+    VkBool32           advancedBlendNonPremultipliedDstColor;
+    VkBool32           advancedBlendCorrelatedOverlap;
+    VkBool32           advancedBlendAllOperations;
+} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+
+typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkBool32             srcPremultiplied;
+    VkBool32             dstPremultiplied;
+    VkBlendOverlapEXT    blendOverlap;
+} VkPipelineColorBlendAdvancedStateCreateInfoEXT;
+
+
+
+#define VK_NV_fragment_coverage_to_color 1
+#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
+#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
+typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
+typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
+    VkBool32                                       coverageToColorEnable;
+    uint32_t                                       coverageToColorLocation;
+} VkPipelineCoverageToColorStateCreateInfoNV;
+
+
+
+#define VK_NV_framebuffer_mixed_samples 1
+#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
+#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
+
+typedef enum VkCoverageModulationModeNV {
+    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
+    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
+    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
+    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
+    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCoverageModulationModeNV;
+typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
+typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
+    VkStructureType                                   sType;
+    const void*                                       pNext;
+    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
+    VkCoverageModulationModeNV                        coverageModulationMode;
+    VkBool32                                          coverageModulationTableEnable;
+    uint32_t                                          coverageModulationTableCount;
+    const float*                                      pCoverageModulationTable;
+} VkPipelineCoverageModulationStateCreateInfoNV;
+
+
+
+#define VK_NV_fill_rectangle 1
+#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
+#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
+
+
+#define VK_NV_shader_sm_builtins 1
+#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
+#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
+typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderSMCount;
+    uint32_t           shaderWarpsPerSM;
+} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
+
+typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSMBuiltins;
+} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
+
+
+
+#define VK_EXT_post_depth_coverage 1
+#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
+#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
+
+
+#define VK_EXT_image_drm_format_modifier 1
+#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
+#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
+typedef struct VkDrmFormatModifierPropertiesEXT {
+    uint64_t                drmFormatModifier;
+    uint32_t                drmFormatModifierPlaneCount;
+    VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
+} VkDrmFormatModifierPropertiesEXT;
+
+typedef struct VkDrmFormatModifierPropertiesListEXT {
+    VkStructureType                      sType;
+    void*                                pNext;
+    uint32_t                             drmFormatModifierCount;
+    VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
+} VkDrmFormatModifierPropertiesListEXT;
+
+typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint64_t           drmFormatModifier;
+    VkSharingMode      sharingMode;
+    uint32_t           queueFamilyIndexCount;
+    const uint32_t*    pQueueFamilyIndices;
+} VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
+
+typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           drmFormatModifierCount;
+    const uint64_t*    pDrmFormatModifiers;
+} VkImageDrmFormatModifierListCreateInfoEXT;
+
+typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    uint64_t                      drmFormatModifier;
+    uint32_t                      drmFormatModifierPlaneCount;
+    const VkSubresourceLayout*    pPlaneLayouts;
+} VkImageDrmFormatModifierExplicitCreateInfoEXT;
+
+typedef struct VkImageDrmFormatModifierPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           drmFormatModifier;
+} VkImageDrmFormatModifierPropertiesEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(
+    VkDevice                                    device,
+    VkImage                                     image,
+    VkImageDrmFormatModifierPropertiesEXT*      pProperties);
+#endif
+
+
+#define VK_EXT_validation_cache 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
+#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
+
+typedef enum VkValidationCacheHeaderVersionEXT {
+    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
+    VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationCacheHeaderVersionEXT;
+typedef VkFlags VkValidationCacheCreateFlagsEXT;
+typedef struct VkValidationCacheCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkValidationCacheCreateFlagsEXT    flags;
+    size_t                             initialDataSize;
+    const void*                        pInitialData;
+} VkValidationCacheCreateInfoEXT;
+
+typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkValidationCacheEXT    validationCache;
+} VkShaderModuleValidationCacheCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
+typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
+typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
+    VkDevice                                    device,
+    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkValidationCacheEXT*                       pValidationCache);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        validationCache,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        dstCache,
+    uint32_t                                    srcCacheCount,
+    const VkValidationCacheEXT*                 pSrcCaches);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        validationCache,
+    size_t*                                     pDataSize,
+    void*                                       pData);
+#endif
+
+
+#define VK_EXT_descriptor_indexing 1
+#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
+#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
+typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;
+
+typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;
+
+typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+
+typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
+
+typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
+
+typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+
+typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+
+
+
+#define VK_EXT_shader_viewport_index_layer 1
+#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
+#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
+
+
+#define VK_NV_shading_rate_image 1
+#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
+#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
+
+typedef enum VkShadingRatePaletteEntryNV {
+    VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
+    VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
+    VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
+    VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
+    VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
+    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
+    VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
+} VkShadingRatePaletteEntryNV;
+
+typedef enum VkCoarseSampleOrderTypeNV {
+    VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
+    VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
+    VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
+    VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
+    VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCoarseSampleOrderTypeNV;
+typedef struct VkShadingRatePaletteNV {
+    uint32_t                              shadingRatePaletteEntryCount;
+    const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
+} VkShadingRatePaletteNV;
+
+typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkBool32                         shadingRateImageEnable;
+    uint32_t                         viewportCount;
+    const VkShadingRatePaletteNV*    pShadingRatePalettes;
+} VkPipelineViewportShadingRateImageStateCreateInfoNV;
+
+typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shadingRateImage;
+    VkBool32           shadingRateCoarseSampleOrder;
+} VkPhysicalDeviceShadingRateImageFeaturesNV;
+
+typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         shadingRateTexelSize;
+    uint32_t           shadingRatePaletteSize;
+    uint32_t           shadingRateMaxCoarseSamples;
+} VkPhysicalDeviceShadingRateImagePropertiesNV;
+
+typedef struct VkCoarseSampleLocationNV {
+    uint32_t    pixelX;
+    uint32_t    pixelY;
+    uint32_t    sample;
+} VkCoarseSampleLocationNV;
+
+typedef struct VkCoarseSampleOrderCustomNV {
+    VkShadingRatePaletteEntryNV        shadingRate;
+    uint32_t                           sampleCount;
+    uint32_t                           sampleLocationCount;
+    const VkCoarseSampleLocationNV*    pSampleLocations;
+} VkCoarseSampleOrderCustomNV;
+
+typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkCoarseSampleOrderTypeNV             sampleOrderType;
+    uint32_t                              customSampleOrderCount;
+    const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
+} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
+typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
+    VkCommandBuffer                             commandBuffer,
+    VkImageView                                 imageView,
+    VkImageLayout                               imageLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkShadingRatePaletteNV*               pShadingRatePalettes);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
+    VkCommandBuffer                             commandBuffer,
+    VkCoarseSampleOrderTypeNV                   sampleOrderType,
+    uint32_t                                    customSampleOrderCount,
+    const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
+#endif
+
+
+#define VK_NV_ray_tracing 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
+#define VK_NV_RAY_TRACING_SPEC_VERSION    3
+#define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
+#define VK_SHADER_UNUSED_KHR              (~0U)
+#define VK_SHADER_UNUSED_NV               VK_SHADER_UNUSED_KHR
+
+typedef enum VkRayTracingShaderGroupTypeKHR {
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkRayTracingShaderGroupTypeKHR;
+typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;
+
+
+typedef enum VkGeometryTypeKHR {
+    VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0,
+    VK_GEOMETRY_TYPE_AABBS_KHR = 1,
+    VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
+    VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
+    VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
+    VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkGeometryTypeKHR;
+typedef VkGeometryTypeKHR VkGeometryTypeNV;
+
+
+typedef enum VkAccelerationStructureTypeKHR {
+    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0,
+    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1,
+    VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2,
+    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
+    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
+    VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAccelerationStructureTypeKHR;
+typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;
+
+
+typedef enum VkCopyAccelerationStructureModeKHR {
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkCopyAccelerationStructureModeKHR;
+typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;
+
+
+typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
+    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
+    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
+    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
+    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkAccelerationStructureMemoryRequirementsTypeNV;
+
+typedef enum VkGeometryFlagBitsKHR {
+    VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001,
+    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002,
+    VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR,
+    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR,
+    VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkGeometryFlagBitsKHR;
+typedef VkFlags VkGeometryFlagsKHR;
+typedef VkGeometryFlagsKHR VkGeometryFlagsNV;
+
+typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;
+
+
+typedef enum VkGeometryInstanceFlagBitsKHR {
+    VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001,
+    VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002,
+    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004,
+    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,
+    VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR,
+    VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
+    VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
+    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
+    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
+    VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkGeometryInstanceFlagBitsKHR;
+typedef VkFlags VkGeometryInstanceFlagsKHR;
+typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
+
+typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;
+
+
+typedef enum VkBuildAccelerationStructureFlagBitsKHR {
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002,
+    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004,
+    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008,
+    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010,
+    VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
+    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
+    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
+    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
+    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR,
+    VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkBuildAccelerationStructureFlagBitsKHR;
+typedef VkFlags VkBuildAccelerationStructureFlagsKHR;
+typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;
+
+typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV;
+
+typedef struct VkRayTracingShaderGroupCreateInfoNV {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkRayTracingShaderGroupTypeKHR    type;
+    uint32_t                          generalShader;
+    uint32_t                          closestHitShader;
+    uint32_t                          anyHitShader;
+    uint32_t                          intersectionShader;
+} VkRayTracingShaderGroupCreateInfoNV;
+
+typedef struct VkRayTracingPipelineCreateInfoNV {
+    VkStructureType                               sType;
+    const void*                                   pNext;
+    VkPipelineCreateFlags                         flags;
+    uint32_t                                      stageCount;
+    const VkPipelineShaderStageCreateInfo*        pStages;
+    uint32_t                                      groupCount;
+    const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
+    uint32_t                                      maxRecursionDepth;
+    VkPipelineLayout                              layout;
+    VkPipeline                                    basePipelineHandle;
+    int32_t                                       basePipelineIndex;
+} VkRayTracingPipelineCreateInfoNV;
+
+typedef struct VkGeometryTrianglesNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           vertexData;
+    VkDeviceSize       vertexOffset;
+    uint32_t           vertexCount;
+    VkDeviceSize       vertexStride;
+    VkFormat           vertexFormat;
+    VkBuffer           indexData;
+    VkDeviceSize       indexOffset;
+    uint32_t           indexCount;
+    VkIndexType        indexType;
+    VkBuffer           transformData;
+    VkDeviceSize       transformOffset;
+} VkGeometryTrianglesNV;
+
+typedef struct VkGeometryAABBNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           aabbData;
+    uint32_t           numAABBs;
+    uint32_t           stride;
+    VkDeviceSize       offset;
+} VkGeometryAABBNV;
+
+typedef struct VkGeometryDataNV {
+    VkGeometryTrianglesNV    triangles;
+    VkGeometryAABBNV         aabbs;
+} VkGeometryDataNV;
+
+typedef struct VkGeometryNV {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkGeometryTypeKHR     geometryType;
+    VkGeometryDataNV      geometry;
+    VkGeometryFlagsKHR    flags;
+} VkGeometryNV;
+
+typedef struct VkAccelerationStructureInfoNV {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkAccelerationStructureTypeNV          type;
+    VkBuildAccelerationStructureFlagsNV    flags;
+    uint32_t                               instanceCount;
+    uint32_t                               geometryCount;
+    const VkGeometryNV*                    pGeometries;
+} VkAccelerationStructureInfoNV;
+
+typedef struct VkAccelerationStructureCreateInfoNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkDeviceSize                     compactedSize;
+    VkAccelerationStructureInfoNV    info;
+} VkAccelerationStructureCreateInfoNV;
+
+typedef struct VkBindAccelerationStructureMemoryInfoNV {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkAccelerationStructureNV    accelerationStructure;
+    VkDeviceMemory               memory;
+    VkDeviceSize                 memoryOffset;
+    uint32_t                     deviceIndexCount;
+    const uint32_t*              pDeviceIndices;
+} VkBindAccelerationStructureMemoryInfoNV;
+
+typedef struct VkWriteDescriptorSetAccelerationStructureNV {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    uint32_t                            accelerationStructureCount;
+    const VkAccelerationStructureNV*    pAccelerationStructures;
+} VkWriteDescriptorSetAccelerationStructureNV;
+
+typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    VkAccelerationStructureMemoryRequirementsTypeNV    type;
+    VkAccelerationStructureNV                          accelerationStructure;
+} VkAccelerationStructureMemoryRequirementsInfoNV;
+
+typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderGroupHandleSize;
+    uint32_t           maxRecursionDepth;
+    uint32_t           maxShaderGroupStride;
+    uint32_t           shaderGroupBaseAlignment;
+    uint64_t           maxGeometryCount;
+    uint64_t           maxInstanceCount;
+    uint64_t           maxTriangleCount;
+    uint32_t           maxDescriptorSetAccelerationStructures;
+} VkPhysicalDeviceRayTracingPropertiesNV;
+
+typedef struct VkTransformMatrixKHR {
+    float    matrix[3][4];
+} VkTransformMatrixKHR;
+
+typedef VkTransformMatrixKHR VkTransformMatrixNV;
+
+typedef struct VkAabbPositionsKHR {
+    float    minX;
+    float    minY;
+    float    minZ;
+    float    maxX;
+    float    maxY;
+    float    maxZ;
+} VkAabbPositionsKHR;
+
+typedef VkAabbPositionsKHR VkAabbPositionsNV;
+
+typedef struct VkAccelerationStructureInstanceKHR {
+    VkTransformMatrixKHR          transform;
+    uint32_t                      instanceCustomIndex:24;
+    uint32_t                      mask:8;
+    uint32_t                      instanceShaderBindingTableRecordOffset:24;
+    VkGeometryInstanceFlagsKHR    flags:8;
+    uint64_t                      accelerationStructureReference;
+} VkAccelerationStructureInstanceKHR;
+
+typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
+typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
+typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode);
+typedef void (VKAPI_PTR *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_t width, uint32_t height, uint32_t depth);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
+typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
+typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(
+    VkDevice                                    device,
+    const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkAccelerationStructureNV*                  pAccelerationStructure);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(
+    VkDevice                                    device,
+    VkAccelerationStructureNV                   accelerationStructure,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(
+    VkDevice                                    device,
+    const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+    VkMemoryRequirements2KHR*                   pMemoryRequirements);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(
+    VkCommandBuffer                             commandBuffer,
+    const VkAccelerationStructureInfoNV*        pInfo,
+    VkBuffer                                    instanceData,
+    VkDeviceSize                                instanceOffset,
+    VkBool32                                    update,
+    VkAccelerationStructureNV                   dst,
+    VkAccelerationStructureNV                   src,
+    VkBuffer                                    scratch,
+    VkDeviceSize                                scratchOffset);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(
+    VkCommandBuffer                             commandBuffer,
+    VkAccelerationStructureNV                   dst,
+    VkAccelerationStructureNV                   src,
+    VkCopyAccelerationStructureModeKHR          mode);
+
+VKAPI_ATTR void VKAPI_CALL 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_t                                    width,
+    uint32_t                                    height,
+    uint32_t                                    depth);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    firstGroup,
+    uint32_t                                    groupCount,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    firstGroup,
+    uint32_t                                    groupCount,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(
+    VkDevice                                    device,
+    VkAccelerationStructureNV                   accelerationStructure,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    accelerationStructureCount,
+    const VkAccelerationStructureNV*            pAccelerationStructures,
+    VkQueryType                                 queryType,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    shader);
+#endif
+
+
+#define VK_NV_representative_fragment_test 1
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
+typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           representativeFragmentTest;
+} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+
+typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           representativeFragmentTestEnable;
+} VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
+
+
+
+#define VK_EXT_filter_cubic 1
+#define VK_EXT_FILTER_CUBIC_SPEC_VERSION  3
+#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
+typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageViewType    imageViewType;
+} VkPhysicalDeviceImageViewImageFormatInfoEXT;
+
+typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           filterCubic;
+    VkBool32           filterCubicMinmax;
+} VkFilterCubicImageViewImageFormatPropertiesEXT;
+
+
+
+#define VK_QCOM_render_pass_shader_resolve 1
+#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4
+#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
+
+
+#define VK_EXT_global_priority 1
+#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
+#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
+
+typedef enum VkQueueGlobalPriorityEXT {
+    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
+    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
+    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
+    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
+    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkQueueGlobalPriorityEXT;
+typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkQueueGlobalPriorityEXT    globalPriority;
+} VkDeviceQueueGlobalPriorityCreateInfoEXT;
+
+
+
+#define VK_EXT_external_memory_host 1
+#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
+typedef struct VkImportMemoryHostPointerInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 pHostPointer;
+} VkImportMemoryHostPointerInfoEXT;
+
+typedef struct VkMemoryHostPointerPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryHostPointerPropertiesEXT;
+
+typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       minImportedHostPointerAlignment;
+} VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHostPointer,
+    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
+#endif
+
+
+#define VK_AMD_buffer_marker 1
+#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
+#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
+typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlagBits                     pipelineStage,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    uint32_t                                    marker);
+#endif
+
+
+#define VK_AMD_pipeline_compiler_control 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
+
+typedef enum VkPipelineCompilerControlFlagBitsAMD {
+    VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkPipelineCompilerControlFlagBitsAMD;
+typedef VkFlags VkPipelineCompilerControlFlagsAMD;
+typedef struct VkPipelineCompilerControlCreateInfoAMD {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
+} VkPipelineCompilerControlCreateInfoAMD;
+
+
+
+#define VK_EXT_calibrated_timestamps 1
+#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
+#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
+
+typedef enum VkTimeDomainEXT {
+    VK_TIME_DOMAIN_DEVICE_EXT = 0,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
+    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
+    VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkTimeDomainEXT;
+typedef struct VkCalibratedTimestampInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkTimeDomainEXT    timeDomain;
+} VkCalibratedTimestampInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
+typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pTimeDomainCount,
+    VkTimeDomainEXT*                            pTimeDomains);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
+    VkDevice                                    device,
+    uint32_t                                    timestampCount,
+    const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
+    uint64_t*                                   pTimestamps,
+    uint64_t*                                   pMaxDeviation);
+#endif
+
+
+#define VK_AMD_shader_core_properties 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
+#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
+typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderEngineCount;
+    uint32_t           shaderArraysPerEngineCount;
+    uint32_t           computeUnitsPerShaderArray;
+    uint32_t           simdPerComputeUnit;
+    uint32_t           wavefrontsPerSimd;
+    uint32_t           wavefrontSize;
+    uint32_t           sgprsPerSimd;
+    uint32_t           minSgprAllocation;
+    uint32_t           maxSgprAllocation;
+    uint32_t           sgprAllocationGranularity;
+    uint32_t           vgprsPerSimd;
+    uint32_t           minVgprAllocation;
+    uint32_t           maxVgprAllocation;
+    uint32_t           vgprAllocationGranularity;
+} VkPhysicalDeviceShaderCorePropertiesAMD;
+
+
+
+#define VK_AMD_memory_overallocation_behavior 1
+#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
+#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
+
+typedef enum VkMemoryOverallocationBehaviorAMD {
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkMemoryOverallocationBehaviorAMD;
+typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
+} VkDeviceMemoryOverallocationCreateInfoAMD;
+
+
+
+#define VK_EXT_vertex_attribute_divisor 1
+#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
+#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
+typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVertexAttribDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+
+typedef struct VkVertexInputBindingDivisorDescriptionEXT {
+    uint32_t    binding;
+    uint32_t    divisor;
+} VkVertexInputBindingDivisorDescriptionEXT;
+
+typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    uint32_t                                            vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
+} VkPipelineVertexInputDivisorStateCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           vertexAttributeInstanceRateDivisor;
+    VkBool32           vertexAttributeInstanceRateZeroDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+
+
+
+#define VK_EXT_pipeline_creation_feedback 1
+#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
+#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
+
+typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
+    VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
+    VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
+    VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
+    VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkPipelineCreationFeedbackFlagBitsEXT;
+typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
+typedef struct VkPipelineCreationFeedbackEXT {
+    VkPipelineCreationFeedbackFlagsEXT    flags;
+    uint64_t                              duration;
+} VkPipelineCreationFeedbackEXT;
+
+typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
+    uint32_t                          pipelineStageCreationFeedbackCount;
+    VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
+} VkPipelineCreationFeedbackCreateInfoEXT;
+
+
+
+#define VK_NV_shader_subgroup_partitioned 1
+#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
+#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
+
+
+#define VK_NV_compute_shader_derivatives 1
+#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
+#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
+typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           computeDerivativeGroupQuads;
+    VkBool32           computeDerivativeGroupLinear;
+} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
+
+
+
+#define VK_NV_mesh_shader 1
+#define VK_NV_MESH_SHADER_SPEC_VERSION    1
+#define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
+typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           taskShader;
+    VkBool32           meshShader;
+} VkPhysicalDeviceMeshShaderFeaturesNV;
+
+typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxDrawMeshTasksCount;
+    uint32_t           maxTaskWorkGroupInvocations;
+    uint32_t           maxTaskWorkGroupSize[3];
+    uint32_t           maxTaskTotalMemorySize;
+    uint32_t           maxTaskOutputCount;
+    uint32_t           maxMeshWorkGroupInvocations;
+    uint32_t           maxMeshWorkGroupSize[3];
+    uint32_t           maxMeshTotalMemorySize;
+    uint32_t           maxMeshOutputVertices;
+    uint32_t           maxMeshOutputPrimitives;
+    uint32_t           maxMeshMultiviewViewCount;
+    uint32_t           meshOutputPerVertexGranularity;
+    uint32_t           meshOutputPerPrimitiveGranularity;
+} VkPhysicalDeviceMeshShaderPropertiesNV;
+
+typedef struct VkDrawMeshTasksIndirectCommandNV {
+    uint32_t    taskCount;
+    uint32_t    firstTask;
+} VkDrawMeshTasksIndirectCommandNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    taskCount,
+    uint32_t                                    firstTask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+
+#define VK_NV_fragment_shader_barycentric 1
+#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
+#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
+typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentShaderBarycentric;
+} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+
+
+
+#define VK_NV_shader_image_footprint 1
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
+typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           imageFootprint;
+} VkPhysicalDeviceShaderImageFootprintFeaturesNV;
+
+
+
+#define VK_NV_scissor_exclusive 1
+#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
+#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
+typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           exclusiveScissorCount;
+    const VkRect2D*    pExclusiveScissors;
+} VkPipelineViewportExclusiveScissorStateCreateInfoNV;
+
+typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           exclusiveScissor;
+} VkPhysicalDeviceExclusiveScissorFeaturesNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstExclusiveScissor,
+    uint32_t                                    exclusiveScissorCount,
+    const VkRect2D*                             pExclusiveScissors);
+#endif
+
+
+#define VK_NV_device_diagnostic_checkpoints 1
+#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
+#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
+typedef struct VkQueueFamilyCheckpointPropertiesNV {
+    VkStructureType         sType;
+    void*                   pNext;
+    VkPipelineStageFlags    checkpointExecutionStageMask;
+} VkQueueFamilyCheckpointPropertiesNV;
+
+typedef struct VkCheckpointDataNV {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkPipelineStageFlagBits    stage;
+    void*                      pCheckpointMarker;
+} VkCheckpointDataNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
+typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(
+    VkCommandBuffer                             commandBuffer,
+    const void*                                 pCheckpointMarker);
+
+VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
+    VkQueue                                     queue,
+    uint32_t*                                   pCheckpointDataCount,
+    VkCheckpointDataNV*                         pCheckpointData);
+#endif
+
+
+#define VK_INTEL_shader_integer_functions2 1
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
+typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderIntegerFunctions2;
+} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+
+
+
+#define VK_INTEL_performance_query 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
+#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2
+#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
+
+typedef enum VkPerformanceConfigurationTypeINTEL {
+    VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
+    VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
+} VkPerformanceConfigurationTypeINTEL;
+
+typedef enum VkQueryPoolSamplingModeINTEL {
+    VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
+    VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
+} VkQueryPoolSamplingModeINTEL;
+
+typedef enum VkPerformanceOverrideTypeINTEL {
+    VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
+    VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
+    VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
+} VkPerformanceOverrideTypeINTEL;
+
+typedef enum VkPerformanceParameterTypeINTEL {
+    VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
+    VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
+    VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
+} VkPerformanceParameterTypeINTEL;
+
+typedef enum VkPerformanceValueTypeINTEL {
+    VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
+    VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
+    VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
+    VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
+    VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
+    VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
+} VkPerformanceValueTypeINTEL;
+typedef union VkPerformanceValueDataINTEL {
+    uint32_t       value32;
+    uint64_t       value64;
+    float          valueFloat;
+    VkBool32       valueBool;
+    const char*    valueString;
+} VkPerformanceValueDataINTEL;
+
+typedef struct VkPerformanceValueINTEL {
+    VkPerformanceValueTypeINTEL    type;
+    VkPerformanceValueDataINTEL    data;
+} VkPerformanceValueINTEL;
+
+typedef struct VkInitializePerformanceApiInfoINTEL {
+    VkStructureType    sType;
+    const void*        pNext;
+    void*              pUserData;
+} VkInitializePerformanceApiInfoINTEL;
+
+typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
+} VkQueryPoolPerformanceQueryCreateInfoINTEL;
+
+typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL;
+
+typedef struct VkPerformanceMarkerInfoINTEL {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint64_t           marker;
+} VkPerformanceMarkerInfoINTEL;
+
+typedef struct VkPerformanceStreamMarkerInfoINTEL {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           marker;
+} VkPerformanceStreamMarkerInfoINTEL;
+
+typedef struct VkPerformanceOverrideInfoINTEL {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkPerformanceOverrideTypeINTEL    type;
+    VkBool32                          enable;
+    uint64_t                          parameter;
+} VkPerformanceOverrideInfoINTEL;
+
+typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkPerformanceConfigurationTypeINTEL    type;
+} VkPerformanceConfigurationAcquireInfoINTEL;
+
+typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
+typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);
+typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
+typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(
+    VkDevice                                    device,
+    const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(
+    VkDevice                                    device);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(
+    VkCommandBuffer                             commandBuffer,
+    const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(
+    VkCommandBuffer                             commandBuffer,
+    const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(
+    VkCommandBuffer                             commandBuffer,
+    const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(
+    VkDevice                                    device,
+    const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+    VkPerformanceConfigurationINTEL*            pConfiguration);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(
+    VkDevice                                    device,
+    VkPerformanceConfigurationINTEL             configuration);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(
+    VkQueue                                     queue,
+    VkPerformanceConfigurationINTEL             configuration);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(
+    VkDevice                                    device,
+    VkPerformanceParameterTypeINTEL             parameter,
+    VkPerformanceValueINTEL*                    pValue);
+#endif
+
+
+#define VK_EXT_pci_bus_info 1
+#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION  2
+#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
+typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           pciDomain;
+    uint32_t           pciBus;
+    uint32_t           pciDevice;
+    uint32_t           pciFunction;
+} VkPhysicalDevicePCIBusInfoPropertiesEXT;
+
+
+
+#define VK_AMD_display_native_hdr 1
+#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
+#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
+typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           localDimmingSupport;
+} VkDisplayNativeHdrSurfaceCapabilitiesAMD;
+
+typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           localDimmingEnable;
+} VkSwapchainDisplayNativeHdrCreateInfoAMD;
+
+typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapChain,
+    VkBool32                                    localDimmingEnable);
+#endif
+
+
+#define VK_EXT_fragment_density_map 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
+typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentDensityMap;
+    VkBool32           fragmentDensityMapDynamic;
+    VkBool32           fragmentDensityMapNonSubsampledImages;
+} VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
+
+typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         minFragmentDensityTexelSize;
+    VkExtent2D         maxFragmentDensityTexelSize;
+    VkBool32           fragmentDensityInvocations;
+} VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
+
+typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkAttachmentReference    fragmentDensityMapAttachment;
+} VkRenderPassFragmentDensityMapCreateInfoEXT;
+
+
+
+#define VK_EXT_scalar_block_layout 1
+#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
+#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
+typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
+
+
+
+#define VK_GOOGLE_hlsl_functionality1 1
+#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1
+#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
+
+
+#define VK_GOOGLE_decorate_string 1
+#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
+#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
+
+
+#define VK_EXT_subgroup_size_control 1
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
+typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           subgroupSizeControl;
+    VkBool32           computeFullSubgroups;
+} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
+
+typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
+    VkStructureType       sType;
+    void*                 pNext;
+    uint32_t              minSubgroupSize;
+    uint32_t              maxSubgroupSize;
+    uint32_t              maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags    requiredSubgroupSizeStages;
+} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
+
+typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           requiredSubgroupSize;
+} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+
+
+
+#define VK_AMD_shader_core_properties2 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
+
+typedef enum VkShaderCorePropertiesFlagBitsAMD {
+    VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkShaderCorePropertiesFlagBitsAMD;
+typedef VkFlags VkShaderCorePropertiesFlagsAMD;
+typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
+    VkStructureType                   sType;
+    void*                             pNext;
+    VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
+    uint32_t                          activeComputeUnitCount;
+} VkPhysicalDeviceShaderCoreProperties2AMD;
+
+
+
+#define VK_AMD_device_coherent_memory 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
+typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           deviceCoherentMemory;
+} VkPhysicalDeviceCoherentMemoryFeaturesAMD;
+
+
+
+#define VK_EXT_shader_image_atomic_int64 1
+#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1
+#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64"
+typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderImageInt64Atomics;
+    VkBool32           sparseImageInt64Atomics;
+} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
+
+
+
+#define VK_EXT_memory_budget 1
+#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
+#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
+typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
+    VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryBudgetPropertiesEXT;
+
+
+
+#define VK_EXT_memory_priority 1
+#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
+#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
+typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           memoryPriority;
+} VkPhysicalDeviceMemoryPriorityFeaturesEXT;
+
+typedef struct VkMemoryPriorityAllocateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    float              priority;
+} VkMemoryPriorityAllocateInfoEXT;
+
+
+
+#define VK_NV_dedicated_allocation_image_aliasing 1
+#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
+#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
+typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           dedicatedAllocationImageAliasing;
+} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+
+
+
+#define VK_EXT_buffer_device_address 1
+#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
+#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           bufferDeviceAddress;
+    VkBool32           bufferDeviceAddressCaptureReplay;
+    VkBool32           bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
+
+typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
+
+typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;
+
+typedef struct VkBufferDeviceAddressCreateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceAddress    deviceAddress;
+} VkBufferDeviceAddressCreateInfoEXT;
+
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
+    VkDevice                                    device,
+    const VkBufferDeviceAddressInfo*            pInfo);
+#endif
+
+
+#define VK_EXT_tooling_info 1
+#define VK_EXT_TOOLING_INFO_SPEC_VERSION  1
+#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"
+
+typedef enum VkToolPurposeFlagBitsEXT {
+    VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 0x00000001,
+    VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 0x00000002,
+    VK_TOOL_PURPOSE_TRACING_BIT_EXT = 0x00000004,
+    VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 0x00000008,
+    VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 0x00000010,
+    VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,
+    VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,
+    VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkToolPurposeFlagBitsEXT;
+typedef VkFlags VkToolPurposeFlagsEXT;
+typedef struct VkPhysicalDeviceToolPropertiesEXT {
+    VkStructureType          sType;
+    void*                    pNext;
+    char                     name[VK_MAX_EXTENSION_NAME_SIZE];
+    char                     version[VK_MAX_EXTENSION_NAME_SIZE];
+    VkToolPurposeFlagsEXT    purposes;
+    char                     description[VK_MAX_DESCRIPTION_SIZE];
+    char                     layer[VK_MAX_EXTENSION_NAME_SIZE];
+} VkPhysicalDeviceToolPropertiesEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pToolCount,
+    VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
+#endif
+
+
+#define VK_EXT_separate_stencil_usage 1
+#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
+#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
+typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
+
+
+
+#define VK_EXT_validation_features 1
+#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5
+#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
+
+typedef enum VkValidationFeatureEnableEXT {
+    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
+    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
+    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
+    VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3,
+    VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4,
+    VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationFeatureEnableEXT;
+
+typedef enum VkValidationFeatureDisableEXT {
+    VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
+    VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
+    VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
+    VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
+    VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
+    VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
+    VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
+    VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7,
+    VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationFeatureDisableEXT;
+typedef struct VkValidationFeaturesEXT {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    uint32_t                                enabledValidationFeatureCount;
+    const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
+    uint32_t                                disabledValidationFeatureCount;
+    const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
+} VkValidationFeaturesEXT;
+
+
+
+#define VK_NV_cooperative_matrix 1
+#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
+#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
+
+typedef enum VkComponentTypeNV {
+    VK_COMPONENT_TYPE_FLOAT16_NV = 0,
+    VK_COMPONENT_TYPE_FLOAT32_NV = 1,
+    VK_COMPONENT_TYPE_FLOAT64_NV = 2,
+    VK_COMPONENT_TYPE_SINT8_NV = 3,
+    VK_COMPONENT_TYPE_SINT16_NV = 4,
+    VK_COMPONENT_TYPE_SINT32_NV = 5,
+    VK_COMPONENT_TYPE_SINT64_NV = 6,
+    VK_COMPONENT_TYPE_UINT8_NV = 7,
+    VK_COMPONENT_TYPE_UINT16_NV = 8,
+    VK_COMPONENT_TYPE_UINT32_NV = 9,
+    VK_COMPONENT_TYPE_UINT64_NV = 10,
+    VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkComponentTypeNV;
+
+typedef enum VkScopeNV {
+    VK_SCOPE_DEVICE_NV = 1,
+    VK_SCOPE_WORKGROUP_NV = 2,
+    VK_SCOPE_SUBGROUP_NV = 3,
+    VK_SCOPE_QUEUE_FAMILY_NV = 5,
+    VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkScopeNV;
+typedef struct VkCooperativeMatrixPropertiesNV {
+    VkStructureType      sType;
+    void*                pNext;
+    uint32_t             MSize;
+    uint32_t             NSize;
+    uint32_t             KSize;
+    VkComponentTypeNV    AType;
+    VkComponentTypeNV    BType;
+    VkComponentTypeNV    CType;
+    VkComponentTypeNV    DType;
+    VkScopeNV            scope;
+} VkCooperativeMatrixPropertiesNV;
+
+typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cooperativeMatrix;
+    VkBool32           cooperativeMatrixRobustBufferAccess;
+} VkPhysicalDeviceCooperativeMatrixFeaturesNV;
+
+typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkShaderStageFlags    cooperativeMatrixSupportedStages;
+} VkPhysicalDeviceCooperativeMatrixPropertiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkCooperativeMatrixPropertiesNV*            pProperties);
+#endif
+
+
+#define VK_NV_coverage_reduction_mode 1
+#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
+#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
+
+typedef enum VkCoverageReductionModeNV {
+    VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
+    VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
+    VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCoverageReductionModeNV;
+typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
+typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           coverageReductionMode;
+} VkPhysicalDeviceCoverageReductionModeFeaturesNV;
+
+typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    VkPipelineCoverageReductionStateCreateFlagsNV    flags;
+    VkCoverageReductionModeNV                        coverageReductionMode;
+} VkPipelineCoverageReductionStateCreateInfoNV;
+
+typedef struct VkFramebufferMixedSamplesCombinationNV {
+    VkStructureType              sType;
+    void*                        pNext;
+    VkCoverageReductionModeNV    coverageReductionMode;
+    VkSampleCountFlagBits        rasterizationSamples;
+    VkSampleCountFlags           depthStencilSamples;
+    VkSampleCountFlags           colorSamples;
+} VkFramebufferMixedSamplesCombinationNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pCombinationCount,
+    VkFramebufferMixedSamplesCombinationNV*     pCombinations);
+#endif
+
+
+#define VK_EXT_fragment_shader_interlock 1
+#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
+#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
+typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentShaderSampleInterlock;
+    VkBool32           fragmentShaderPixelInterlock;
+    VkBool32           fragmentShaderShadingRateInterlock;
+} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+
+
+
+#define VK_EXT_ycbcr_image_arrays 1
+#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
+#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
+typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           ycbcrImageArrays;
+} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
+
+
+
+#define VK_EXT_provoking_vertex 1
+#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1
+#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"
+
+typedef enum VkProvokingVertexModeEXT {
+    VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0,
+    VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1,
+    VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkProvokingVertexModeEXT;
+typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           provokingVertexLast;
+    VkBool32           transformFeedbackPreservesProvokingVertex;
+} VkPhysicalDeviceProvokingVertexFeaturesEXT;
+
+typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           provokingVertexModePerPipeline;
+    VkBool32           transformFeedbackPreservesTriangleFanProvokingVertex;
+} VkPhysicalDeviceProvokingVertexPropertiesEXT;
+
+typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkProvokingVertexModeEXT    provokingVertexMode;
+} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
+
+
+
+#define VK_EXT_headless_surface 1
+#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
+#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
+typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
+typedef struct VkHeadlessSurfaceCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkHeadlessSurfaceCreateFlagsEXT    flags;
+} VkHeadlessSurfaceCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
+    VkInstance                                  instance,
+    const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_EXT_line_rasterization 1
+#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
+#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
+
+typedef enum VkLineRasterizationModeEXT {
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
+    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkLineRasterizationModeEXT;
+typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rectangularLines;
+    VkBool32           bresenhamLines;
+    VkBool32           smoothLines;
+    VkBool32           stippledRectangularLines;
+    VkBool32           stippledBresenhamLines;
+    VkBool32           stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeaturesEXT;
+
+typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationPropertiesEXT;
+
+typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkLineRasterizationModeEXT    lineRasterizationMode;
+    VkBool32                      stippledLineEnable;
+    uint32_t                      lineStippleFactor;
+    uint16_t                      lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+#endif
+
+
+#define VK_EXT_shader_atomic_float 1
+#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1
+#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float"
+typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
+    VkStructureType    sType;
+    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;
+} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
+
+
+
+#define VK_EXT_host_query_reset 1
+#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
+#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
+typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;
+
+typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount);
+#endif
+
+
+#define VK_EXT_index_type_uint8 1
+#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
+#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
+typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+
+
+
+#define VK_EXT_extended_dynamic_state 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state"
+typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           extendedDynamicState;
+} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
+typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
+typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkCullModeFlags                             cullMode);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkFrontFace                                 frontFace);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkPrimitiveTopology                         primitiveTopology);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    viewportCount,
+    const VkViewport*                           pViewports);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    scissorCount,
+    const VkRect2D*                             pScissors);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkDeviceSize*                         pOffsets,
+    const VkDeviceSize*                         pSizes,
+    const VkDeviceSize*                         pStrides);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    depthTestEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    depthWriteEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkCompareOp                                 depthCompareOp);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    depthBoundsTestEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    stencilTestEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    VkStencilOp                                 failOp,
+    VkStencilOp                                 passOp,
+    VkStencilOp                                 depthFailOp,
+    VkCompareOp                                 compareOp);
+#endif
+
+
+#define VK_EXT_shader_atomic_float2 1
+#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
+#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2"
+typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    VkStructureType    sType;
+    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;
+} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
+
+
+
+#define VK_EXT_shader_demote_to_helper_invocation 1
+#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
+#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
+typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderDemoteToHelperInvocation;
+} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+
+
+
+#define VK_NV_device_generated_commands 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
+#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
+#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands"
+
+typedef enum VkIndirectCommandsTokenTypeNV {
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkIndirectCommandsTokenTypeNV;
+
+typedef enum VkIndirectStateFlagBitsNV {
+    VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001,
+    VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkIndirectStateFlagBitsNV;
+typedef VkFlags VkIndirectStateFlagsNV;
+
+typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV {
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkIndirectCommandsLayoutUsageFlagBitsNV;
+typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxGraphicsShaderGroupCount;
+    uint32_t           maxIndirectSequenceCount;
+    uint32_t           maxIndirectCommandsTokenCount;
+    uint32_t           maxIndirectCommandsStreamCount;
+    uint32_t           maxIndirectCommandsTokenOffset;
+    uint32_t           maxIndirectCommandsStreamStride;
+    uint32_t           minSequencesCountBufferOffsetAlignment;
+    uint32_t           minSequencesIndexBufferOffsetAlignment;
+    uint32_t           minIndirectCommandsBufferOffsetAlignment;
+} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
+
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           deviceGeneratedCommands;
+} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
+
+typedef struct VkGraphicsShaderGroupCreateInfoNV {
+    VkStructureType                                 sType;
+    const void*                                     pNext;
+    uint32_t                                        stageCount;
+    const VkPipelineShaderStageCreateInfo*          pStages;
+    const VkPipelineVertexInputStateCreateInfo*     pVertexInputState;
+    const VkPipelineTessellationStateCreateInfo*    pTessellationState;
+} VkGraphicsShaderGroupCreateInfoNV;
+
+typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    groupCount;
+    const VkGraphicsShaderGroupCreateInfoNV*    pGroups;
+    uint32_t                                    pipelineCount;
+    const VkPipeline*                           pPipelines;
+} VkGraphicsPipelineShaderGroupsCreateInfoNV;
+
+typedef struct VkBindShaderGroupIndirectCommandNV {
+    uint32_t    groupIndex;
+} VkBindShaderGroupIndirectCommandNV;
+
+typedef struct VkBindIndexBufferIndirectCommandNV {
+    VkDeviceAddress    bufferAddress;
+    uint32_t           size;
+    VkIndexType        indexType;
+} VkBindIndexBufferIndirectCommandNV;
+
+typedef struct VkBindVertexBufferIndirectCommandNV {
+    VkDeviceAddress    bufferAddress;
+    uint32_t           size;
+    uint32_t           stride;
+} VkBindVertexBufferIndirectCommandNV;
+
+typedef struct VkSetStateFlagsIndirectCommandNV {
+    uint32_t    data;
+} VkSetStateFlagsIndirectCommandNV;
+
+typedef struct VkIndirectCommandsStreamNV {
+    VkBuffer        buffer;
+    VkDeviceSize    offset;
+} VkIndirectCommandsStreamNV;
+
+typedef struct VkIndirectCommandsLayoutTokenNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkIndirectCommandsTokenTypeNV    tokenType;
+    uint32_t                         stream;
+    uint32_t                         offset;
+    uint32_t                         vertexBindingUnit;
+    VkBool32                         vertexDynamicStride;
+    VkPipelineLayout                 pushconstantPipelineLayout;
+    VkShaderStageFlags               pushconstantShaderStageFlags;
+    uint32_t                         pushconstantOffset;
+    uint32_t                         pushconstantSize;
+    VkIndirectStateFlagsNV           indirectStateFlags;
+    uint32_t                         indexTypeCount;
+    const VkIndexType*               pIndexTypes;
+    const uint32_t*                  pIndexTypeValues;
+} VkIndirectCommandsLayoutTokenNV;
+
+typedef struct VkIndirectCommandsLayoutCreateInfoNV {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkIndirectCommandsLayoutUsageFlagsNV      flags;
+    VkPipelineBindPoint                       pipelineBindPoint;
+    uint32_t                                  tokenCount;
+    const VkIndirectCommandsLayoutTokenNV*    pTokens;
+    uint32_t                                  streamCount;
+    const uint32_t*                           pStreamStrides;
+} VkIndirectCommandsLayoutCreateInfoNV;
+
+typedef struct VkGeneratedCommandsInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkPipelineBindPoint                  pipelineBindPoint;
+    VkPipeline                           pipeline;
+    VkIndirectCommandsLayoutNV           indirectCommandsLayout;
+    uint32_t                             streamCount;
+    const VkIndirectCommandsStreamNV*    pStreams;
+    uint32_t                             sequencesCount;
+    VkBuffer                             preprocessBuffer;
+    VkDeviceSize                         preprocessOffset;
+    VkDeviceSize                         preprocessSize;
+    VkBuffer                             sequencesCountBuffer;
+    VkDeviceSize                         sequencesCountOffset;
+    VkBuffer                             sequencesIndexBuffer;
+    VkDeviceSize                         sequencesIndexOffset;
+} VkGeneratedCommandsInfoNV;
+
+typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkPipelineBindPoint           pipelineBindPoint;
+    VkPipeline                    pipeline;
+    VkIndirectCommandsLayoutNV    indirectCommandsLayout;
+    uint32_t                      maxSequencesCount;
+} VkGeneratedCommandsMemoryRequirementsInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(
+    VkDevice                                    device,
+    const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(
+    VkCommandBuffer                             commandBuffer,
+    const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    isPreprocessed,
+    const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipeline                                  pipeline,
+    uint32_t                                    groupIndex);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(
+    VkDevice                                    device,
+    const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(
+    VkDevice                                    device,
+    VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
+    const VkAllocationCallbacks*                pAllocator);
+#endif
+
+
+#define VK_NV_inherited_viewport_scissor 1
+#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1
+#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor"
+typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           inheritedViewportScissor2D;
+} VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
+
+typedef struct VkCommandBufferInheritanceViewportScissorInfoNV {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkBool32             viewportScissor2D;
+    uint32_t             viewportDepthCount;
+    const VkViewport*    pViewportDepths;
+} VkCommandBufferInheritanceViewportScissorInfoNV;
+
+
+
+#define VK_EXT_texel_buffer_alignment 1
+#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
+#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
+typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           texelBufferAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+
+typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
+    VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+
+
+
+#define VK_QCOM_render_pass_transform 1
+#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2
+#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"
+typedef struct VkRenderPassTransformBeginInfoQCOM {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkSurfaceTransformFlagBitsKHR    transform;
+} VkRenderPassTransformBeginInfoQCOM;
+
+typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkSurfaceTransformFlagBitsKHR    transform;
+    VkRect2D                         renderArea;
+} VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
+
+
+
+#define VK_EXT_device_memory_report 1
+#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2
+#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report"
+
+typedef enum VkDeviceMemoryReportEventTypeEXT {
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0,
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1,
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2,
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3,
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4,
+    VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDeviceMemoryReportEventTypeEXT;
+typedef VkFlags VkDeviceMemoryReportFlagsEXT;
+typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           deviceMemoryReport;
+} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
+
+typedef struct VkDeviceMemoryReportCallbackDataEXT {
+    VkStructureType                     sType;
+    void*                               pNext;
+    VkDeviceMemoryReportFlagsEXT        flags;
+    VkDeviceMemoryReportEventTypeEXT    type;
+    uint64_t                            memoryObjectId;
+    VkDeviceSize                        size;
+    VkObjectType                        objectType;
+    uint64_t                            objectHandle;
+    uint32_t                            heapIndex;
+} VkDeviceMemoryReportCallbackDataEXT;
+
+typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)(
+    const VkDeviceMemoryReportCallbackDataEXT*  pCallbackData,
+    void*                                       pUserData);
+
+typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkDeviceMemoryReportFlagsEXT           flags;
+    PFN_vkDeviceMemoryReportCallbackEXT    pfnUserCallback;
+    void*                                  pUserData;
+} VkDeviceDeviceMemoryReportCreateInfoEXT;
+
+
+
+#define VK_EXT_acquire_drm_display 1
+#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    int32_t                                     drmFd,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    int32_t                                     drmFd,
+    uint32_t                                    connectorId,
+    VkDisplayKHR*                               display);
+#endif
+
+
+#define VK_EXT_robustness2 1
+#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION  1
+#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
+typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           robustBufferAccess2;
+    VkBool32           robustImageAccess2;
+    VkBool32           nullDescriptor;
+} VkPhysicalDeviceRobustness2FeaturesEXT;
+
+typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize       robustUniformBufferAccessSizeAlignment;
+} VkPhysicalDeviceRobustness2PropertiesEXT;
+
+
+
+#define VK_EXT_custom_border_color 1
+#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12
+#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"
+typedef struct VkSamplerCustomBorderColorCreateInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkClearColorValue    customBorderColor;
+    VkFormat             format;
+} VkSamplerCustomBorderColorCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxCustomBorderColorSamplers;
+} VkPhysicalDeviceCustomBorderColorPropertiesEXT;
+
+typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           customBorderColors;
+    VkBool32           customBorderColorWithoutFormat;
+} VkPhysicalDeviceCustomBorderColorFeaturesEXT;
+
+
+
+#define VK_GOOGLE_user_type 1
+#define VK_GOOGLE_USER_TYPE_SPEC_VERSION  1
+#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
+
+
+#define VK_EXT_private_data 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlotEXT)
+#define VK_EXT_PRIVATE_DATA_SPEC_VERSION  1
+#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
+
+typedef enum VkPrivateDataSlotCreateFlagBitsEXT {
+    VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkPrivateDataSlotCreateFlagBitsEXT;
+typedef VkFlags VkPrivateDataSlotCreateFlagsEXT;
+typedef struct VkPhysicalDevicePrivateDataFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           privateData;
+} VkPhysicalDevicePrivateDataFeaturesEXT;
+
+typedef struct VkDevicePrivateDataCreateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           privateDataSlotRequestCount;
+} VkDevicePrivateDataCreateInfoEXT;
+
+typedef struct VkPrivateDataSlotCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkPrivateDataSlotCreateFlagsEXT    flags;
+} VkPrivateDataSlotCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot);
+typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data);
+typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(
+    VkDevice                                    device,
+    const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPrivateDataSlotEXT*                       pPrivateDataSlot);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(
+    VkDevice                                    device,
+    VkPrivateDataSlotEXT                        privateDataSlot,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(
+    VkDevice                                    device,
+    VkObjectType                                objectType,
+    uint64_t                                    objectHandle,
+    VkPrivateDataSlotEXT                        privateDataSlot,
+    uint64_t                                    data);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(
+    VkDevice                                    device,
+    VkObjectType                                objectType,
+    uint64_t                                    objectHandle,
+    VkPrivateDataSlotEXT                        privateDataSlot,
+    uint64_t*                                   pData);
+#endif
+
+
+#define VK_EXT_pipeline_creation_cache_control 1
+#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3
+#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control"
+typedef struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           pipelineCreationCacheControl;
+} VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
+
+
+
+#define VK_NV_device_diagnostics_config 1
+#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1
+#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"
+
+typedef enum VkDeviceDiagnosticsConfigFlagBitsNV {
+    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001,
+    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002,
+    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004,
+    VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkDeviceDiagnosticsConfigFlagBitsNV;
+typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;
+typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           diagnosticsConfig;
+} VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
+
+typedef struct VkDeviceDiagnosticsConfigCreateInfoNV {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkDeviceDiagnosticsConfigFlagsNV    flags;
+} VkDeviceDiagnosticsConfigCreateInfoNV;
+
+
+
+#define VK_QCOM_render_pass_store_ops 1
+#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2
+#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
+
+
+#define VK_NV_fragment_shading_rate_enums 1
+#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1
+#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums"
+
+typedef enum VkFragmentShadingRateTypeNV {
+    VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0,
+    VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1,
+    VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkFragmentShadingRateTypeNV;
+
+typedef enum VkFragmentShadingRateNV {
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
+    VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10,
+    VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11,
+    VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12,
+    VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13,
+    VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14,
+    VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15,
+    VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkFragmentShadingRateNV;
+typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentShadingRateEnums;
+    VkBool32           supersampleFragmentShadingRates;
+    VkBool32           noInvocationFragmentShadingRates;
+} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
+
+typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
+    VkStructureType          sType;
+    void*                    pNext;
+    VkSampleCountFlagBits    maxFragmentShadingRateInvocationCount;
+} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
+
+typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkFragmentShadingRateTypeNV           shadingRateType;
+    VkFragmentShadingRateNV               shadingRate;
+    VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
+} VkPipelineFragmentShadingRateEnumStateCreateInfoNV;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer           commandBuffer, VkFragmentShadingRateNV                     shadingRate, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(
+    VkCommandBuffer                             commandBuffer,
+    VkFragmentShadingRateNV                     shadingRate,
+    const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
+#endif
+
+
+#define VK_NV_ray_tracing_motion_blur 1
+#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1
+#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur"
+
+typedef enum VkAccelerationStructureMotionInstanceTypeNV {
+    VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0,
+    VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1,
+    VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2,
+    VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkAccelerationStructureMotionInstanceTypeNV;
+typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV;
+typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV;
+typedef union VkDeviceOrHostAddressConstKHR {
+    VkDeviceAddress    deviceAddress;
+    const void*        hostAddress;
+} VkDeviceOrHostAddressConstKHR;
+
+typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkDeviceOrHostAddressConstKHR    vertexData;
+} VkAccelerationStructureGeometryMotionTrianglesDataNV;
+
+typedef struct VkAccelerationStructureMotionInfoNV {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    maxInstances;
+    VkAccelerationStructureMotionInfoFlagsNV    flags;
+} VkAccelerationStructureMotionInfoNV;
+
+typedef struct VkAccelerationStructureMatrixMotionInstanceNV {
+    VkTransformMatrixKHR          transformT0;
+    VkTransformMatrixKHR          transformT1;
+    uint32_t                      instanceCustomIndex:24;
+    uint32_t                      mask:8;
+    uint32_t                      instanceShaderBindingTableRecordOffset:24;
+    VkGeometryInstanceFlagsKHR    flags:8;
+    uint64_t                      accelerationStructureReference;
+} VkAccelerationStructureMatrixMotionInstanceNV;
+
+typedef struct VkSRTDataNV {
+    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;
+} VkSRTDataNV;
+
+typedef struct VkAccelerationStructureSRTMotionInstanceNV {
+    VkSRTDataNV                   transformT0;
+    VkSRTDataNV                   transformT1;
+    uint32_t                      instanceCustomIndex:24;
+    uint32_t                      mask:8;
+    uint32_t                      instanceShaderBindingTableRecordOffset:24;
+    VkGeometryInstanceFlagsKHR    flags:8;
+    uint64_t                      accelerationStructureReference;
+} VkAccelerationStructureSRTMotionInstanceNV;
+
+typedef union VkAccelerationStructureMotionInstanceDataNV {
+    VkAccelerationStructureInstanceKHR               staticInstance;
+    VkAccelerationStructureMatrixMotionInstanceNV    matrixMotionInstance;
+    VkAccelerationStructureSRTMotionInstanceNV       srtMotionInstance;
+} VkAccelerationStructureMotionInstanceDataNV;
+
+typedef struct VkAccelerationStructureMotionInstanceNV {
+    VkAccelerationStructureMotionInstanceTypeNV     type;
+    VkAccelerationStructureMotionInstanceFlagsNV    flags;
+    VkAccelerationStructureMotionInstanceDataNV     data;
+} VkAccelerationStructureMotionInstanceNV;
+
+typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rayTracingMotionBlur;
+    VkBool32           rayTracingMotionBlurPipelineTraceRaysIndirect;
+} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
+
+
+
+#define VK_EXT_ycbcr_2plane_444_formats 1
+#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1
+#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats"
+typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           ycbcr2plane444Formats;
+} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
+
+
+
+#define VK_EXT_fragment_density_map2 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2"
+typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fragmentDensityMapDeferred;
+} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
+
+typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           subsampledLoads;
+    VkBool32           subsampledCoarseReconstructionEarlyAccess;
+    uint32_t           maxSubsampledArrayLayers;
+    uint32_t           maxDescriptorSetSubsampledSamplers;
+} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
+
+
+
+#define VK_QCOM_rotated_copy_commands 1
+#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
+#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
+typedef struct VkCopyCommandTransformInfoQCOM {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkSurfaceTransformFlagBitsKHR    transform;
+} VkCopyCommandTransformInfoQCOM;
+
+
+
+#define VK_EXT_image_robustness 1
+#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1
+#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness"
+typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           robustImageAccess;
+} VkPhysicalDeviceImageRobustnessFeaturesEXT;
+
+
+
+#define VK_EXT_4444_formats 1
+#define VK_EXT_4444_FORMATS_SPEC_VERSION  1
+#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"
+typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           formatA4R4G4B4;
+    VkBool32           formatA4B4G4R4;
+} VkPhysicalDevice4444FormatsFeaturesEXT;
+
+
+
+#define VK_NV_acquire_winrt_display 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    deviceRelativeId,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+
+#define VK_VALVE_mutable_descriptor_type 1
+#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
+#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
+typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           mutableDescriptorType;
+} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+
+typedef struct VkMutableDescriptorTypeListVALVE {
+    uint32_t                   descriptorTypeCount;
+    const VkDescriptorType*    pDescriptorTypes;
+} VkMutableDescriptorTypeListVALVE;
+
+typedef struct VkMutableDescriptorTypeCreateInfoVALVE {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   mutableDescriptorTypeListCount;
+    const VkMutableDescriptorTypeListVALVE*    pMutableDescriptorTypeLists;
+} VkMutableDescriptorTypeCreateInfoVALVE;
+
+
+
+#define VK_EXT_vertex_input_dynamic_state 1
+#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2
+#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"
+typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           vertexInputDynamicState;
+} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
+
+typedef struct VkVertexInputBindingDescription2EXT {
+    VkStructureType      sType;
+    void*                pNext;
+    uint32_t             binding;
+    uint32_t             stride;
+    VkVertexInputRate    inputRate;
+    uint32_t             divisor;
+} VkVertexInputBindingDescription2EXT;
+
+typedef struct VkVertexInputAttributeDescription2EXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           location;
+    uint32_t           binding;
+    VkFormat           format;
+    uint32_t           offset;
+} VkVertexInputAttributeDescription2EXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    vertexBindingDescriptionCount,
+    const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
+    uint32_t                                    vertexAttributeDescriptionCount,
+    const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
+#endif
+
+
+#define VK_EXT_physical_device_drm 1
+#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1
+#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm"
+typedef struct VkPhysicalDeviceDrmPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           hasPrimary;
+    VkBool32           hasRender;
+    int64_t            primaryMajor;
+    int64_t            primaryMinor;
+    int64_t            renderMajor;
+    int64_t            renderMinor;
+} VkPhysicalDeviceDrmPropertiesEXT;
+
+
+
+#define VK_HUAWEI_subpass_shading 1
+#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2
+#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"
+typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI {
+    VkStructureType    sType;
+    void*              pNext;
+    VkRenderPass       renderPass;
+    uint32_t           subpass;
+} VkSubpassShadingPipelineCreateInfoHUAWEI;
+
+typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           subpassShading;
+} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
+
+typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxSubpassShadingWorkgroupSizeAspectRatio;
+} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize);
+typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
+    VkDevice                                    device,
+    VkRenderPass                                renderpass,
+    VkExtent2D*                                 pMaxWorkgroupSize);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(
+    VkCommandBuffer                             commandBuffer);
+#endif
+
+
+#define VK_HUAWEI_invocation_mask 1
+#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1
+#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask"
+typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           invocationMask;
+} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
+
+typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(
+    VkCommandBuffer                             commandBuffer,
+    VkImageView                                 imageView,
+    VkImageLayout                               imageLayout);
+#endif
+
+
+#define VK_NV_external_memory_rdma 1
+typedef void* VkRemoteAddressNV;
+#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma"
+typedef struct VkMemoryGetRemoteAddressInfoNV {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetRemoteAddressInfoNV;
+
+typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           externalMemoryRDMA;
+} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(
+    VkDevice                                    device,
+    const VkMemoryGetRemoteAddressInfoNV*       pMemoryGetRemoteAddressInfo,
+    VkRemoteAddressNV*                          pAddress);
+#endif
+
+
+#define VK_EXT_extended_dynamic_state2 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"
+typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           extendedDynamicState2;
+    VkBool32           extendedDynamicState2LogicOp;
+    VkBool32           extendedDynamicState2PatchControlPoints;
+} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
+typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    patchControlPoints);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    rasterizerDiscardEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    depthBiasEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkLogicOp                                   logicOp);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    primitiveRestartEnable);
+#endif
+
+
+#define VK_EXT_color_write_enable 1
+#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1
+#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"
+typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           colorWriteEnable;
+} VkPhysicalDeviceColorWriteEnableFeaturesEXT;
+
+typedef struct VkPipelineColorWriteCreateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           attachmentCount;
+    const VkBool32*    pColorWriteEnables;
+} VkPipelineColorWriteCreateInfoEXT;
+
+typedef void                                    (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer       commandBuffer, uint32_t                                attachmentCount, const VkBool32*   pColorWriteEnables);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void                                    VKAPI_CALL vkCmdSetColorWriteEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    attachmentCount,
+    const VkBool32*                             pColorWriteEnables);
+#endif
+
+
+#define VK_EXT_global_priority_query 1
+#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT   16U
+#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1
+#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"
+typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           globalPriorityQuery;
+} VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
+
+typedef struct VkQueueFamilyGlobalPriorityPropertiesEXT {
+    VkStructureType             sType;
+    void*                       pNext;
+    uint32_t                    priorityCount;
+    VkQueueGlobalPriorityEXT    priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT];
+} VkQueueFamilyGlobalPriorityPropertiesEXT;
+
+
+
+#define VK_EXT_multi_draw 1
+#define VK_EXT_MULTI_DRAW_SPEC_VERSION    1
+#define VK_EXT_MULTI_DRAW_EXTENSION_NAME  "VK_EXT_multi_draw"
+typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           multiDraw;
+} VkPhysicalDeviceMultiDrawFeaturesEXT;
+
+typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxMultiDrawCount;
+} VkPhysicalDeviceMultiDrawPropertiesEXT;
+
+typedef struct VkMultiDrawInfoEXT {
+    uint32_t    firstVertex;
+    uint32_t    vertexCount;
+} VkMultiDrawInfoEXT;
+
+typedef struct VkMultiDrawIndexedInfoEXT {
+    uint32_t    firstIndex;
+    uint32_t    indexCount;
+    int32_t     vertexOffset;
+} VkMultiDrawIndexedInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    drawCount,
+    const VkMultiDrawInfoEXT*                   pVertexInfo,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstInstance,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    drawCount,
+    const VkMultiDrawIndexedInfoEXT*            pIndexInfo,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstInstance,
+    uint32_t                                    stride,
+    const int32_t*                              pVertexOffset);
+#endif
+
+
+#define VK_EXT_load_store_op_none 1
+#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1
+#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none"
+
+
+#define VK_KHR_acceleration_structure 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
+#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 12
+#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"
+
+typedef enum VkBuildAccelerationStructureModeKHR {
+    VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0,
+    VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1,
+    VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkBuildAccelerationStructureModeKHR;
+
+typedef enum VkAccelerationStructureBuildTypeKHR {
+    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0,
+    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1,
+    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2,
+    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAccelerationStructureBuildTypeKHR;
+
+typedef enum VkAccelerationStructureCompatibilityKHR {
+    VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0,
+    VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1,
+    VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAccelerationStructureCompatibilityKHR;
+
+typedef enum VkAccelerationStructureCreateFlagBitsKHR {
+    VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001,
+    VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004,
+    VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAccelerationStructureCreateFlagBitsKHR;
+typedef VkFlags VkAccelerationStructureCreateFlagsKHR;
+typedef union VkDeviceOrHostAddressKHR {
+    VkDeviceAddress    deviceAddress;
+    void*              hostAddress;
+} VkDeviceOrHostAddressKHR;
+
+typedef struct VkAccelerationStructureBuildRangeInfoKHR {
+    uint32_t    primitiveCount;
+    uint32_t    primitiveOffset;
+    uint32_t    firstVertex;
+    uint32_t    transformOffset;
+} VkAccelerationStructureBuildRangeInfoKHR;
+
+typedef struct VkAccelerationStructureGeometryTrianglesDataKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkFormat                         vertexFormat;
+    VkDeviceOrHostAddressConstKHR    vertexData;
+    VkDeviceSize                     vertexStride;
+    uint32_t                         maxVertex;
+    VkIndexType                      indexType;
+    VkDeviceOrHostAddressConstKHR    indexData;
+    VkDeviceOrHostAddressConstKHR    transformData;
+} VkAccelerationStructureGeometryTrianglesDataKHR;
+
+typedef struct VkAccelerationStructureGeometryAabbsDataKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkDeviceOrHostAddressConstKHR    data;
+    VkDeviceSize                     stride;
+} VkAccelerationStructureGeometryAabbsDataKHR;
+
+typedef struct VkAccelerationStructureGeometryInstancesDataKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkBool32                         arrayOfPointers;
+    VkDeviceOrHostAddressConstKHR    data;
+} VkAccelerationStructureGeometryInstancesDataKHR;
+
+typedef union VkAccelerationStructureGeometryDataKHR {
+    VkAccelerationStructureGeometryTrianglesDataKHR    triangles;
+    VkAccelerationStructureGeometryAabbsDataKHR        aabbs;
+    VkAccelerationStructureGeometryInstancesDataKHR    instances;
+} VkAccelerationStructureGeometryDataKHR;
+
+typedef struct VkAccelerationStructureGeometryKHR {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkGeometryTypeKHR                         geometryType;
+    VkAccelerationStructureGeometryDataKHR    geometry;
+    VkGeometryFlagsKHR                        flags;
+} VkAccelerationStructureGeometryKHR;
+
+typedef struct VkAccelerationStructureBuildGeometryInfoKHR {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    VkAccelerationStructureTypeKHR                      type;
+    VkBuildAccelerationStructureFlagsKHR                flags;
+    VkBuildAccelerationStructureModeKHR                 mode;
+    VkAccelerationStructureKHR                          srcAccelerationStructure;
+    VkAccelerationStructureKHR                          dstAccelerationStructure;
+    uint32_t                                            geometryCount;
+    const VkAccelerationStructureGeometryKHR*           pGeometries;
+    const VkAccelerationStructureGeometryKHR* const*    ppGeometries;
+    VkDeviceOrHostAddressKHR                            scratchData;
+} VkAccelerationStructureBuildGeometryInfoKHR;
+
+typedef struct VkAccelerationStructureCreateInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkAccelerationStructureCreateFlagsKHR    createFlags;
+    VkBuffer                                 buffer;
+    VkDeviceSize                             offset;
+    VkDeviceSize                             size;
+    VkAccelerationStructureTypeKHR           type;
+    VkDeviceAddress                          deviceAddress;
+} VkAccelerationStructureCreateInfoKHR;
+
+typedef struct VkWriteDescriptorSetAccelerationStructureKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    uint32_t                             accelerationStructureCount;
+    const VkAccelerationStructureKHR*    pAccelerationStructures;
+} VkWriteDescriptorSetAccelerationStructureKHR;
+
+typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           accelerationStructure;
+    VkBool32           accelerationStructureCaptureReplay;
+    VkBool32           accelerationStructureIndirectBuild;
+    VkBool32           accelerationStructureHostCommands;
+    VkBool32           descriptorBindingAccelerationStructureUpdateAfterBind;
+} VkPhysicalDeviceAccelerationStructureFeaturesKHR;
+
+typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           maxGeometryCount;
+    uint64_t           maxInstanceCount;
+    uint64_t           maxPrimitiveCount;
+    uint32_t           maxPerStageDescriptorAccelerationStructures;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    uint32_t           maxDescriptorSetAccelerationStructures;
+    uint32_t           maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    uint32_t           minAccelerationStructureScratchOffsetAlignment;
+} VkPhysicalDeviceAccelerationStructurePropertiesKHR;
+
+typedef struct VkAccelerationStructureDeviceAddressInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkAccelerationStructureKHR    accelerationStructure;
+} VkAccelerationStructureDeviceAddressInfoKHR;
+
+typedef struct VkAccelerationStructureVersionInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    const uint8_t*     pVersionData;
+} VkAccelerationStructureVersionInfoKHR;
+
+typedef struct VkCopyAccelerationStructureToMemoryInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkAccelerationStructureKHR            src;
+    VkDeviceOrHostAddressKHR              dst;
+    VkCopyAccelerationStructureModeKHR    mode;
+} VkCopyAccelerationStructureToMemoryInfoKHR;
+
+typedef struct VkCopyMemoryToAccelerationStructureInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceOrHostAddressConstKHR         src;
+    VkAccelerationStructureKHR            dst;
+    VkCopyAccelerationStructureModeKHR    mode;
+} VkCopyMemoryToAccelerationStructureInfoKHR;
+
+typedef struct VkCopyAccelerationStructureInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkAccelerationStructureKHR            src;
+    VkAccelerationStructureKHR            dst;
+    VkCopyAccelerationStructureModeKHR    mode;
+} VkCopyAccelerationStructureInfoKHR;
+
+typedef struct VkAccelerationStructureBuildSizesInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceSize       accelerationStructureSize;
+    VkDeviceSize       updateScratchSize;
+    VkDeviceSize       buildScratchSize;
+} VkAccelerationStructureBuildSizesInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice                                           device, const VkAccelerationStructureCreateInfoKHR*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkAccelerationStructureKHR*                        pAccelerationStructure);
+typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer                  commandBuffer, uint32_t                                           infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress*             pIndirectDeviceAddresses, const uint32_t*                    pIndirectStrides, const uint32_t* const*             ppMaxPrimitiveCounts);
+typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice                                           device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType  queryType, size_t       dataSize, void* pData, size_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility);
+typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice                                            device, VkAccelerationStructureBuildTypeKHR                 buildType, const VkAccelerationStructureBuildGeometryInfoKHR*  pBuildInfo, const uint32_t*  pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR*           pSizeInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(
+    VkDevice                                    device,
+    const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkAccelerationStructureKHR*                 pAccelerationStructure);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(
+    VkDevice                                    device,
+    VkAccelerationStructureKHR                  accelerationStructure,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    infoCount,
+    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    infoCount,
+    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkDeviceAddress*                      pIndirectDeviceAddresses,
+    const uint32_t*                             pIndirectStrides,
+    const uint32_t* const*                      ppMaxPrimitiveCounts);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      deferredOperation,
+    uint32_t                                    infoCount,
+    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      deferredOperation,
+    const VkCopyAccelerationStructureInfoKHR*   pInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      deferredOperation,
+    const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      deferredOperation,
+    const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(
+    VkDevice                                    device,
+    uint32_t                                    accelerationStructureCount,
+    const VkAccelerationStructureKHR*           pAccelerationStructures,
+    VkQueryType                                 queryType,
+    size_t                                      dataSize,
+    void*                                       pData,
+    size_t                                      stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyAccelerationStructureInfoKHR*   pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(
+    VkDevice                                    device,
+    const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    accelerationStructureCount,
+    const VkAccelerationStructureKHR*           pAccelerationStructures,
+    VkQueryType                                 queryType,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(
+    VkDevice                                    device,
+    const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+    VkAccelerationStructureCompatibilityKHR*    pCompatibility);
+
+VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(
+    VkDevice                                    device,
+    VkAccelerationStructureBuildTypeKHR         buildType,
+    const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
+    const uint32_t*                             pMaxPrimitiveCounts,
+    VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
+#endif
+
+
+#define VK_KHR_ray_tracing_pipeline 1
+#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1
+#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline"
+
+typedef enum VkShaderGroupShaderKHR {
+    VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0,
+    VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1,
+    VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2,
+    VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3,
+    VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkShaderGroupShaderKHR;
+typedef struct VkRayTracingShaderGroupCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkRayTracingShaderGroupTypeKHR    type;
+    uint32_t                          generalShader;
+    uint32_t                          closestHitShader;
+    uint32_t                          anyHitShader;
+    uint32_t                          intersectionShader;
+    const void*                       pShaderGroupCaptureReplayHandle;
+} VkRayTracingShaderGroupCreateInfoKHR;
+
+typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           maxPipelineRayPayloadSize;
+    uint32_t           maxPipelineRayHitAttributeSize;
+} VkRayTracingPipelineInterfaceCreateInfoKHR;
+
+typedef struct VkRayTracingPipelineCreateInfoKHR {
+    VkStructureType                                      sType;
+    const void*                                          pNext;
+    VkPipelineCreateFlags                                flags;
+    uint32_t                                             stageCount;
+    const VkPipelineShaderStageCreateInfo*               pStages;
+    uint32_t                                             groupCount;
+    const VkRayTracingShaderGroupCreateInfoKHR*          pGroups;
+    uint32_t                                             maxPipelineRayRecursionDepth;
+    const VkPipelineLibraryCreateInfoKHR*                pLibraryInfo;
+    const VkRayTracingPipelineInterfaceCreateInfoKHR*    pLibraryInterface;
+    const VkPipelineDynamicStateCreateInfo*              pDynamicState;
+    VkPipelineLayout                                     layout;
+    VkPipeline                                           basePipelineHandle;
+    int32_t                                              basePipelineIndex;
+} VkRayTracingPipelineCreateInfoKHR;
+
+typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rayTracingPipeline;
+    VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplay;
+    VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    VkBool32           rayTracingPipelineTraceRaysIndirect;
+    VkBool32           rayTraversalPrimitiveCulling;
+} VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
+
+typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderGroupHandleSize;
+    uint32_t           maxRayRecursionDepth;
+    uint32_t           maxShaderGroupStride;
+    uint32_t           shaderGroupBaseAlignment;
+    uint32_t           shaderGroupHandleCaptureReplaySize;
+    uint32_t           maxRayDispatchInvocationCount;
+    uint32_t           shaderGroupHandleAlignment;
+    uint32_t           maxRayHitAttributeSize;
+} VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
+
+typedef struct VkStridedDeviceAddressRegionKHR {
+    VkDeviceAddress    deviceAddress;
+    VkDeviceSize       stride;
+    VkDeviceSize       size;
+} VkStridedDeviceAddressRegionKHR;
+
+typedef struct VkTraceRaysIndirectCommandKHR {
+    uint32_t    width;
+    uint32_t    height;
+    uint32_t    depth;
+} VkTraceRaysIndirectCommandKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress);
+typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
+    uint32_t                                    width,
+    uint32_t                                    height,
+    uint32_t                                    depth);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(
+    VkDevice                                    device,
+    VkDeferredOperationKHR                      deferredOperation,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    firstGroup,
+    uint32_t                                    groupCount,
+    size_t                                      dataSize,
+    void*                                       pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
+    const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
+    VkDeviceAddress                             indirectDeviceAddress);
+
+VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    uint32_t                                    group,
+    VkShaderGroupShaderKHR                      groupShader);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    pipelineStackSize);
+#endif
+
+
+#define VK_KHR_ray_query 1
+#define VK_KHR_RAY_QUERY_SPEC_VERSION     1
+#define VK_KHR_RAY_QUERY_EXTENSION_NAME   "VK_KHR_ray_query"
+typedef struct VkPhysicalDeviceRayQueryFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rayQuery;
+} VkPhysicalDeviceRayQueryFeaturesKHR;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/vulkan/_gen/vulkan_ios.h

@@ -0,0 +1,47 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+/*
+** Copyright 2015-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_MVK_ios_surface 1
+#define VK_MVK_IOS_SURFACE_SPEC_VERSION   3
+#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+typedef struct VkIOSSurfaceCreateInfoMVK {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkIOSSurfaceCreateFlagsMVK    flags;
+    const void*                   pView;
+} VkIOSSurfaceCreateInfoMVK;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/vulkan/_gen/vulkan_macos.h

@@ -0,0 +1,47 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+/*
+** Copyright 2015-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_MVK_macos_surface 1
+#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3
+#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+typedef struct VkMacOSSurfaceCreateInfoMVK {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/vulkan/_gen/vulkan_metal.h

@@ -0,0 +1,54 @@
+#ifndef VULKAN_METAL_H_
+#define VULKAN_METAL_H_ 1
+
+/*
+** Copyright 2015-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_EXT_metal_surface 1
+
+#ifdef __OBJC__
+@class CAMetalLayer;
+#else
+typedef void CAMetalLayer;
+#endif
+
+#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
+#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
+typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
+typedef struct VkMetalSurfaceCreateInfoEXT {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMetalSurfaceCreateFlagsEXT    flags;
+    const CAMetalLayer*             pLayer;
+} VkMetalSurfaceCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
+    VkInstance                                  instance,
+    const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/vulkan/_gen/vulkan_win32.h

@@ -0,0 +1,315 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+/*
+** Copyright 2015-2021 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_win32_surface 1
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+    VkInstance                                  instance,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex);
+#endif
+
+
+#define VK_KHR_external_memory_win32 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
+typedef struct VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    HANDLE                                handle;
+    LPCWSTR                               name;
+} VkImportMemoryWin32HandleInfoKHR;
+
+typedef struct VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportMemoryWin32HandleInfoKHR;
+
+typedef struct VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryWin32HandlePropertiesKHR;
+
+typedef struct VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
+    VkDevice                                    device,
+    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    HANDLE                                      handle,
+    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#endif
+
+
+#define VK_KHR_win32_keyed_mutex 1
+#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeouts;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_win32 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
+typedef struct VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    HANDLE                                   handle;
+    LPCWSTR                                  name;
+} VkImportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkD3D12FenceSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValuesCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValuesCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHR;
+
+typedef struct VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_KHR_external_fence_win32 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
+typedef struct VkImportFenceWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    HANDLE                               handle;
+    LPCWSTR                              name;
+} VkImportFenceWin32HandleInfoKHR;
+
+typedef struct VkExportFenceWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportFenceWin32HandleInfoKHR;
+
+typedef struct VkFenceGetWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+
+#define VK_EXT_full_screen_exclusive 1
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
+
+typedef enum VkFullScreenExclusiveEXT {
+    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
+    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
+    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
+    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
+    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkFullScreenExclusiveEXT;
+typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkFullScreenExclusiveEXT    fullScreenExclusive;
+} VkSurfaceFullScreenExclusiveInfoEXT;
+
+typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fullScreenExclusiveSupported;
+} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
+
+typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    HMONITOR           hmonitor;
+} VkSurfaceFullScreenExclusiveWin32InfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
+typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    uint32_t*                                   pPresentModeCount,
+    VkPresentModeKHR*                           pPresentModes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
+    VkDevice                                    device,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    VkDeviceGroupPresentModeFlagsKHR*           pModes);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/vulkan/core.odin

@@ -0,0 +1,770 @@
+//
+// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
+//
+package vulkan
+
+import "core:c"
+API_VERSION_1_0 :: (1<<22) | (0<<12) | (0);
+
+MAKE_VERSION :: proc(major, minor, patch: u32) -> u32 {
+    return (major<<22) | (minor<<12) | (patch);
+}
+
+// Base types
+Flags         :: distinct u32;
+Flags64       :: distinct u64;
+DeviceSize    :: distinct u64;
+DeviceAddress :: distinct u64;
+SampleMask    :: distinct u32;
+
+Handle                :: distinct rawptr;
+NonDispatchableHandle :: distinct u64;
+
+SetProcAddressType :: #type proc(p: rawptr, name: cstring);
+
+
+cstring_array :: ^cstring; // Helper Type
+
+RemoteAddressNV :: distinct rawptr; // Declared inline before MemoryGetRemoteAddressInfoNV
+
+// Base constants
+LOD_CLAMP_NONE                :: 1000.0;
+REMAINING_MIP_LEVELS          :: ~u32(0);
+REMAINING_ARRAY_LAYERS        :: ~u32(0);
+WHOLE_SIZE                    :: ~u64(0);
+ATTACHMENT_UNUSED             :: ~u32(0);
+TRUE                          :: 1;
+FALSE                         :: 0;
+QUEUE_FAMILY_IGNORED          :: ~u32(0);
+SUBPASS_EXTERNAL              :: ~u32(0);
+MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256;
+UUID_SIZE                     :: 16;
+MAX_MEMORY_TYPES              :: 32;
+MAX_MEMORY_HEAPS              :: 16;
+MAX_EXTENSION_NAME_SIZE       :: 256;
+MAX_DESCRIPTION_SIZE          :: 256;
+MAX_DEVICE_GROUP_SIZE_KHX     :: 32;
+MAX_DEVICE_GROUP_SIZE         :: 32;
+LUID_SIZE_KHX                 :: 8;
+LUID_SIZE_KHR                 :: 8;
+LUID_SIZE                     :: 8;
+MAX_DRIVER_NAME_SIZE_KHR      :: 256;
+MAX_DRIVER_INFO_SIZE_KHR      :: 256;
+MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(0)-1;
+MAX_GLOBAL_PRIORITY_SIZE_EXT  :: 16;
+
+// General Constants
+HEADER_VERSION       :: 189;
+MAX_DRIVER_NAME_SIZE :: 256;
+MAX_DRIVER_INFO_SIZE :: 256;
+
+// Vendor Constants
+KHR_surface                                             :: 1;
+KHR_SURFACE_SPEC_VERSION                                :: 25;
+KHR_SURFACE_EXTENSION_NAME                              :: "VK_KHR_surface";
+KHR_swapchain                                           :: 1;
+KHR_SWAPCHAIN_SPEC_VERSION                              :: 70;
+KHR_SWAPCHAIN_EXTENSION_NAME                            :: "VK_KHR_swapchain";
+KHR_display                                             :: 1;
+KHR_DISPLAY_SPEC_VERSION                                :: 23;
+KHR_DISPLAY_EXTENSION_NAME                              :: "VK_KHR_display";
+KHR_display_swapchain                                   :: 1;
+KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION                      :: 10;
+KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME                    :: "VK_KHR_display_swapchain";
+KHR_sampler_mirror_clamp_to_edge                        :: 1;
+KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION           :: 3;
+KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME         :: "VK_KHR_sampler_mirror_clamp_to_edge";
+KHR_multiview                                           :: 1;
+KHR_MULTIVIEW_SPEC_VERSION                              :: 1;
+KHR_MULTIVIEW_EXTENSION_NAME                            :: "VK_KHR_multiview";
+KHR_get_physical_device_properties2                     :: 1;
+KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION       :: 2;
+KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME     :: "VK_KHR_get_physical_device_properties2";
+KHR_device_group                                        :: 1;
+KHR_DEVICE_GROUP_SPEC_VERSION                           :: 4;
+KHR_DEVICE_GROUP_EXTENSION_NAME                         :: "VK_KHR_device_group";
+KHR_shader_draw_parameters                              :: 1;
+KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION                 :: 1;
+KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME               :: "VK_KHR_shader_draw_parameters";
+KHR_maintenance1                                        :: 1;
+KHR_MAINTENANCE1_SPEC_VERSION                           :: 2;
+KHR_MAINTENANCE1_EXTENSION_NAME                         :: "VK_KHR_maintenance1";
+KHR_device_group_creation                               :: 1;
+KHR_DEVICE_GROUP_CREATION_SPEC_VERSION                  :: 1;
+KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME                :: "VK_KHR_device_group_creation";
+KHR_external_memory_capabilities                        :: 1;
+KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION           :: 1;
+KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME         :: "VK_KHR_external_memory_capabilities";
+KHR_external_memory                                     :: 1;
+KHR_EXTERNAL_MEMORY_SPEC_VERSION                        :: 1;
+KHR_EXTERNAL_MEMORY_EXTENSION_NAME                      :: "VK_KHR_external_memory";
+KHR_external_memory_fd                                  :: 1;
+KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION                     :: 1;
+KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME                   :: "VK_KHR_external_memory_fd";
+KHR_external_semaphore_capabilities                     :: 1;
+KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION        :: 1;
+KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME      :: "VK_KHR_external_semaphore_capabilities";
+KHR_external_semaphore                                  :: 1;
+KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION                     :: 1;
+KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME                   :: "VK_KHR_external_semaphore";
+KHR_external_semaphore_fd                               :: 1;
+KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION                  :: 1;
+KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME                :: "VK_KHR_external_semaphore_fd";
+KHR_push_descriptor                                     :: 1;
+KHR_PUSH_DESCRIPTOR_SPEC_VERSION                        :: 2;
+KHR_PUSH_DESCRIPTOR_EXTENSION_NAME                      :: "VK_KHR_push_descriptor";
+KHR_shader_float16_int8                                 :: 1;
+KHR_SHADER_FLOAT16_INT8_SPEC_VERSION                    :: 1;
+KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME                  :: "VK_KHR_shader_float16_int8";
+KHR_16bit_storage                                       :: 1;
+KHR_16BIT_STORAGE_SPEC_VERSION                          :: 1;
+KHR_16BIT_STORAGE_EXTENSION_NAME                        :: "VK_KHR_16bit_storage";
+KHR_incremental_present                                 :: 1;
+KHR_INCREMENTAL_PRESENT_SPEC_VERSION                    :: 2;
+KHR_INCREMENTAL_PRESENT_EXTENSION_NAME                  :: "VK_KHR_incremental_present";
+KHR_descriptor_update_template                          :: 1;
+KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION             :: 1;
+KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME           :: "VK_KHR_descriptor_update_template";
+KHR_imageless_framebuffer                               :: 1;
+KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION                  :: 1;
+KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME                :: "VK_KHR_imageless_framebuffer";
+KHR_create_renderpass2                                  :: 1;
+KHR_CREATE_RENDERPASS_2_SPEC_VERSION                    :: 1;
+KHR_CREATE_RENDERPASS_2_EXTENSION_NAME                  :: "VK_KHR_create_renderpass2";
+KHR_shared_presentable_image                            :: 1;
+KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION               :: 1;
+KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME             :: "VK_KHR_shared_presentable_image";
+KHR_external_fence_capabilities                         :: 1;
+KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION            :: 1;
+KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME          :: "VK_KHR_external_fence_capabilities";
+KHR_external_fence                                      :: 1;
+KHR_EXTERNAL_FENCE_SPEC_VERSION                         :: 1;
+KHR_EXTERNAL_FENCE_EXTENSION_NAME                       :: "VK_KHR_external_fence";
+KHR_external_fence_fd                                   :: 1;
+KHR_EXTERNAL_FENCE_FD_SPEC_VERSION                      :: 1;
+KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME                    :: "VK_KHR_external_fence_fd";
+KHR_performance_query                                   :: 1;
+KHR_PERFORMANCE_QUERY_SPEC_VERSION                      :: 1;
+KHR_PERFORMANCE_QUERY_EXTENSION_NAME                    :: "VK_KHR_performance_query";
+KHR_maintenance2                                        :: 1;
+KHR_MAINTENANCE2_SPEC_VERSION                           :: 1;
+KHR_MAINTENANCE2_EXTENSION_NAME                         :: "VK_KHR_maintenance2";
+KHR_get_surface_capabilities2                           :: 1;
+KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION             :: 1;
+KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME           :: "VK_KHR_get_surface_capabilities2";
+KHR_variable_pointers                                   :: 1;
+KHR_VARIABLE_POINTERS_SPEC_VERSION                      :: 1;
+KHR_VARIABLE_POINTERS_EXTENSION_NAME                    :: "VK_KHR_variable_pointers";
+KHR_get_display_properties2                             :: 1;
+KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION               :: 1;
+KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME             :: "VK_KHR_get_display_properties2";
+KHR_dedicated_allocation                                :: 1;
+KHR_DEDICATED_ALLOCATION_SPEC_VERSION                   :: 3;
+KHR_DEDICATED_ALLOCATION_EXTENSION_NAME                 :: "VK_KHR_dedicated_allocation";
+KHR_storage_buffer_storage_class                        :: 1;
+KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION           :: 1;
+KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME         :: "VK_KHR_storage_buffer_storage_class";
+KHR_relaxed_block_layout                                :: 1;
+KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION                   :: 1;
+KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME                 :: "VK_KHR_relaxed_block_layout";
+KHR_get_memory_requirements2                            :: 1;
+KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION              :: 1;
+KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME            :: "VK_KHR_get_memory_requirements2";
+KHR_image_format_list                                   :: 1;
+KHR_IMAGE_FORMAT_LIST_SPEC_VERSION                      :: 1;
+KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME                    :: "VK_KHR_image_format_list";
+KHR_sampler_ycbcr_conversion                            :: 1;
+KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION               :: 14;
+KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME             :: "VK_KHR_sampler_ycbcr_conversion";
+KHR_bind_memory2                                        :: 1;
+KHR_BIND_MEMORY_2_SPEC_VERSION                          :: 1;
+KHR_BIND_MEMORY_2_EXTENSION_NAME                        :: "VK_KHR_bind_memory2";
+KHR_maintenance3                                        :: 1;
+KHR_MAINTENANCE3_SPEC_VERSION                           :: 1;
+KHR_MAINTENANCE3_EXTENSION_NAME                         :: "VK_KHR_maintenance3";
+KHR_draw_indirect_count                                 :: 1;
+KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION                    :: 1;
+KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME                  :: "VK_KHR_draw_indirect_count";
+KHR_shader_subgroup_extended_types                      :: 1;
+KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION         :: 1;
+KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME       :: "VK_KHR_shader_subgroup_extended_types";
+KHR_8bit_storage                                        :: 1;
+KHR_8BIT_STORAGE_SPEC_VERSION                           :: 1;
+KHR_8BIT_STORAGE_EXTENSION_NAME                         :: "VK_KHR_8bit_storage";
+KHR_shader_atomic_int64                                 :: 1;
+KHR_SHADER_ATOMIC_INT64_SPEC_VERSION                    :: 1;
+KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME                  :: "VK_KHR_shader_atomic_int64";
+KHR_shader_clock                                        :: 1;
+KHR_SHADER_CLOCK_SPEC_VERSION                           :: 1;
+KHR_SHADER_CLOCK_EXTENSION_NAME                         :: "VK_KHR_shader_clock";
+KHR_driver_properties                                   :: 1;
+KHR_DRIVER_PROPERTIES_SPEC_VERSION                      :: 1;
+KHR_DRIVER_PROPERTIES_EXTENSION_NAME                    :: "VK_KHR_driver_properties";
+KHR_shader_float_controls                               :: 1;
+KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION                  :: 4;
+KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME                :: "VK_KHR_shader_float_controls";
+KHR_depth_stencil_resolve                               :: 1;
+KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION                  :: 1;
+KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME                :: "VK_KHR_depth_stencil_resolve";
+KHR_swapchain_mutable_format                            :: 1;
+KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION               :: 1;
+KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME             :: "VK_KHR_swapchain_mutable_format";
+KHR_timeline_semaphore                                  :: 1;
+KHR_TIMELINE_SEMAPHORE_SPEC_VERSION                     :: 2;
+KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME                   :: "VK_KHR_timeline_semaphore";
+KHR_vulkan_memory_model                                 :: 1;
+KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION                    :: 3;
+KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME                  :: "VK_KHR_vulkan_memory_model";
+KHR_shader_terminate_invocation                         :: 1;
+KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION            :: 1;
+KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME          :: "VK_KHR_shader_terminate_invocation";
+KHR_fragment_shading_rate                               :: 1;
+KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION                  :: 1;
+KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME                :: "VK_KHR_fragment_shading_rate";
+KHR_spirv_1_4                                           :: 1;
+KHR_SPIRV_1_4_SPEC_VERSION                              :: 1;
+KHR_SPIRV_1_4_EXTENSION_NAME                            :: "VK_KHR_spirv_1_4";
+KHR_surface_protected_capabilities                      :: 1;
+KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION         :: 1;
+KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME       :: "VK_KHR_surface_protected_capabilities";
+KHR_separate_depth_stencil_layouts                      :: 1;
+KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION         :: 1;
+KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME       :: "VK_KHR_separate_depth_stencil_layouts";
+KHR_present_wait                                        :: 1;
+KHR_PRESENT_WAIT_SPEC_VERSION                           :: 1;
+KHR_PRESENT_WAIT_EXTENSION_NAME                         :: "VK_KHR_present_wait";
+KHR_uniform_buffer_standard_layout                      :: 1;
+KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION         :: 1;
+KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME       :: "VK_KHR_uniform_buffer_standard_layout";
+KHR_buffer_device_address                               :: 1;
+KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION                  :: 1;
+KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME                :: "VK_KHR_buffer_device_address";
+KHR_deferred_host_operations                            :: 1;
+KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION               :: 4;
+KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME             :: "VK_KHR_deferred_host_operations";
+KHR_pipeline_executable_properties                      :: 1;
+KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION         :: 1;
+KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME       :: "VK_KHR_pipeline_executable_properties";
+KHR_pipeline_library                                    :: 1;
+KHR_PIPELINE_LIBRARY_SPEC_VERSION                       :: 1;
+KHR_PIPELINE_LIBRARY_EXTENSION_NAME                     :: "VK_KHR_pipeline_library";
+KHR_shader_non_semantic_info                            :: 1;
+KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION               :: 1;
+KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME             :: "VK_KHR_shader_non_semantic_info";
+KHR_present_id                                          :: 1;
+KHR_PRESENT_ID_SPEC_VERSION                             :: 1;
+KHR_PRESENT_ID_EXTENSION_NAME                           :: "VK_KHR_present_id";
+KHR_synchronization2                                    :: 1;
+KHR_SYNCHRONIZATION_2_SPEC_VERSION                      :: 1;
+KHR_SYNCHRONIZATION_2_EXTENSION_NAME                    :: "VK_KHR_synchronization2";
+KHR_shader_subgroup_uniform_control_flow                :: 1;
+KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION   :: 1;
+KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME :: "VK_KHR_shader_subgroup_uniform_control_flow";
+KHR_zero_initialize_workgroup_memory                    :: 1;
+KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION       :: 1;
+KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME     :: "VK_KHR_zero_initialize_workgroup_memory";
+KHR_workgroup_memory_explicit_layout                    :: 1;
+KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION       :: 1;
+KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME     :: "VK_KHR_workgroup_memory_explicit_layout";
+KHR_copy_commands2                                      :: 1;
+KHR_COPY_COMMANDS_2_SPEC_VERSION                        :: 1;
+KHR_COPY_COMMANDS_2_EXTENSION_NAME                      :: "VK_KHR_copy_commands2";
+EXT_debug_report                                        :: 1;
+EXT_DEBUG_REPORT_SPEC_VERSION                           :: 10;
+EXT_DEBUG_REPORT_EXTENSION_NAME                         :: "VK_EXT_debug_report";
+NV_glsl_shader                                          :: 1;
+NV_GLSL_SHADER_SPEC_VERSION                             :: 1;
+NV_GLSL_SHADER_EXTENSION_NAME                           :: "VK_NV_glsl_shader";
+EXT_depth_range_unrestricted                            :: 1;
+EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION               :: 1;
+EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME             :: "VK_EXT_depth_range_unrestricted";
+AMD_rasterization_order                                 :: 1;
+AMD_RASTERIZATION_ORDER_SPEC_VERSION                    :: 1;
+AMD_RASTERIZATION_ORDER_EXTENSION_NAME                  :: "VK_AMD_rasterization_order";
+AMD_shader_trinary_minmax                               :: 1;
+AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION                  :: 1;
+AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME                :: "VK_AMD_shader_trinary_minmax";
+AMD_shader_explicit_vertex_parameter                    :: 1;
+AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION       :: 1;
+AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME     :: "VK_AMD_shader_explicit_vertex_parameter";
+EXT_debug_marker                                        :: 1;
+EXT_DEBUG_MARKER_SPEC_VERSION                           :: 4;
+EXT_DEBUG_MARKER_EXTENSION_NAME                         :: "VK_EXT_debug_marker";
+AMD_gcn_shader                                          :: 1;
+AMD_GCN_SHADER_SPEC_VERSION                             :: 1;
+AMD_GCN_SHADER_EXTENSION_NAME                           :: "VK_AMD_gcn_shader";
+NV_dedicated_allocation                                 :: 1;
+NV_DEDICATED_ALLOCATION_SPEC_VERSION                    :: 1;
+NV_DEDICATED_ALLOCATION_EXTENSION_NAME                  :: "VK_NV_dedicated_allocation";
+EXT_transform_feedback                                  :: 1;
+EXT_TRANSFORM_FEEDBACK_SPEC_VERSION                     :: 1;
+EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME                   :: "VK_EXT_transform_feedback";
+NVX_binary_import                                       :: 1;
+NVX_BINARY_IMPORT_SPEC_VERSION                          :: 1;
+NVX_BINARY_IMPORT_EXTENSION_NAME                        :: "VK_NVX_binary_import";
+NVX_image_view_handle                                   :: 1;
+NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION                      :: 2;
+NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME                    :: "VK_NVX_image_view_handle";
+AMD_draw_indirect_count                                 :: 1;
+AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION                    :: 2;
+AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME                  :: "VK_AMD_draw_indirect_count";
+AMD_negative_viewport_height                            :: 1;
+AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION               :: 1;
+AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME             :: "VK_AMD_negative_viewport_height";
+AMD_gpu_shader_half_float                               :: 1;
+AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION                  :: 2;
+AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME                :: "VK_AMD_gpu_shader_half_float";
+AMD_shader_ballot                                       :: 1;
+AMD_SHADER_BALLOT_SPEC_VERSION                          :: 1;
+AMD_SHADER_BALLOT_EXTENSION_NAME                        :: "VK_AMD_shader_ballot";
+AMD_texture_gather_bias_lod                             :: 1;
+AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION                :: 1;
+AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME              :: "VK_AMD_texture_gather_bias_lod";
+AMD_shader_info                                         :: 1;
+AMD_SHADER_INFO_SPEC_VERSION                            :: 1;
+AMD_SHADER_INFO_EXTENSION_NAME                          :: "VK_AMD_shader_info";
+AMD_shader_image_load_store_lod                         :: 1;
+AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION            :: 1;
+AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME          :: "VK_AMD_shader_image_load_store_lod";
+NV_corner_sampled_image                                 :: 1;
+NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION                    :: 2;
+NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME                  :: "VK_NV_corner_sampled_image";
+NV_external_memory_capabilities                         :: 1;
+NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION            :: 1;
+NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME          :: "VK_NV_external_memory_capabilities";
+NV_external_memory                                      :: 1;
+NV_EXTERNAL_MEMORY_SPEC_VERSION                         :: 1;
+NV_EXTERNAL_MEMORY_EXTENSION_NAME                       :: "VK_NV_external_memory";
+EXT_validation_flags                                    :: 1;
+EXT_VALIDATION_FLAGS_SPEC_VERSION                       :: 2;
+EXT_VALIDATION_FLAGS_EXTENSION_NAME                     :: "VK_EXT_validation_flags";
+EXT_shader_subgroup_ballot                              :: 1;
+EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION                 :: 1;
+EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME               :: "VK_EXT_shader_subgroup_ballot";
+EXT_shader_subgroup_vote                                :: 1;
+EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION                   :: 1;
+EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME                 :: "VK_EXT_shader_subgroup_vote";
+EXT_texture_compression_astc_hdr                        :: 1;
+EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION           :: 1;
+EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME         :: "VK_EXT_texture_compression_astc_hdr";
+EXT_astc_decode_mode                                    :: 1;
+EXT_ASTC_DECODE_MODE_SPEC_VERSION                       :: 1;
+EXT_ASTC_DECODE_MODE_EXTENSION_NAME                     :: "VK_EXT_astc_decode_mode";
+EXT_conditional_rendering                               :: 1;
+EXT_CONDITIONAL_RENDERING_SPEC_VERSION                  :: 2;
+EXT_CONDITIONAL_RENDERING_EXTENSION_NAME                :: "VK_EXT_conditional_rendering";
+NV_clip_space_w_scaling                                 :: 1;
+NV_CLIP_SPACE_W_SCALING_SPEC_VERSION                    :: 1;
+NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME                  :: "VK_NV_clip_space_w_scaling";
+EXT_direct_mode_display                                 :: 1;
+EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION                    :: 1;
+EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME                  :: "VK_EXT_direct_mode_display";
+EXT_display_surface_counter                             :: 1;
+EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION                :: 1;
+EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME              :: "VK_EXT_display_surface_counter";
+EXT_display_control                                     :: 1;
+EXT_DISPLAY_CONTROL_SPEC_VERSION                        :: 1;
+EXT_DISPLAY_CONTROL_EXTENSION_NAME                      :: "VK_EXT_display_control";
+GOOGLE_display_timing                                   :: 1;
+GOOGLE_DISPLAY_TIMING_SPEC_VERSION                      :: 1;
+GOOGLE_DISPLAY_TIMING_EXTENSION_NAME                    :: "VK_GOOGLE_display_timing";
+NV_sample_mask_override_coverage                        :: 1;
+NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION           :: 1;
+NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME         :: "VK_NV_sample_mask_override_coverage";
+NV_geometry_shader_passthrough                          :: 1;
+NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION             :: 1;
+NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME           :: "VK_NV_geometry_shader_passthrough";
+NV_viewport_array2                                      :: 1;
+NV_VIEWPORT_ARRAY2_SPEC_VERSION                         :: 1;
+NV_VIEWPORT_ARRAY2_EXTENSION_NAME                       :: "VK_NV_viewport_array2";
+NVX_multiview_per_view_attributes                       :: 1;
+NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION          :: 1;
+NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME        :: "VK_NVX_multiview_per_view_attributes";
+NV_viewport_swizzle                                     :: 1;
+NV_VIEWPORT_SWIZZLE_SPEC_VERSION                        :: 1;
+NV_VIEWPORT_SWIZZLE_EXTENSION_NAME                      :: "VK_NV_viewport_swizzle";
+EXT_discard_rectangles                                  :: 1;
+EXT_DISCARD_RECTANGLES_SPEC_VERSION                     :: 1;
+EXT_DISCARD_RECTANGLES_EXTENSION_NAME                   :: "VK_EXT_discard_rectangles";
+EXT_conservative_rasterization                          :: 1;
+EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION             :: 1;
+EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME           :: "VK_EXT_conservative_rasterization";
+EXT_depth_clip_enable                                   :: 1;
+EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION                      :: 1;
+EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME                    :: "VK_EXT_depth_clip_enable";
+EXT_swapchain_colorspace                                :: 1;
+EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION                  :: 4;
+EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME                :: "VK_EXT_swapchain_colorspace";
+EXT_hdr_metadata                                        :: 1;
+EXT_HDR_METADATA_SPEC_VERSION                           :: 2;
+EXT_HDR_METADATA_EXTENSION_NAME                         :: "VK_EXT_hdr_metadata";
+EXT_external_memory_dma_buf                             :: 1;
+EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION                :: 1;
+EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME              :: "VK_EXT_external_memory_dma_buf";
+EXT_queue_family_foreign                                :: 1;
+EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION                   :: 1;
+EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME                 :: "VK_EXT_queue_family_foreign";
+EXT_debug_utils                                         :: 1;
+EXT_DEBUG_UTILS_SPEC_VERSION                            :: 2;
+EXT_DEBUG_UTILS_EXTENSION_NAME                          :: "VK_EXT_debug_utils";
+EXT_sampler_filter_minmax                               :: 1;
+EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION                  :: 2;
+EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME                :: "VK_EXT_sampler_filter_minmax";
+AMD_gpu_shader_int16                                    :: 1;
+AMD_GPU_SHADER_INT16_SPEC_VERSION                       :: 2;
+AMD_GPU_SHADER_INT16_EXTENSION_NAME                     :: "VK_AMD_gpu_shader_int16";
+AMD_mixed_attachment_samples                            :: 1;
+AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION               :: 1;
+AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME             :: "VK_AMD_mixed_attachment_samples";
+AMD_shader_fragment_mask                                :: 1;
+AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION                   :: 1;
+AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME                 :: "VK_AMD_shader_fragment_mask";
+EXT_inline_uniform_block                                :: 1;
+EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION                   :: 1;
+EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME                 :: "VK_EXT_inline_uniform_block";
+EXT_shader_stencil_export                               :: 1;
+EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION                  :: 1;
+EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME                :: "VK_EXT_shader_stencil_export";
+EXT_sample_locations                                    :: 1;
+EXT_SAMPLE_LOCATIONS_SPEC_VERSION                       :: 1;
+EXT_SAMPLE_LOCATIONS_EXTENSION_NAME                     :: "VK_EXT_sample_locations";
+EXT_blend_operation_advanced                            :: 1;
+EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION               :: 2;
+EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME             :: "VK_EXT_blend_operation_advanced";
+NV_fragment_coverage_to_color                           :: 1;
+NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION              :: 1;
+NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME            :: "VK_NV_fragment_coverage_to_color";
+NV_framebuffer_mixed_samples                            :: 1;
+NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION               :: 1;
+NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME             :: "VK_NV_framebuffer_mixed_samples";
+NV_fill_rectangle                                       :: 1;
+NV_FILL_RECTANGLE_SPEC_VERSION                          :: 1;
+NV_FILL_RECTANGLE_EXTENSION_NAME                        :: "VK_NV_fill_rectangle";
+NV_shader_sm_builtins                                   :: 1;
+NV_SHADER_SM_BUILTINS_SPEC_VERSION                      :: 1;
+NV_SHADER_SM_BUILTINS_EXTENSION_NAME                    :: "VK_NV_shader_sm_builtins";
+EXT_post_depth_coverage                                 :: 1;
+EXT_POST_DEPTH_COVERAGE_SPEC_VERSION                    :: 1;
+EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME                  :: "VK_EXT_post_depth_coverage";
+EXT_image_drm_format_modifier                           :: 1;
+EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION              :: 1;
+EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME            :: "VK_EXT_image_drm_format_modifier";
+EXT_validation_cache                                    :: 1;
+EXT_VALIDATION_CACHE_SPEC_VERSION                       :: 1;
+EXT_VALIDATION_CACHE_EXTENSION_NAME                     :: "VK_EXT_validation_cache";
+EXT_descriptor_indexing                                 :: 1;
+EXT_DESCRIPTOR_INDEXING_SPEC_VERSION                    :: 2;
+EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME                  :: "VK_EXT_descriptor_indexing";
+EXT_shader_viewport_index_layer                         :: 1;
+EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION            :: 1;
+EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME          :: "VK_EXT_shader_viewport_index_layer";
+NV_shading_rate_image                                   :: 1;
+NV_SHADING_RATE_IMAGE_SPEC_VERSION                      :: 3;
+NV_SHADING_RATE_IMAGE_EXTENSION_NAME                    :: "VK_NV_shading_rate_image";
+NV_ray_tracing                                          :: 1;
+NV_RAY_TRACING_SPEC_VERSION                             :: 3;
+NV_RAY_TRACING_EXTENSION_NAME                           :: "VK_NV_ray_tracing";
+NV_representative_fragment_test                         :: 1;
+NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION            :: 2;
+NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME          :: "VK_NV_representative_fragment_test";
+EXT_filter_cubic                                        :: 1;
+EXT_FILTER_CUBIC_SPEC_VERSION                           :: 3;
+EXT_FILTER_CUBIC_EXTENSION_NAME                         :: "VK_EXT_filter_cubic";
+EXT_global_priority                                     :: 1;
+EXT_GLOBAL_PRIORITY_SPEC_VERSION                        :: 2;
+EXT_GLOBAL_PRIORITY_EXTENSION_NAME                      :: "VK_EXT_global_priority";
+EXT_external_memory_host                                :: 1;
+EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION                   :: 1;
+EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME                 :: "VK_EXT_external_memory_host";
+AMD_buffer_marker                                       :: 1;
+AMD_BUFFER_MARKER_SPEC_VERSION                          :: 1;
+AMD_BUFFER_MARKER_EXTENSION_NAME                        :: "VK_AMD_buffer_marker";
+AMD_pipeline_compiler_control                           :: 1;
+AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION              :: 1;
+AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME            :: "VK_AMD_pipeline_compiler_control";
+EXT_calibrated_timestamps                               :: 1;
+EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION                  :: 2;
+EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME                :: "VK_EXT_calibrated_timestamps";
+AMD_shader_core_properties                              :: 1;
+AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION                 :: 2;
+AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME               :: "VK_AMD_shader_core_properties";
+AMD_memory_overallocation_behavior                      :: 1;
+AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION         :: 1;
+AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME       :: "VK_AMD_memory_overallocation_behavior";
+EXT_vertex_attribute_divisor                            :: 1;
+EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION               :: 3;
+EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME             :: "VK_EXT_vertex_attribute_divisor";
+EXT_pipeline_creation_feedback                          :: 1;
+EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION             :: 1;
+EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME           :: "VK_EXT_pipeline_creation_feedback";
+NV_shader_subgroup_partitioned                          :: 1;
+NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION             :: 1;
+NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME           :: "VK_NV_shader_subgroup_partitioned";
+NV_compute_shader_derivatives                           :: 1;
+NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION              :: 1;
+NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME            :: "VK_NV_compute_shader_derivatives";
+NV_mesh_shader                                          :: 1;
+NV_MESH_SHADER_SPEC_VERSION                             :: 1;
+NV_MESH_SHADER_EXTENSION_NAME                           :: "VK_NV_mesh_shader";
+NV_fragment_shader_barycentric                          :: 1;
+NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION             :: 1;
+NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME           :: "VK_NV_fragment_shader_barycentric";
+NV_shader_image_footprint                               :: 1;
+NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION                  :: 2;
+NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME                :: "VK_NV_shader_image_footprint";
+NV_scissor_exclusive                                    :: 1;
+NV_SCISSOR_EXCLUSIVE_SPEC_VERSION                       :: 1;
+NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME                     :: "VK_NV_scissor_exclusive";
+NV_device_diagnostic_checkpoints                        :: 1;
+NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION           :: 2;
+NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME         :: "VK_NV_device_diagnostic_checkpoints";
+EXT_pci_bus_info                                        :: 1;
+EXT_PCI_BUS_INFO_SPEC_VERSION                           :: 2;
+EXT_PCI_BUS_INFO_EXTENSION_NAME                         :: "VK_EXT_pci_bus_info";
+AMD_display_native_hdr                                  :: 1;
+AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION                     :: 1;
+AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME                   :: "VK_AMD_display_native_hdr";
+EXT_fragment_density_map                                :: 1;
+EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION                   :: 1;
+EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME                 :: "VK_EXT_fragment_density_map";
+EXT_scalar_block_layout                                 :: 1;
+EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION                    :: 1;
+EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME                  :: "VK_EXT_scalar_block_layout";
+GOOGLE_hlsl_functionality1                              :: 1;
+GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION                 :: 1;
+GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME               :: "VK_GOOGLE_hlsl_functionality1";
+GOOGLE_decorate_string                                  :: 1;
+GOOGLE_DECORATE_STRING_SPEC_VERSION                     :: 1;
+GOOGLE_DECORATE_STRING_EXTENSION_NAME                   :: "VK_GOOGLE_decorate_string";
+EXT_subgroup_size_control                               :: 1;
+EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION                  :: 2;
+EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME                :: "VK_EXT_subgroup_size_control";
+AMD_shader_core_properties2                             :: 1;
+AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION               :: 1;
+AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME             :: "VK_AMD_shader_core_properties2";
+AMD_device_coherent_memory                              :: 1;
+AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION                 :: 1;
+AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME               :: "VK_AMD_device_coherent_memory";
+EXT_shader_image_atomic_int64                           :: 1;
+EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION              :: 1;
+EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME            :: "VK_EXT_shader_image_atomic_int64";
+EXT_memory_budget                                       :: 1;
+EXT_MEMORY_BUDGET_SPEC_VERSION                          :: 1;
+EXT_MEMORY_BUDGET_EXTENSION_NAME                        :: "VK_EXT_memory_budget";
+EXT_memory_priority                                     :: 1;
+EXT_MEMORY_PRIORITY_SPEC_VERSION                        :: 1;
+EXT_MEMORY_PRIORITY_EXTENSION_NAME                      :: "VK_EXT_memory_priority";
+NV_dedicated_allocation_image_aliasing                  :: 1;
+NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION     :: 1;
+NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME   :: "VK_NV_dedicated_allocation_image_aliasing";
+EXT_buffer_device_address                               :: 1;
+EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION                  :: 2;
+EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME                :: "VK_EXT_buffer_device_address";
+EXT_tooling_info                                        :: 1;
+EXT_TOOLING_INFO_SPEC_VERSION                           :: 1;
+EXT_TOOLING_INFO_EXTENSION_NAME                         :: "VK_EXT_tooling_info";
+EXT_separate_stencil_usage                              :: 1;
+EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION                 :: 1;
+EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME               :: "VK_EXT_separate_stencil_usage";
+EXT_validation_features                                 :: 1;
+EXT_VALIDATION_FEATURES_SPEC_VERSION                    :: 5;
+EXT_VALIDATION_FEATURES_EXTENSION_NAME                  :: "VK_EXT_validation_features";
+NV_cooperative_matrix                                   :: 1;
+NV_COOPERATIVE_MATRIX_SPEC_VERSION                      :: 1;
+NV_COOPERATIVE_MATRIX_EXTENSION_NAME                    :: "VK_NV_cooperative_matrix";
+NV_coverage_reduction_mode                              :: 1;
+NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION                 :: 1;
+NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME               :: "VK_NV_coverage_reduction_mode";
+EXT_fragment_shader_interlock                           :: 1;
+EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION              :: 1;
+EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME            :: "VK_EXT_fragment_shader_interlock";
+EXT_ycbcr_image_arrays                                  :: 1;
+EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION                     :: 1;
+EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME                   :: "VK_EXT_ycbcr_image_arrays";
+EXT_provoking_vertex                                    :: 1;
+EXT_PROVOKING_VERTEX_SPEC_VERSION                       :: 1;
+EXT_PROVOKING_VERTEX_EXTENSION_NAME                     :: "VK_EXT_provoking_vertex";
+EXT_headless_surface                                    :: 1;
+EXT_HEADLESS_SURFACE_SPEC_VERSION                       :: 1;
+EXT_HEADLESS_SURFACE_EXTENSION_NAME                     :: "VK_EXT_headless_surface";
+EXT_line_rasterization                                  :: 1;
+EXT_LINE_RASTERIZATION_SPEC_VERSION                     :: 1;
+EXT_LINE_RASTERIZATION_EXTENSION_NAME                   :: "VK_EXT_line_rasterization";
+EXT_shader_atomic_float                                 :: 1;
+EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION                    :: 1;
+EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME                  :: "VK_EXT_shader_atomic_float";
+EXT_host_query_reset                                    :: 1;
+EXT_HOST_QUERY_RESET_SPEC_VERSION                       :: 1;
+EXT_HOST_QUERY_RESET_EXTENSION_NAME                     :: "VK_EXT_host_query_reset";
+EXT_index_type_uint8                                    :: 1;
+EXT_INDEX_TYPE_UINT8_SPEC_VERSION                       :: 1;
+EXT_INDEX_TYPE_UINT8_EXTENSION_NAME                     :: "VK_EXT_index_type_uint8";
+EXT_extended_dynamic_state                              :: 1;
+EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION                 :: 1;
+EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME               :: "VK_EXT_extended_dynamic_state";
+EXT_shader_atomic_float2                                :: 1;
+EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION                  :: 1;
+EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME                :: "VK_EXT_shader_atomic_float2";
+EXT_shader_demote_to_helper_invocation                  :: 1;
+EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION     :: 1;
+EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME   :: "VK_EXT_shader_demote_to_helper_invocation";
+NV_device_generated_commands                            :: 1;
+NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION               :: 3;
+NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME             :: "VK_NV_device_generated_commands";
+NV_inherited_viewport_scissor                           :: 1;
+NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION              :: 1;
+NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME            :: "VK_NV_inherited_viewport_scissor";
+EXT_texel_buffer_alignment                              :: 1;
+EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION                 :: 1;
+EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME               :: "VK_EXT_texel_buffer_alignment";
+EXT_device_memory_report                                :: 1;
+EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION                   :: 2;
+EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME                 :: "VK_EXT_device_memory_report";
+EXT_acquire_drm_display                                 :: 1;
+EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION                    :: 1;
+EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME                  :: "VK_EXT_acquire_drm_display";
+EXT_robustness2                                         :: 1;
+EXT_ROBUSTNESS_2_SPEC_VERSION                           :: 1;
+EXT_ROBUSTNESS_2_EXTENSION_NAME                         :: "VK_EXT_robustness2";
+EXT_custom_border_color                                 :: 1;
+EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION                    :: 12;
+EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME                  :: "VK_EXT_custom_border_color";
+GOOGLE_user_type                                        :: 1;
+GOOGLE_USER_TYPE_SPEC_VERSION                           :: 1;
+GOOGLE_USER_TYPE_EXTENSION_NAME                         :: "VK_GOOGLE_user_type";
+EXT_private_data                                        :: 1;
+EXT_PRIVATE_DATA_SPEC_VERSION                           :: 1;
+EXT_PRIVATE_DATA_EXTENSION_NAME                         :: "VK_EXT_private_data";
+EXT_pipeline_creation_cache_control                     :: 1;
+EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION        :: 3;
+EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME      :: "VK_EXT_pipeline_creation_cache_control";
+NV_device_diagnostics_config                            :: 1;
+NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION               :: 1;
+NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME             :: "VK_NV_device_diagnostics_config";
+NV_fragment_shading_rate_enums                          :: 1;
+NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION             :: 1;
+NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME           :: "VK_NV_fragment_shading_rate_enums";
+NV_ray_tracing_motion_blur                              :: 1;
+NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION                 :: 1;
+NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME               :: "VK_NV_ray_tracing_motion_blur";
+EXT_ycbcr_2plane_444_formats                            :: 1;
+EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION               :: 1;
+EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME             :: "VK_EXT_ycbcr_2plane_444_formats";
+EXT_fragment_density_map2                               :: 1;
+EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION                 :: 1;
+EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME               :: "VK_EXT_fragment_density_map2";
+EXT_image_robustness                                    :: 1;
+EXT_IMAGE_ROBUSTNESS_SPEC_VERSION                       :: 1;
+EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME                     :: "VK_EXT_image_robustness";
+EXT_4444_formats                                        :: 1;
+EXT_4444_FORMATS_SPEC_VERSION                           :: 1;
+EXT_4444_FORMATS_EXTENSION_NAME                         :: "VK_EXT_4444_formats";
+NV_acquire_winrt_display                                :: 1;
+NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION                   :: 1;
+NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME                 :: "VK_NV_acquire_winrt_display";
+EXT_vertex_input_dynamic_state                          :: 1;
+EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION             :: 2;
+EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME           :: "VK_EXT_vertex_input_dynamic_state";
+EXT_physical_device_drm                                 :: 1;
+EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION                    :: 1;
+EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME                  :: "VK_EXT_physical_device_drm";
+NV_external_memory_rdma                                 :: 1;
+NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION                    :: 1;
+NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME                  :: "VK_NV_external_memory_rdma";
+EXT_extended_dynamic_state2                             :: 1;
+EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION               :: 1;
+EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME             :: "VK_EXT_extended_dynamic_state2";
+EXT_color_write_enable                                  :: 1;
+EXT_COLOR_WRITE_ENABLE_SPEC_VERSION                     :: 1;
+EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME                   :: "VK_EXT_color_write_enable";
+EXT_global_priority_query                               :: 1;
+EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION                  :: 1;
+EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME                :: "VK_EXT_global_priority_query";
+EXT_multi_draw                                          :: 1;
+EXT_MULTI_DRAW_SPEC_VERSION                             :: 1;
+EXT_MULTI_DRAW_EXTENSION_NAME                           :: "VK_EXT_multi_draw";
+EXT_load_store_op_none                                  :: 1;
+EXT_LOAD_STORE_OP_NONE_SPEC_VERSION                     :: 1;
+EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME                   :: "VK_EXT_load_store_op_none";
+KHR_acceleration_structure                              :: 1;
+KHR_ACCELERATION_STRUCTURE_SPEC_VERSION                 :: 12;
+KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME               :: "VK_KHR_acceleration_structure";
+KHR_ray_tracing_pipeline                                :: 1;
+KHR_RAY_TRACING_PIPELINE_SPEC_VERSION                   :: 1;
+KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME                 :: "VK_KHR_ray_tracing_pipeline";
+KHR_ray_query                                           :: 1;
+KHR_RAY_QUERY_SPEC_VERSION                              :: 1;
+KHR_RAY_QUERY_EXTENSION_NAME                            :: "VK_KHR_ray_query";
+KHR_win32_surface                                       :: 1;
+KHR_WIN32_SURFACE_SPEC_VERSION                          :: 6;
+KHR_WIN32_SURFACE_EXTENSION_NAME                        :: "VK_KHR_win32_surface";
+KHR_external_memory_win32                               :: 1;
+KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION                  :: 1;
+KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME                :: "VK_KHR_external_memory_win32";
+KHR_win32_keyed_mutex                                   :: 1;
+KHR_WIN32_KEYED_MUTEX_SPEC_VERSION                      :: 1;
+KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME                    :: "VK_KHR_win32_keyed_mutex";
+KHR_external_semaphore_win32                            :: 1;
+KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION               :: 1;
+KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME             :: "VK_KHR_external_semaphore_win32";
+KHR_external_fence_win32                                :: 1;
+KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION                   :: 1;
+KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME                 :: "VK_KHR_external_fence_win32";
+NV_external_memory_win32                                :: 1;
+NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION                   :: 1;
+NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME                 :: "VK_NV_external_memory_win32";
+NV_win32_keyed_mutex                                    :: 1;
+NV_WIN32_KEYED_MUTEX_SPEC_VERSION                       :: 2;
+NV_WIN32_KEYED_MUTEX_EXTENSION_NAME                     :: "VK_NV_win32_keyed_mutex";
+EXT_full_screen_exclusive                               :: 1;
+EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION                  :: 4;
+EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME                :: "VK_EXT_full_screen_exclusive";
+EXT_metal_surface                                       :: 1;
+EXT_METAL_SURFACE_SPEC_VERSION                          :: 1;
+EXT_METAL_SURFACE_EXTENSION_NAME                        :: "VK_EXT_metal_surface";
+
+// Handles types
+Instance       :: distinct Handle;
+PhysicalDevice :: distinct Handle;
+Device         :: distinct Handle;
+Queue          :: distinct Handle;
+CommandBuffer  :: distinct Handle;
+Buffer                        :: distinct NonDispatchableHandle;
+Image                         :: distinct NonDispatchableHandle;
+Semaphore                     :: distinct NonDispatchableHandle;
+Fence                         :: distinct NonDispatchableHandle;
+DeviceMemory                  :: distinct NonDispatchableHandle;
+Event                         :: distinct NonDispatchableHandle;
+QueryPool                     :: distinct NonDispatchableHandle;
+BufferView                    :: distinct NonDispatchableHandle;
+ImageView                     :: distinct NonDispatchableHandle;
+ShaderModule                  :: distinct NonDispatchableHandle;
+PipelineCache                 :: distinct NonDispatchableHandle;
+PipelineLayout                :: distinct NonDispatchableHandle;
+Pipeline                      :: distinct NonDispatchableHandle;
+RenderPass                    :: distinct NonDispatchableHandle;
+DescriptorSetLayout           :: distinct NonDispatchableHandle;
+Sampler                       :: distinct NonDispatchableHandle;
+DescriptorSet                 :: distinct NonDispatchableHandle;
+DescriptorPool                :: distinct NonDispatchableHandle;
+Framebuffer                   :: distinct NonDispatchableHandle;
+CommandPool                   :: distinct NonDispatchableHandle;
+SamplerYcbcrConversion        :: distinct NonDispatchableHandle;
+DescriptorUpdateTemplate      :: distinct NonDispatchableHandle;
+SurfaceKHR                    :: distinct NonDispatchableHandle;
+SwapchainKHR                  :: distinct NonDispatchableHandle;
+DisplayKHR                    :: distinct NonDispatchableHandle;
+DisplayModeKHR                :: distinct NonDispatchableHandle;
+DeferredOperationKHR          :: distinct NonDispatchableHandle;
+DebugReportCallbackEXT        :: distinct NonDispatchableHandle;
+CuModuleNVX                   :: distinct NonDispatchableHandle;
+CuFunctionNVX                 :: distinct NonDispatchableHandle;
+DebugUtilsMessengerEXT        :: distinct NonDispatchableHandle;
+ValidationCacheEXT            :: distinct NonDispatchableHandle;
+AccelerationStructureNV       :: distinct NonDispatchableHandle;
+PerformanceConfigurationINTEL :: distinct NonDispatchableHandle;
+IndirectCommandsLayoutNV      :: distinct NonDispatchableHandle;
+PrivateDataSlotEXT            :: distinct NonDispatchableHandle;
+AccelerationStructureKHR      :: distinct NonDispatchableHandle;
+
+

vendor/vulkan/enums.odin

@@ -0,0 +1,2974 @@
+//
+// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
+//
+package vulkan
+
+import "core:c"
+
+// Enums
+Result :: enum c.int {
+	SUCCESS                                            = 0,
+	NOT_READY                                          = 1,
+	TIMEOUT                                            = 2,
+	EVENT_SET                                          = 3,
+	EVENT_RESET                                        = 4,
+	INCOMPLETE                                         = 5,
+	ERROR_OUT_OF_HOST_MEMORY                           = -1,
+	ERROR_OUT_OF_DEVICE_MEMORY                         = -2,
+	ERROR_INITIALIZATION_FAILED                        = -3,
+	ERROR_DEVICE_LOST                                  = -4,
+	ERROR_MEMORY_MAP_FAILED                            = -5,
+	ERROR_LAYER_NOT_PRESENT                            = -6,
+	ERROR_EXTENSION_NOT_PRESENT                        = -7,
+	ERROR_FEATURE_NOT_PRESENT                          = -8,
+	ERROR_INCOMPATIBLE_DRIVER                          = -9,
+	ERROR_TOO_MANY_OBJECTS                             = -10,
+	ERROR_FORMAT_NOT_SUPPORTED                         = -11,
+	ERROR_FRAGMENTED_POOL                              = -12,
+	ERROR_UNKNOWN                                      = -13,
+	ERROR_OUT_OF_POOL_MEMORY                           = -1000069000,
+	ERROR_INVALID_EXTERNAL_HANDLE                      = -1000072003,
+	ERROR_FRAGMENTATION                                = -1000161000,
+	ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS               = -1000257000,
+	ERROR_SURFACE_LOST_KHR                             = -1000000000,
+	ERROR_NATIVE_WINDOW_IN_USE_KHR                     = -1000000001,
+	SUBOPTIMAL_KHR                                     = 1000001003,
+	ERROR_OUT_OF_DATE_KHR                              = -1000001004,
+	ERROR_INCOMPATIBLE_DISPLAY_KHR                     = -1000003001,
+	ERROR_VALIDATION_FAILED_EXT                        = -1000011001,
+	ERROR_INVALID_SHADER_NV                            = -1000012000,
+	ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
+	ERROR_NOT_PERMITTED_EXT                            = -1000174001,
+	ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT          = -1000255000,
+	THREAD_IDLE_KHR                                    = 1000268000,
+	THREAD_DONE_KHR                                    = 1000268001,
+	OPERATION_DEFERRED_KHR                             = 1000268002,
+	OPERATION_NOT_DEFERRED_KHR                         = 1000268003,
+	PIPELINE_COMPILE_REQUIRED_EXT                      = 1000297000,
+	ERROR_OUT_OF_POOL_MEMORY_KHR                       = ERROR_OUT_OF_POOL_MEMORY,
+	ERROR_INVALID_EXTERNAL_HANDLE_KHR                  = ERROR_INVALID_EXTERNAL_HANDLE,
+	ERROR_FRAGMENTATION_EXT                            = ERROR_FRAGMENTATION,
+	ERROR_INVALID_DEVICE_ADDRESS_EXT                   = ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+	ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR           = ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
+	ERROR_PIPELINE_COMPILE_REQUIRED_EXT                = PIPELINE_COMPILE_REQUIRED_EXT,
+}
+
+StructureType :: enum c.int {
+	APPLICATION_INFO                                                  = 0,
+	INSTANCE_CREATE_INFO                                              = 1,
+	DEVICE_QUEUE_CREATE_INFO                                          = 2,
+	DEVICE_CREATE_INFO                                                = 3,
+	SUBMIT_INFO                                                       = 4,
+	MEMORY_ALLOCATE_INFO                                              = 5,
+	MAPPED_MEMORY_RANGE                                               = 6,
+	BIND_SPARSE_INFO                                                  = 7,
+	FENCE_CREATE_INFO                                                 = 8,
+	SEMAPHORE_CREATE_INFO                                             = 9,
+	EVENT_CREATE_INFO                                                 = 10,
+	QUERY_POOL_CREATE_INFO                                            = 11,
+	BUFFER_CREATE_INFO                                                = 12,
+	BUFFER_VIEW_CREATE_INFO                                           = 13,
+	IMAGE_CREATE_INFO                                                 = 14,
+	IMAGE_VIEW_CREATE_INFO                                            = 15,
+	SHADER_MODULE_CREATE_INFO                                         = 16,
+	PIPELINE_CACHE_CREATE_INFO                                        = 17,
+	PIPELINE_SHADER_STAGE_CREATE_INFO                                 = 18,
+	PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO                           = 19,
+	PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO                         = 20,
+	PIPELINE_TESSELLATION_STATE_CREATE_INFO                           = 21,
+	PIPELINE_VIEWPORT_STATE_CREATE_INFO                               = 22,
+	PIPELINE_RASTERIZATION_STATE_CREATE_INFO                          = 23,
+	PIPELINE_MULTISAMPLE_STATE_CREATE_INFO                            = 24,
+	PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO                          = 25,
+	PIPELINE_COLOR_BLEND_STATE_CREATE_INFO                            = 26,
+	PIPELINE_DYNAMIC_STATE_CREATE_INFO                                = 27,
+	GRAPHICS_PIPELINE_CREATE_INFO                                     = 28,
+	COMPUTE_PIPELINE_CREATE_INFO                                      = 29,
+	PIPELINE_LAYOUT_CREATE_INFO                                       = 30,
+	SAMPLER_CREATE_INFO                                               = 31,
+	DESCRIPTOR_SET_LAYOUT_CREATE_INFO                                 = 32,
+	DESCRIPTOR_POOL_CREATE_INFO                                       = 33,
+	DESCRIPTOR_SET_ALLOCATE_INFO                                      = 34,
+	WRITE_DESCRIPTOR_SET                                              = 35,
+	COPY_DESCRIPTOR_SET                                               = 36,
+	FRAMEBUFFER_CREATE_INFO                                           = 37,
+	RENDER_PASS_CREATE_INFO                                           = 38,
+	COMMAND_POOL_CREATE_INFO                                          = 39,
+	COMMAND_BUFFER_ALLOCATE_INFO                                      = 40,
+	COMMAND_BUFFER_INHERITANCE_INFO                                   = 41,
+	COMMAND_BUFFER_BEGIN_INFO                                         = 42,
+	RENDER_PASS_BEGIN_INFO                                            = 43,
+	BUFFER_MEMORY_BARRIER                                             = 44,
+	IMAGE_MEMORY_BARRIER                                              = 45,
+	MEMORY_BARRIER                                                    = 46,
+	LOADER_INSTANCE_CREATE_INFO                                       = 47,
+	LOADER_DEVICE_CREATE_INFO                                         = 48,
+	PHYSICAL_DEVICE_SUBGROUP_PROPERTIES                               = 1000094000,
+	BIND_BUFFER_MEMORY_INFO                                           = 1000157000,
+	BIND_IMAGE_MEMORY_INFO                                            = 1000157001,
+	PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES                            = 1000083000,
+	MEMORY_DEDICATED_REQUIREMENTS                                     = 1000127000,
+	MEMORY_DEDICATED_ALLOCATE_INFO                                    = 1000127001,
+	MEMORY_ALLOCATE_FLAGS_INFO                                        = 1000060000,
+	DEVICE_GROUP_RENDER_PASS_BEGIN_INFO                               = 1000060003,
+	DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO                            = 1000060004,
+	DEVICE_GROUP_SUBMIT_INFO                                          = 1000060005,
+	DEVICE_GROUP_BIND_SPARSE_INFO                                     = 1000060006,
+	BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO                              = 1000060013,
+	BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO                               = 1000060014,
+	PHYSICAL_DEVICE_GROUP_PROPERTIES                                  = 1000070000,
+	DEVICE_GROUP_DEVICE_CREATE_INFO                                   = 1000070001,
+	BUFFER_MEMORY_REQUIREMENTS_INFO_2                                 = 1000146000,
+	IMAGE_MEMORY_REQUIREMENTS_INFO_2                                  = 1000146001,
+	IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2                           = 1000146002,
+	MEMORY_REQUIREMENTS_2                                             = 1000146003,
+	SPARSE_IMAGE_MEMORY_REQUIREMENTS_2                                = 1000146004,
+	PHYSICAL_DEVICE_FEATURES_2                                        = 1000059000,
+	PHYSICAL_DEVICE_PROPERTIES_2                                      = 1000059001,
+	FORMAT_PROPERTIES_2                                               = 1000059002,
+	IMAGE_FORMAT_PROPERTIES_2                                         = 1000059003,
+	PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2                               = 1000059004,
+	QUEUE_FAMILY_PROPERTIES_2                                         = 1000059005,
+	PHYSICAL_DEVICE_MEMORY_PROPERTIES_2                               = 1000059006,
+	SPARSE_IMAGE_FORMAT_PROPERTIES_2                                  = 1000059007,
+	PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2                        = 1000059008,
+	PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES                         = 1000117000,
+	RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO                   = 1000117001,
+	IMAGE_VIEW_USAGE_CREATE_INFO                                      = 1000117002,
+	PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO             = 1000117003,
+	RENDER_PASS_MULTIVIEW_CREATE_INFO                                 = 1000053000,
+	PHYSICAL_DEVICE_MULTIVIEW_FEATURES                                = 1000053001,
+	PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES                              = 1000053002,
+	PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES                        = 1000120000,
+	PROTECTED_SUBMIT_INFO                                             = 1000145000,
+	PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES                         = 1000145001,
+	PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES                       = 1000145002,
+	DEVICE_QUEUE_INFO_2                                               = 1000145003,
+	SAMPLER_YCBCR_CONVERSION_CREATE_INFO                              = 1000156000,
+	SAMPLER_YCBCR_CONVERSION_INFO                                     = 1000156001,
+	BIND_IMAGE_PLANE_MEMORY_INFO                                      = 1000156002,
+	IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO                              = 1000156003,
+	PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES                 = 1000156004,
+	SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES                  = 1000156005,
+	DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO                            = 1000085000,
+	PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO                        = 1000071000,
+	EXTERNAL_IMAGE_FORMAT_PROPERTIES                                  = 1000071001,
+	PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO                              = 1000071002,
+	EXTERNAL_BUFFER_PROPERTIES                                        = 1000071003,
+	PHYSICAL_DEVICE_ID_PROPERTIES                                     = 1000071004,
+	EXTERNAL_MEMORY_BUFFER_CREATE_INFO                                = 1000072000,
+	EXTERNAL_MEMORY_IMAGE_CREATE_INFO                                 = 1000072001,
+	EXPORT_MEMORY_ALLOCATE_INFO                                       = 1000072002,
+	PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO                               = 1000112000,
+	EXTERNAL_FENCE_PROPERTIES                                         = 1000112001,
+	EXPORT_FENCE_CREATE_INFO                                          = 1000113000,
+	EXPORT_SEMAPHORE_CREATE_INFO                                      = 1000077000,
+	PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO                           = 1000076000,
+	EXTERNAL_SEMAPHORE_PROPERTIES                                     = 1000076001,
+	PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES                          = 1000168000,
+	DESCRIPTOR_SET_LAYOUT_SUPPORT                                     = 1000168001,
+	PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES                   = 1000063000,
+	PHYSICAL_DEVICE_VULKAN_1_1_FEATURES                               = 49,
+	PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES                             = 50,
+	PHYSICAL_DEVICE_VULKAN_1_2_FEATURES                               = 51,
+	PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES                             = 52,
+	IMAGE_FORMAT_LIST_CREATE_INFO                                     = 1000147000,
+	ATTACHMENT_DESCRIPTION_2                                          = 1000109000,
+	ATTACHMENT_REFERENCE_2                                            = 1000109001,
+	SUBPASS_DESCRIPTION_2                                             = 1000109002,
+	SUBPASS_DEPENDENCY_2                                              = 1000109003,
+	RENDER_PASS_CREATE_INFO_2                                         = 1000109004,
+	SUBPASS_BEGIN_INFO                                                = 1000109005,
+	SUBPASS_END_INFO                                                  = 1000109006,
+	PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES                             = 1000177000,
+	PHYSICAL_DEVICE_DRIVER_PROPERTIES                                 = 1000196000,
+	PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES                      = 1000180000,
+	PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES                      = 1000082000,
+	PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES                         = 1000197000,
+	DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO                   = 1000161000,
+	PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES                      = 1000161001,
+	PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES                    = 1000161002,
+	DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO            = 1000161003,
+	DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT           = 1000161004,
+	PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES                  = 1000199000,
+	SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE                         = 1000199001,
+	PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES                      = 1000221000,
+	IMAGE_STENCIL_USAGE_CREATE_INFO                                   = 1000246000,
+	PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES                  = 1000130000,
+	SAMPLER_REDUCTION_MODE_CREATE_INFO                                = 1000130001,
+	PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES                      = 1000211000,
+	PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES                    = 1000108000,
+	FRAMEBUFFER_ATTACHMENTS_CREATE_INFO                               = 1000108001,
+	FRAMEBUFFER_ATTACHMENT_IMAGE_INFO                                 = 1000108002,
+	RENDER_PASS_ATTACHMENT_BEGIN_INFO                                 = 1000108003,
+	PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES           = 1000253000,
+	PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES           = 1000175000,
+	PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES           = 1000241000,
+	ATTACHMENT_REFERENCE_STENCIL_LAYOUT                               = 1000241001,
+	ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT                             = 1000241002,
+	PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES                         = 1000261000,
+	PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES                       = 1000207000,
+	PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES                     = 1000207001,
+	SEMAPHORE_TYPE_CREATE_INFO                                        = 1000207002,
+	TIMELINE_SEMAPHORE_SUBMIT_INFO                                    = 1000207003,
+	SEMAPHORE_WAIT_INFO                                               = 1000207004,
+	SEMAPHORE_SIGNAL_INFO                                             = 1000207005,
+	PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES                    = 1000257000,
+	BUFFER_DEVICE_ADDRESS_INFO                                        = 1000244001,
+	BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO                         = 1000257002,
+	MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO                       = 1000257003,
+	DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO                         = 1000257004,
+	SWAPCHAIN_CREATE_INFO_KHR                                         = 1000001000,
+	PRESENT_INFO_KHR                                                  = 1000001001,
+	DEVICE_GROUP_PRESENT_CAPABILITIES_KHR                             = 1000060007,
+	IMAGE_SWAPCHAIN_CREATE_INFO_KHR                                   = 1000060008,
+	BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR                              = 1000060009,
+	ACQUIRE_NEXT_IMAGE_INFO_KHR                                       = 1000060010,
+	DEVICE_GROUP_PRESENT_INFO_KHR                                     = 1000060011,
+	DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR                            = 1000060012,
+	DISPLAY_MODE_CREATE_INFO_KHR                                      = 1000002000,
+	DISPLAY_SURFACE_CREATE_INFO_KHR                                   = 1000002001,
+	DISPLAY_PRESENT_INFO_KHR                                          = 1000003000,
+	XLIB_SURFACE_CREATE_INFO_KHR                                      = 1000004000,
+	XCB_SURFACE_CREATE_INFO_KHR                                       = 1000005000,
+	WAYLAND_SURFACE_CREATE_INFO_KHR                                   = 1000006000,
+	ANDROID_SURFACE_CREATE_INFO_KHR                                   = 1000008000,
+	WIN32_SURFACE_CREATE_INFO_KHR                                     = 1000009000,
+	DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT                             = 1000011000,
+	PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD              = 1000018000,
+	DEBUG_MARKER_OBJECT_NAME_INFO_EXT                                 = 1000022000,
+	DEBUG_MARKER_OBJECT_TAG_INFO_EXT                                  = 1000022001,
+	DEBUG_MARKER_MARKER_INFO_EXT                                      = 1000022002,
+	VIDEO_PROFILE_KHR                                                 = 1000023000,
+	VIDEO_CAPABILITIES_KHR                                            = 1000023001,
+	VIDEO_PICTURE_RESOURCE_KHR                                        = 1000023002,
+	VIDEO_GET_MEMORY_PROPERTIES_KHR                                   = 1000023003,
+	VIDEO_BIND_MEMORY_KHR                                             = 1000023004,
+	VIDEO_SESSION_CREATE_INFO_KHR                                     = 1000023005,
+	VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR                          = 1000023006,
+	VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR                          = 1000023007,
+	VIDEO_BEGIN_CODING_INFO_KHR                                       = 1000023008,
+	VIDEO_END_CODING_INFO_KHR                                         = 1000023009,
+	VIDEO_CODING_CONTROL_INFO_KHR                                     = 1000023010,
+	VIDEO_REFERENCE_SLOT_KHR                                          = 1000023011,
+	VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR                               = 1000023012,
+	VIDEO_PROFILES_KHR                                                = 1000023013,
+	PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR                             = 1000023014,
+	VIDEO_FORMAT_PROPERTIES_KHR                                       = 1000023015,
+	VIDEO_DECODE_INFO_KHR                                             = 1000024000,
+	DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV                         = 1000026000,
+	DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV                        = 1000026001,
+	DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV                      = 1000026002,
+	PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT                   = 1000028000,
+	PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT                 = 1000028001,
+	PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT               = 1000028002,
+	CU_MODULE_CREATE_INFO_NVX                                         = 1000029000,
+	CU_FUNCTION_CREATE_INFO_NVX                                       = 1000029001,
+	CU_LAUNCH_INFO_NVX                                                = 1000029002,
+	IMAGE_VIEW_HANDLE_INFO_NVX                                        = 1000030000,
+	IMAGE_VIEW_ADDRESS_PROPERTIES_NVX                                 = 1000030001,
+	VIDEO_ENCODE_H264_CAPABILITIES_EXT                                = 1000038000,
+	VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT                         = 1000038001,
+	VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT              = 1000038002,
+	VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT                 = 1000038003,
+	VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT                              = 1000038004,
+	VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT                               = 1000038005,
+	VIDEO_ENCODE_H264_NALU_SLICE_EXT                                  = 1000038006,
+	VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT                     = 1000038007,
+	VIDEO_ENCODE_H264_PROFILE_EXT                                     = 1000038008,
+	VIDEO_DECODE_H264_CAPABILITIES_EXT                                = 1000040000,
+	VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT                         = 1000040001,
+	VIDEO_DECODE_H264_PICTURE_INFO_EXT                                = 1000040002,
+	VIDEO_DECODE_H264_MVC_EXT                                         = 1000040003,
+	VIDEO_DECODE_H264_PROFILE_EXT                                     = 1000040004,
+	VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT              = 1000040005,
+	VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT                 = 1000040006,
+	VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT                               = 1000040007,
+	TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD                          = 1000041000,
+	STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP                         = 1000049000,
+	PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV                  = 1000050000,
+	EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV                              = 1000056000,
+	EXPORT_MEMORY_ALLOCATE_INFO_NV                                    = 1000056001,
+	IMPORT_MEMORY_WIN32_HANDLE_INFO_NV                                = 1000057000,
+	EXPORT_MEMORY_WIN32_HANDLE_INFO_NV                                = 1000057001,
+	WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV                         = 1000058000,
+	VALIDATION_FLAGS_EXT                                              = 1000061000,
+	VI_SURFACE_CREATE_INFO_NN                                         = 1000062000,
+	PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT         = 1000066000,
+	IMAGE_VIEW_ASTC_DECODE_MODE_EXT                                   = 1000067000,
+	PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT                          = 1000067001,
+	IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR                               = 1000073000,
+	EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR                               = 1000073001,
+	MEMORY_WIN32_HANDLE_PROPERTIES_KHR                                = 1000073002,
+	MEMORY_GET_WIN32_HANDLE_INFO_KHR                                  = 1000073003,
+	IMPORT_MEMORY_FD_INFO_KHR                                         = 1000074000,
+	MEMORY_FD_PROPERTIES_KHR                                          = 1000074001,
+	MEMORY_GET_FD_INFO_KHR                                            = 1000074002,
+	WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR                        = 1000075000,
+	IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR                            = 1000078000,
+	EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR                            = 1000078001,
+	D3D12_FENCE_SUBMIT_INFO_KHR                                       = 1000078002,
+	SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR                               = 1000078003,
+	IMPORT_SEMAPHORE_FD_INFO_KHR                                      = 1000079000,
+	SEMAPHORE_GET_FD_INFO_KHR                                         = 1000079001,
+	PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR                    = 1000080000,
+	COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT         = 1000081000,
+	PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT                = 1000081001,
+	CONDITIONAL_RENDERING_BEGIN_INFO_EXT                              = 1000081002,
+	PRESENT_REGIONS_KHR                                               = 1000084000,
+	PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV                  = 1000087000,
+	SURFACE_CAPABILITIES_2_EXT                                        = 1000090000,
+	DISPLAY_POWER_INFO_EXT                                            = 1000091000,
+	DEVICE_EVENT_INFO_EXT                                             = 1000091001,
+	DISPLAY_EVENT_INFO_EXT                                            = 1000091002,
+	SWAPCHAIN_COUNTER_CREATE_INFO_EXT                                 = 1000091003,
+	PRESENT_TIMES_INFO_GOOGLE                                         = 1000092000,
+	PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX      = 1000097000,
+	PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV                    = 1000098000,
+	PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT                  = 1000099000,
+	PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT                  = 1000099001,
+	PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT         = 1000101000,
+	PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT         = 1000101001,
+	PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT                    = 1000102000,
+	PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT           = 1000102001,
+	HDR_METADATA_EXT                                                  = 1000105000,
+	SHARED_PRESENT_SURFACE_CAPABILITIES_KHR                           = 1000111000,
+	IMPORT_FENCE_WIN32_HANDLE_INFO_KHR                                = 1000114000,
+	EXPORT_FENCE_WIN32_HANDLE_INFO_KHR                                = 1000114001,
+	FENCE_GET_WIN32_HANDLE_INFO_KHR                                   = 1000114002,
+	IMPORT_FENCE_FD_INFO_KHR                                          = 1000115000,
+	FENCE_GET_FD_INFO_KHR                                             = 1000115001,
+	PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR                    = 1000116000,
+	PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR                  = 1000116001,
+	QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR                            = 1000116002,
+	PERFORMANCE_QUERY_SUBMIT_INFO_KHR                                 = 1000116003,
+	ACQUIRE_PROFILING_LOCK_INFO_KHR                                   = 1000116004,
+	PERFORMANCE_COUNTER_KHR                                           = 1000116005,
+	PERFORMANCE_COUNTER_DESCRIPTION_KHR                               = 1000116006,
+	PHYSICAL_DEVICE_SURFACE_INFO_2_KHR                                = 1000119000,
+	SURFACE_CAPABILITIES_2_KHR                                        = 1000119001,
+	SURFACE_FORMAT_2_KHR                                              = 1000119002,
+	DISPLAY_PROPERTIES_2_KHR                                          = 1000121000,
+	DISPLAY_PLANE_PROPERTIES_2_KHR                                    = 1000121001,
+	DISPLAY_MODE_PROPERTIES_2_KHR                                     = 1000121002,
+	DISPLAY_PLANE_INFO_2_KHR                                          = 1000121003,
+	DISPLAY_PLANE_CAPABILITIES_2_KHR                                  = 1000121004,
+	IOS_SURFACE_CREATE_INFO_MVK                                       = 1000122000,
+	MACOS_SURFACE_CREATE_INFO_MVK                                     = 1000123000,
+	DEBUG_UTILS_OBJECT_NAME_INFO_EXT                                  = 1000128000,
+	DEBUG_UTILS_OBJECT_TAG_INFO_EXT                                   = 1000128001,
+	DEBUG_UTILS_LABEL_EXT                                             = 1000128002,
+	DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT                           = 1000128003,
+	DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT                             = 1000128004,
+	ANDROID_HARDWARE_BUFFER_USAGE_ANDROID                             = 1000129000,
+	ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID                        = 1000129001,
+	ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID                 = 1000129002,
+	IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID                       = 1000129003,
+	MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID                   = 1000129004,
+	EXTERNAL_FORMAT_ANDROID                                           = 1000129005,
+	PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT                 = 1000138000,
+	PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT               = 1000138001,
+	WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT                     = 1000138002,
+	DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT              = 1000138003,
+	SAMPLE_LOCATIONS_INFO_EXT                                         = 1000143000,
+	RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT                       = 1000143001,
+	PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT                   = 1000143002,
+	PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT                   = 1000143003,
+	MULTISAMPLE_PROPERTIES_EXT                                        = 1000143004,
+	PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT             = 1000148000,
+	PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT           = 1000148001,
+	PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT               = 1000148002,
+	PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV                   = 1000149000,
+	WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR                   = 1000150007,
+	ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR                    = 1000150000,
+	ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR                    = 1000150002,
+	ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR                    = 1000150003,
+	ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR                = 1000150004,
+	ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR                = 1000150005,
+	ACCELERATION_STRUCTURE_GEOMETRY_KHR                               = 1000150006,
+	ACCELERATION_STRUCTURE_VERSION_INFO_KHR                           = 1000150009,
+	COPY_ACCELERATION_STRUCTURE_INFO_KHR                              = 1000150010,
+	COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR                    = 1000150011,
+	COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR                    = 1000150012,
+	PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR               = 1000150013,
+	PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR             = 1000150014,
+	ACCELERATION_STRUCTURE_CREATE_INFO_KHR                            = 1000150017,
+	ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR                       = 1000150020,
+	PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR                 = 1000347000,
+	PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR               = 1000347001,
+	RAY_TRACING_PIPELINE_CREATE_INFO_KHR                              = 1000150015,
+	RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR                          = 1000150016,
+	RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR                    = 1000150018,
+	PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR                            = 1000348013,
+	PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV                 = 1000152000,
+	PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV                    = 1000154000,
+	PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV                  = 1000154001,
+	DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT                           = 1000158000,
+	PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT                = 1000158002,
+	IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT                    = 1000158003,
+	IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT                = 1000158004,
+	IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT                          = 1000158005,
+	VALIDATION_CACHE_CREATE_INFO_EXT                                  = 1000160000,
+	SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT                    = 1000160001,
+	PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR                   = 1000163000,
+	PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR                 = 1000163001,
+	PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV         = 1000164000,
+	PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV                    = 1000164001,
+	PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV                  = 1000164002,
+	PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV        = 1000164005,
+	RAY_TRACING_PIPELINE_CREATE_INFO_NV                               = 1000165000,
+	ACCELERATION_STRUCTURE_CREATE_INFO_NV                             = 1000165001,
+	GEOMETRY_NV                                                       = 1000165003,
+	GEOMETRY_TRIANGLES_NV                                             = 1000165004,
+	GEOMETRY_AABB_NV                                                  = 1000165005,
+	BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV                        = 1000165006,
+	WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV                    = 1000165007,
+	ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV                = 1000165008,
+	PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV                         = 1000165009,
+	RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV                           = 1000165011,
+	ACCELERATION_STRUCTURE_INFO_NV                                    = 1000165012,
+	PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV          = 1000166000,
+	PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV        = 1000166001,
+	PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT                  = 1000170000,
+	FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT               = 1000170001,
+	DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT                      = 1000174000,
+	IMPORT_MEMORY_HOST_POINTER_INFO_EXT                               = 1000178000,
+	MEMORY_HOST_POINTER_PROPERTIES_EXT                                = 1000178001,
+	PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT               = 1000178002,
+	PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR                         = 1000181000,
+	PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD                         = 1000183000,
+	CALIBRATED_TIMESTAMP_INFO_EXT                                     = 1000184000,
+	PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD                        = 1000185000,
+	VIDEO_DECODE_H265_CAPABILITIES_EXT                                = 1000187000,
+	VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT                         = 1000187001,
+	VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT              = 1000187002,
+	VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT                 = 1000187003,
+	VIDEO_DECODE_H265_PROFILE_EXT                                     = 1000187004,
+	VIDEO_DECODE_H265_PICTURE_INFO_EXT                                = 1000187005,
+	VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT                               = 1000187006,
+	DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD                      = 1000189000,
+	PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT           = 1000190000,
+	PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT               = 1000190001,
+	PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT             = 1000190002,
+	PRESENT_FRAME_TOKEN_GGP                                           = 1000191000,
+	PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT                        = 1000192000,
+	PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV            = 1000201000,
+	PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV                           = 1000202000,
+	PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV                         = 1000202001,
+	PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV           = 1000203000,
+	PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV                = 1000204000,
+	PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV          = 1000205000,
+	PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV                     = 1000205002,
+	CHECKPOINT_DATA_NV                                                = 1000206000,
+	QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV                             = 1000206001,
+	PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL         = 1000209000,
+	QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL                    = 1000210000,
+	INITIALIZE_PERFORMANCE_API_INFO_INTEL                             = 1000210001,
+	PERFORMANCE_MARKER_INFO_INTEL                                     = 1000210002,
+	PERFORMANCE_STREAM_MARKER_INFO_INTEL                              = 1000210003,
+	PERFORMANCE_OVERRIDE_INFO_INTEL                                   = 1000210004,
+	PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL                      = 1000210005,
+	PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT                       = 1000212000,
+	DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD                       = 1000213000,
+	SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD                      = 1000213001,
+	IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA                             = 1000214000,
+	PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR          = 1000215000,
+	METAL_SURFACE_CREATE_INFO_EXT                                     = 1000217000,
+	PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT                 = 1000218000,
+	PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT               = 1000218001,
+	RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT                  = 1000218002,
+	PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT              = 1000225000,
+	PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT      = 1000225001,
+	PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT                = 1000225002,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR                         = 1000226000,
+	PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR              = 1000226001,
+	PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR              = 1000226002,
+	PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR                = 1000226003,
+	PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR                         = 1000226004,
+	PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD                      = 1000227000,
+	PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD                      = 1000229000,
+	PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT            = 1000234000,
+	PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT                      = 1000237000,
+	PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT                      = 1000238000,
+	MEMORY_PRIORITY_ALLOCATE_INFO_EXT                                 = 1000238001,
+	SURFACE_PROTECTED_CAPABILITIES_KHR                                = 1000239000,
+	PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV   = 1000240000,
+	PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT                = 1000244000,
+	BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT                             = 1000244002,
+	PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT                               = 1000245000,
+	VALIDATION_FEATURES_EXT                                           = 1000247000,
+	PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR                         = 1000248000,
+	PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV                    = 1000249000,
+	COOPERATIVE_MATRIX_PROPERTIES_NV                                  = 1000249001,
+	PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV                  = 1000249002,
+	PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV               = 1000250000,
+	PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV                  = 1000250001,
+	FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV                          = 1000250002,
+	PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT            = 1000251000,
+	PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT                   = 1000252000,
+	PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT                     = 1000254000,
+	PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT     = 1000254001,
+	PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT                   = 1000254002,
+	SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT                            = 1000255000,
+	SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT                    = 1000255002,
+	SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT                      = 1000255001,
+	HEADLESS_SURFACE_CREATE_INFO_EXT                                  = 1000256000,
+	PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT                   = 1000259000,
+	PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT                 = 1000259001,
+	PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT                 = 1000259002,
+	PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT                  = 1000260000,
+	PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT                     = 1000265000,
+	PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT               = 1000267000,
+	PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR       = 1000269000,
+	PIPELINE_INFO_KHR                                                 = 1000269001,
+	PIPELINE_EXECUTABLE_PROPERTIES_KHR                                = 1000269002,
+	PIPELINE_EXECUTABLE_INFO_KHR                                      = 1000269003,
+	PIPELINE_EXECUTABLE_STATISTIC_KHR                                 = 1000269004,
+	PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR                   = 1000269005,
+	PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT                = 1000273000,
+	PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT   = 1000276000,
+	PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV           = 1000277000,
+	GRAPHICS_SHADER_GROUP_CREATE_INFO_NV                              = 1000277001,
+	GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV                    = 1000277002,
+	INDIRECT_COMMANDS_LAYOUT_TOKEN_NV                                 = 1000277003,
+	INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV                           = 1000277004,
+	GENERATED_COMMANDS_INFO_NV                                        = 1000277005,
+	GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV                    = 1000277006,
+	PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV             = 1000277007,
+	PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV            = 1000278000,
+	COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV               = 1000278001,
+	PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT               = 1000281000,
+	PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT             = 1000281001,
+	COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM        = 1000282000,
+	RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM                             = 1000282001,
+	PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT                 = 1000284000,
+	DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT                       = 1000284001,
+	DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT                            = 1000284002,
+	PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT                         = 1000286000,
+	PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT                       = 1000286001,
+	SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT                       = 1000287000,
+	PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT                = 1000287001,
+	PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT                  = 1000287002,
+	PIPELINE_LIBRARY_CREATE_INFO_KHR                                  = 1000290000,
+	PRESENT_ID_KHR                                                    = 1000294000,
+	PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR                           = 1000294001,
+	PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT                         = 1000295000,
+	DEVICE_PRIVATE_DATA_CREATE_INFO_EXT                               = 1000295001,
+	PRIVATE_DATA_SLOT_CREATE_INFO_EXT                                 = 1000295002,
+	PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT      = 1000297000,
+	VIDEO_ENCODE_INFO_KHR                                             = 1000299000,
+	VIDEO_ENCODE_RATE_CONTROL_INFO_KHR                                = 1000299001,
+	PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV                    = 1000300000,
+	DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV                          = 1000300001,
+	MEMORY_BARRIER_2_KHR                                              = 1000314000,
+	BUFFER_MEMORY_BARRIER_2_KHR                                       = 1000314001,
+	IMAGE_MEMORY_BARRIER_2_KHR                                        = 1000314002,
+	DEPENDENCY_INFO_KHR                                               = 1000314003,
+	SUBMIT_INFO_2_KHR                                                 = 1000314004,
+	SEMAPHORE_SUBMIT_INFO_KHR                                         = 1000314005,
+	COMMAND_BUFFER_SUBMIT_INFO_KHR                                    = 1000314006,
+	PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR                    = 1000314007,
+	QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV                           = 1000314008,
+	CHECKPOINT_DATA_2_NV                                              = 1000314009,
+	PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000,
+	PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR     = 1000325000,
+	PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV         = 1000326000,
+	PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV           = 1000326001,
+	PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV          = 1000326002,
+	ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV          = 1000327000,
+	PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV               = 1000327001,
+	ACCELERATION_STRUCTURE_MOTION_INFO_NV                             = 1000327002,
+	PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT            = 1000330000,
+	PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT               = 1000332000,
+	PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT             = 1000332001,
+	COPY_COMMAND_TRANSFORM_INFO_QCOM                                  = 1000333000,
+	PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT                     = 1000335000,
+	PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR     = 1000336000,
+	COPY_BUFFER_INFO_2_KHR                                            = 1000337000,
+	COPY_IMAGE_INFO_2_KHR                                             = 1000337001,
+	COPY_BUFFER_TO_IMAGE_INFO_2_KHR                                   = 1000337002,
+	COPY_IMAGE_TO_BUFFER_INFO_2_KHR                                   = 1000337003,
+	BLIT_IMAGE_INFO_2_KHR                                             = 1000337004,
+	RESOLVE_IMAGE_INFO_2_KHR                                          = 1000337005,
+	BUFFER_COPY_2_KHR                                                 = 1000337006,
+	IMAGE_COPY_2_KHR                                                  = 1000337007,
+	IMAGE_BLIT_2_KHR                                                  = 1000337008,
+	BUFFER_IMAGE_COPY_2_KHR                                           = 1000337009,
+	IMAGE_RESOLVE_2_KHR                                               = 1000337010,
+	PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT                         = 1000340000,
+	DIRECTFB_SURFACE_CREATE_INFO_EXT                                  = 1000346000,
+	PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE            = 1000351000,
+	MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE                         = 1000351002,
+	PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT           = 1000352000,
+	VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT                            = 1000352001,
+	VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT                          = 1000352002,
+	PHYSICAL_DEVICE_DRM_PROPERTIES_EXT                                = 1000353000,
+	IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA                          = 1000364000,
+	MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA                           = 1000364001,
+	MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA                             = 1000364002,
+	IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA                       = 1000365000,
+	SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA                          = 1000365001,
+	SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI                       = 1000369000,
+	PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI                   = 1000369001,
+	PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI                 = 1000369002,
+	PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI                   = 1000370000,
+	MEMORY_GET_REMOTE_ADDRESS_INFO_NV                                 = 1000371000,
+	PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV                  = 1000371001,
+	PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT             = 1000377000,
+	SCREEN_SURFACE_CREATE_INFO_QNX                                    = 1000378000,
+	PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT                   = 1000381000,
+	PIPELINE_COLOR_WRITE_CREATE_INFO_EXT                              = 1000381001,
+	PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT                = 1000388000,
+	QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT                       = 1000388001,
+	PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT                           = 1000392000,
+	PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT                         = 1000392001,
+	PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES                         = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+	PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES                    = PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
+	DEBUG_REPORT_CREATE_INFO_EXT                                      = DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+	RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR                             = RENDER_PASS_MULTIVIEW_CREATE_INFO,
+	PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR                            = PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+	PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR                          = PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
+	PHYSICAL_DEVICE_FEATURES_2_KHR                                    = PHYSICAL_DEVICE_FEATURES_2,
+	PHYSICAL_DEVICE_PROPERTIES_2_KHR                                  = PHYSICAL_DEVICE_PROPERTIES_2,
+	FORMAT_PROPERTIES_2_KHR                                           = FORMAT_PROPERTIES_2,
+	IMAGE_FORMAT_PROPERTIES_2_KHR                                     = IMAGE_FORMAT_PROPERTIES_2,
+	PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR                           = PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+	QUEUE_FAMILY_PROPERTIES_2_KHR                                     = QUEUE_FAMILY_PROPERTIES_2,
+	PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR                           = PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
+	SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR                              = SPARSE_IMAGE_FORMAT_PROPERTIES_2,
+	PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR                    = PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
+	MEMORY_ALLOCATE_FLAGS_INFO_KHR                                    = MEMORY_ALLOCATE_FLAGS_INFO,
+	DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR                           = DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
+	DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR                        = DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
+	DEVICE_GROUP_SUBMIT_INFO_KHR                                      = DEVICE_GROUP_SUBMIT_INFO,
+	DEVICE_GROUP_BIND_SPARSE_INFO_KHR                                 = DEVICE_GROUP_BIND_SPARSE_INFO,
+	BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR                          = BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
+	BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR                           = BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
+	PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR                              = PHYSICAL_DEVICE_GROUP_PROPERTIES,
+	DEVICE_GROUP_DEVICE_CREATE_INFO_KHR                               = DEVICE_GROUP_DEVICE_CREATE_INFO,
+	PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR                    = PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+	EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR                              = EXTERNAL_IMAGE_FORMAT_PROPERTIES,
+	PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR                          = PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+	EXTERNAL_BUFFER_PROPERTIES_KHR                                    = EXTERNAL_BUFFER_PROPERTIES,
+	PHYSICAL_DEVICE_ID_PROPERTIES_KHR                                 = PHYSICAL_DEVICE_ID_PROPERTIES,
+	EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR                            = EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+	EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR                             = EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+	EXPORT_MEMORY_ALLOCATE_INFO_KHR                                   = EXPORT_MEMORY_ALLOCATE_INFO,
+	PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR                       = PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+	EXTERNAL_SEMAPHORE_PROPERTIES_KHR                                 = EXTERNAL_SEMAPHORE_PROPERTIES,
+	EXPORT_SEMAPHORE_CREATE_INFO_KHR                                  = EXPORT_SEMAPHORE_CREATE_INFO,
+	PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR                  = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+	PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR                         = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+	PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR                        = PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+	DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR                        = DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
+	SURFACE_CAPABILITIES2_EXT                                         = SURFACE_CAPABILITIES_2_EXT,
+	PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR                = PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+	FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR                           = FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
+	FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR                             = FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+	RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR                             = RENDER_PASS_ATTACHMENT_BEGIN_INFO,
+	ATTACHMENT_DESCRIPTION_2_KHR                                      = ATTACHMENT_DESCRIPTION_2,
+	ATTACHMENT_REFERENCE_2_KHR                                        = ATTACHMENT_REFERENCE_2,
+	SUBPASS_DESCRIPTION_2_KHR                                         = SUBPASS_DESCRIPTION_2,
+	SUBPASS_DEPENDENCY_2_KHR                                          = SUBPASS_DEPENDENCY_2,
+	RENDER_PASS_CREATE_INFO_2_KHR                                     = RENDER_PASS_CREATE_INFO_2,
+	SUBPASS_BEGIN_INFO_KHR                                            = SUBPASS_BEGIN_INFO,
+	SUBPASS_END_INFO_KHR                                              = SUBPASS_END_INFO,
+	PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR                           = PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
+	EXTERNAL_FENCE_PROPERTIES_KHR                                     = EXTERNAL_FENCE_PROPERTIES,
+	EXPORT_FENCE_CREATE_INFO_KHR                                      = EXPORT_FENCE_CREATE_INFO,
+	PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR                     = PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
+	RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR               = RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
+	IMAGE_VIEW_USAGE_CREATE_INFO_KHR                                  = IMAGE_VIEW_USAGE_CREATE_INFO,
+	PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR         = PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
+	PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR                    = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+	PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR                     = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
+	MEMORY_DEDICATED_REQUIREMENTS_KHR                                 = MEMORY_DEDICATED_REQUIREMENTS,
+	MEMORY_DEDICATED_ALLOCATE_INFO_KHR                                = MEMORY_DEDICATED_ALLOCATE_INFO,
+	PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT              = PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
+	SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT                            = SAMPLER_REDUCTION_MODE_CREATE_INFO,
+	BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR                             = BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+	IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR                              = IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+	IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR                       = IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
+	MEMORY_REQUIREMENTS_2_KHR                                         = MEMORY_REQUIREMENTS_2,
+	SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR                            = SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
+	IMAGE_FORMAT_LIST_CREATE_INFO_KHR                                 = IMAGE_FORMAT_LIST_CREATE_INFO,
+	SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR                          = SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+	SAMPLER_YCBCR_CONVERSION_INFO_KHR                                 = SAMPLER_YCBCR_CONVERSION_INFO,
+	BIND_IMAGE_PLANE_MEMORY_INFO_KHR                                  = BIND_IMAGE_PLANE_MEMORY_INFO,
+	IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR                          = IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
+	PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR             = PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+	SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR              = SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
+	BIND_BUFFER_MEMORY_INFO_KHR                                       = BIND_BUFFER_MEMORY_INFO,
+	BIND_IMAGE_MEMORY_INFO_KHR                                        = BIND_IMAGE_MEMORY_INFO,
+	DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT               = DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
+	PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT                  = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+	PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT                = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
+	DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT        = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
+	DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT       = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
+	PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR                      = PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
+	DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR                                 = DESCRIPTOR_SET_LAYOUT_SUPPORT,
+	PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR       = PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
+	PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR                         = PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
+	PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR                  = PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+	PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR                             = PHYSICAL_DEVICE_DRIVER_PROPERTIES,
+	PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR                     = PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
+	PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR              = PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
+	SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR                     = SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
+	PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR                   = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
+	PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR                 = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
+	SEMAPHORE_TYPE_CREATE_INFO_KHR                                    = SEMAPHORE_TYPE_CREATE_INFO,
+	TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR                                = TIMELINE_SEMAPHORE_SUBMIT_INFO,
+	SEMAPHORE_WAIT_INFO_KHR                                           = SEMAPHORE_WAIT_INFO,
+	SEMAPHORE_SIGNAL_INFO_KHR                                         = SEMAPHORE_SIGNAL_INFO,
+	QUERY_POOL_CREATE_INFO_INTEL                                      = QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
+	PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR                  = PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
+	PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT                  = PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
+	PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR       = PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
+	ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR                           = ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
+	ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR                         = ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
+	PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT                       = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+	BUFFER_DEVICE_ADDRESS_INFO_EXT                                    = BUFFER_DEVICE_ADDRESS_INFO,
+	IMAGE_STENCIL_USAGE_CREATE_INFO_EXT                               = IMAGE_STENCIL_USAGE_CREATE_INFO,
+	PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR       = PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
+	PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR                = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
+	BUFFER_DEVICE_ADDRESS_INFO_KHR                                    = BUFFER_DEVICE_ADDRESS_INFO,
+	BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR                     = BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
+	MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR                   = MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
+	DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR                     = DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+	PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT                     = PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+}
+
+ImageLayout :: enum c.int {
+	UNDEFINED                                      = 0,
+	GENERAL                                        = 1,
+	COLOR_ATTACHMENT_OPTIMAL                       = 2,
+	DEPTH_STENCIL_ATTACHMENT_OPTIMAL               = 3,
+	DEPTH_STENCIL_READ_ONLY_OPTIMAL                = 4,
+	SHADER_READ_ONLY_OPTIMAL                       = 5,
+	TRANSFER_SRC_OPTIMAL                           = 6,
+	TRANSFER_DST_OPTIMAL                           = 7,
+	PREINITIALIZED                                 = 8,
+	DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL     = 1000117000,
+	DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL     = 1000117001,
+	DEPTH_ATTACHMENT_OPTIMAL                       = 1000241000,
+	DEPTH_READ_ONLY_OPTIMAL                        = 1000241001,
+	STENCIL_ATTACHMENT_OPTIMAL                     = 1000241002,
+	STENCIL_READ_ONLY_OPTIMAL                      = 1000241003,
+	PRESENT_SRC_KHR                                = 1000001002,
+	VIDEO_DECODE_DST_KHR                           = 1000024000,
+	VIDEO_DECODE_SRC_KHR                           = 1000024001,
+	VIDEO_DECODE_DPB_KHR                           = 1000024002,
+	SHARED_PRESENT_KHR                             = 1000111000,
+	FRAGMENT_DENSITY_MAP_OPTIMAL_EXT               = 1000218000,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR   = 1000164003,
+	VIDEO_ENCODE_DST_KHR                           = 1000299000,
+	VIDEO_ENCODE_SRC_KHR                           = 1000299001,
+	VIDEO_ENCODE_DPB_KHR                           = 1000299002,
+	READ_ONLY_OPTIMAL_KHR                          = 1000314000,
+	ATTACHMENT_OPTIMAL_KHR                         = 1000314001,
+	DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+	DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+	SHADING_RATE_OPTIMAL_NV                        = FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
+	DEPTH_ATTACHMENT_OPTIMAL_KHR                   = DEPTH_ATTACHMENT_OPTIMAL,
+	DEPTH_READ_ONLY_OPTIMAL_KHR                    = DEPTH_READ_ONLY_OPTIMAL,
+	STENCIL_ATTACHMENT_OPTIMAL_KHR                 = STENCIL_ATTACHMENT_OPTIMAL,
+	STENCIL_READ_ONLY_OPTIMAL_KHR                  = STENCIL_READ_ONLY_OPTIMAL,
+}
+
+ObjectType :: enum c.int {
+	UNKNOWN                         = 0,
+	INSTANCE                        = 1,
+	PHYSICAL_DEVICE                 = 2,
+	DEVICE                          = 3,
+	QUEUE                           = 4,
+	SEMAPHORE                       = 5,
+	COMMAND_BUFFER                  = 6,
+	FENCE                           = 7,
+	DEVICE_MEMORY                   = 8,
+	BUFFER                          = 9,
+	IMAGE                           = 10,
+	EVENT                           = 11,
+	QUERY_POOL                      = 12,
+	BUFFER_VIEW                     = 13,
+	IMAGE_VIEW                      = 14,
+	SHADER_MODULE                   = 15,
+	PIPELINE_CACHE                  = 16,
+	PIPELINE_LAYOUT                 = 17,
+	RENDER_PASS                     = 18,
+	PIPELINE                        = 19,
+	DESCRIPTOR_SET_LAYOUT           = 20,
+	SAMPLER                         = 21,
+	DESCRIPTOR_POOL                 = 22,
+	DESCRIPTOR_SET                  = 23,
+	FRAMEBUFFER                     = 24,
+	COMMAND_POOL                    = 25,
+	SAMPLER_YCBCR_CONVERSION        = 1000156000,
+	DESCRIPTOR_UPDATE_TEMPLATE      = 1000085000,
+	SURFACE_KHR                     = 1000000000,
+	SWAPCHAIN_KHR                   = 1000001000,
+	DISPLAY_KHR                     = 1000002000,
+	DISPLAY_MODE_KHR                = 1000002001,
+	DEBUG_REPORT_CALLBACK_EXT       = 1000011000,
+	VIDEO_SESSION_KHR               = 1000023000,
+	VIDEO_SESSION_PARAMETERS_KHR    = 1000023001,
+	CU_MODULE_NVX                   = 1000029000,
+	CU_FUNCTION_NVX                 = 1000029001,
+	DEBUG_UTILS_MESSENGER_EXT       = 1000128000,
+	ACCELERATION_STRUCTURE_KHR      = 1000150000,
+	VALIDATION_CACHE_EXT            = 1000160000,
+	ACCELERATION_STRUCTURE_NV       = 1000165000,
+	PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
+	DEFERRED_OPERATION_KHR          = 1000268000,
+	INDIRECT_COMMANDS_LAYOUT_NV     = 1000277000,
+	PRIVATE_DATA_SLOT_EXT           = 1000295000,
+	DESCRIPTOR_UPDATE_TEMPLATE_KHR  = DESCRIPTOR_UPDATE_TEMPLATE,
+	SAMPLER_YCBCR_CONVERSION_KHR    = SAMPLER_YCBCR_CONVERSION,
+}
+
+PipelineCacheHeaderVersion :: enum c.int {
+	ONE = 1,
+}
+
+VendorId :: enum c.int {
+	VIV      = 0x10001,
+	VSI      = 0x10002,
+	KAZAN    = 0x10003,
+	CODEPLAY = 0x10004,
+	MESA     = 0x10005,
+	POCL     = 0x10006,
+}
+
+SystemAllocationScope :: enum c.int {
+	COMMAND  = 0,
+	OBJECT   = 1,
+	CACHE    = 2,
+	DEVICE   = 3,
+	INSTANCE = 4,
+}
+
+InternalAllocationType :: enum c.int {
+	EXECUTABLE = 0,
+}
+
+Format :: enum c.int {
+	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,
+	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                      = 1000066000,
+	ASTC_5x4_SFLOAT_BLOCK_EXT                      = 1000066001,
+	ASTC_5x5_SFLOAT_BLOCK_EXT                      = 1000066002,
+	ASTC_6x5_SFLOAT_BLOCK_EXT                      = 1000066003,
+	ASTC_6x6_SFLOAT_BLOCK_EXT                      = 1000066004,
+	ASTC_8x5_SFLOAT_BLOCK_EXT                      = 1000066005,
+	ASTC_8x6_SFLOAT_BLOCK_EXT                      = 1000066006,
+	ASTC_8x8_SFLOAT_BLOCK_EXT                      = 1000066007,
+	ASTC_10x5_SFLOAT_BLOCK_EXT                     = 1000066008,
+	ASTC_10x6_SFLOAT_BLOCK_EXT                     = 1000066009,
+	ASTC_10x8_SFLOAT_BLOCK_EXT                     = 1000066010,
+	ASTC_10x10_SFLOAT_BLOCK_EXT                    = 1000066011,
+	ASTC_12x10_SFLOAT_BLOCK_EXT                    = 1000066012,
+	ASTC_12x12_SFLOAT_BLOCK_EXT                    = 1000066013,
+	G8_B8R8_2PLANE_444_UNORM_EXT                   = 1000330000,
+	G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT  = 1000330001,
+	G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT  = 1000330002,
+	G16_B16R16_2PLANE_444_UNORM_EXT                = 1000330003,
+	A4R4G4B4_UNORM_PACK16_EXT                      = 1000340000,
+	A4B4G4R4_UNORM_PACK16_EXT                      = 1000340001,
+	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,
+}
+
+ImageTiling :: enum c.int {
+	OPTIMAL                 = 0,
+	LINEAR                  = 1,
+	DRM_FORMAT_MODIFIER_EXT = 1000158000,
+}
+
+ImageType :: enum c.int {
+	D1 = 0,
+	D2 = 1,
+	D3 = 2,
+}
+
+PhysicalDeviceType :: enum c.int {
+	OTHER          = 0,
+	INTEGRATED_GPU = 1,
+	DISCRETE_GPU   = 2,
+	VIRTUAL_GPU    = 3,
+	CPU            = 4,
+}
+
+QueryType :: enum c.int {
+	OCCLUSION                                     = 0,
+	PIPELINE_STATISTICS                           = 1,
+	TIMESTAMP                                     = 2,
+	RESULT_STATUS_ONLY_KHR                        = 1000023000,
+	TRANSFORM_FEEDBACK_STREAM_EXT                 = 1000028004,
+	PERFORMANCE_QUERY_KHR                         = 1000116000,
+	ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR     = 1000150000,
+	ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,
+	ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV      = 1000165000,
+	PERFORMANCE_QUERY_INTEL                       = 1000210000,
+	VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR       = 1000299000,
+}
+
+SharingMode :: enum c.int {
+	EXCLUSIVE  = 0,
+	CONCURRENT = 1,
+}
+
+ComponentSwizzle :: enum c.int {
+	IDENTITY = 0,
+	ZERO     = 1,
+	ONE      = 2,
+	R        = 3,
+	G        = 4,
+	B        = 5,
+	A        = 6,
+}
+
+ImageViewType :: enum c.int {
+	D1         = 0,
+	D2         = 1,
+	D3         = 2,
+	CUBE       = 3,
+	D1_ARRAY   = 4,
+	D2_ARRAY   = 5,
+	CUBE_ARRAY = 6,
+}
+
+BlendFactor :: enum c.int {
+	ZERO                     = 0,
+	ONE                      = 1,
+	SRC_COLOR                = 2,
+	ONE_MINUS_SRC_COLOR      = 3,
+	DST_COLOR                = 4,
+	ONE_MINUS_DST_COLOR      = 5,
+	SRC_ALPHA                = 6,
+	ONE_MINUS_SRC_ALPHA      = 7,
+	DST_ALPHA                = 8,
+	ONE_MINUS_DST_ALPHA      = 9,
+	CONSTANT_COLOR           = 10,
+	ONE_MINUS_CONSTANT_COLOR = 11,
+	CONSTANT_ALPHA           = 12,
+	ONE_MINUS_CONSTANT_ALPHA = 13,
+	SRC_ALPHA_SATURATE       = 14,
+	SRC1_COLOR               = 15,
+	ONE_MINUS_SRC1_COLOR     = 16,
+	SRC1_ALPHA               = 17,
+	ONE_MINUS_SRC1_ALPHA     = 18,
+}
+
+BlendOp :: enum c.int {
+	ADD                    = 0,
+	SUBTRACT               = 1,
+	REVERSE_SUBTRACT       = 2,
+	MIN                    = 3,
+	MAX                    = 4,
+	ZERO_EXT               = 1000148000,
+	SRC_EXT                = 1000148001,
+	DST_EXT                = 1000148002,
+	SRC_OVER_EXT           = 1000148003,
+	DST_OVER_EXT           = 1000148004,
+	SRC_IN_EXT             = 1000148005,
+	DST_IN_EXT             = 1000148006,
+	SRC_OUT_EXT            = 1000148007,
+	DST_OUT_EXT            = 1000148008,
+	SRC_ATOP_EXT           = 1000148009,
+	DST_ATOP_EXT           = 1000148010,
+	XOR_EXT                = 1000148011,
+	MULTIPLY_EXT           = 1000148012,
+	SCREEN_EXT             = 1000148013,
+	OVERLAY_EXT            = 1000148014,
+	DARKEN_EXT             = 1000148015,
+	LIGHTEN_EXT            = 1000148016,
+	COLORDODGE_EXT         = 1000148017,
+	COLORBURN_EXT          = 1000148018,
+	HARDLIGHT_EXT          = 1000148019,
+	SOFTLIGHT_EXT          = 1000148020,
+	DIFFERENCE_EXT         = 1000148021,
+	EXCLUSION_EXT          = 1000148022,
+	INVERT_EXT             = 1000148023,
+	INVERT_RGB_EXT         = 1000148024,
+	LINEARDODGE_EXT        = 1000148025,
+	LINEARBURN_EXT         = 1000148026,
+	VIVIDLIGHT_EXT         = 1000148027,
+	LINEARLIGHT_EXT        = 1000148028,
+	PINLIGHT_EXT           = 1000148029,
+	HARDMIX_EXT            = 1000148030,
+	HSL_HUE_EXT            = 1000148031,
+	HSL_SATURATION_EXT     = 1000148032,
+	HSL_COLOR_EXT          = 1000148033,
+	HSL_LUMINOSITY_EXT     = 1000148034,
+	PLUS_EXT               = 1000148035,
+	PLUS_CLAMPED_EXT       = 1000148036,
+	PLUS_CLAMPED_ALPHA_EXT = 1000148037,
+	PLUS_DARKER_EXT        = 1000148038,
+	MINUS_EXT              = 1000148039,
+	MINUS_CLAMPED_EXT      = 1000148040,
+	CONTRAST_EXT           = 1000148041,
+	INVERT_OVG_EXT         = 1000148042,
+	RED_EXT                = 1000148043,
+	GREEN_EXT              = 1000148044,
+	BLUE_EXT               = 1000148045,
+}
+
+CompareOp :: enum c.int {
+	NEVER            = 0,
+	LESS             = 1,
+	EQUAL            = 2,
+	LESS_OR_EQUAL    = 3,
+	GREATER          = 4,
+	NOT_EQUAL        = 5,
+	GREATER_OR_EQUAL = 6,
+	ALWAYS           = 7,
+}
+
+DynamicState :: enum c.int {
+	VIEWPORT                            = 0,
+	SCISSOR                             = 1,
+	LINE_WIDTH                          = 2,
+	DEPTH_BIAS                          = 3,
+	BLEND_CONSTANTS                     = 4,
+	DEPTH_BOUNDS                        = 5,
+	STENCIL_COMPARE_MASK                = 6,
+	STENCIL_WRITE_MASK                  = 7,
+	STENCIL_REFERENCE                   = 8,
+	VIEWPORT_W_SCALING_NV               = 1000087000,
+	DISCARD_RECTANGLE_EXT               = 1000099000,
+	SAMPLE_LOCATIONS_EXT                = 1000143000,
+	RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
+	VIEWPORT_SHADING_RATE_PALETTE_NV    = 1000164004,
+	VIEWPORT_COARSE_SAMPLE_ORDER_NV     = 1000164006,
+	EXCLUSIVE_SCISSOR_NV                = 1000205001,
+	FRAGMENT_SHADING_RATE_KHR           = 1000226000,
+	LINE_STIPPLE_EXT                    = 1000259000,
+	CULL_MODE_EXT                       = 1000267000,
+	FRONT_FACE_EXT                      = 1000267001,
+	PRIMITIVE_TOPOLOGY_EXT              = 1000267002,
+	VIEWPORT_WITH_COUNT_EXT             = 1000267003,
+	SCISSOR_WITH_COUNT_EXT              = 1000267004,
+	VERTEX_INPUT_BINDING_STRIDE_EXT     = 1000267005,
+	DEPTH_TEST_ENABLE_EXT               = 1000267006,
+	DEPTH_WRITE_ENABLE_EXT              = 1000267007,
+	DEPTH_COMPARE_OP_EXT                = 1000267008,
+	DEPTH_BOUNDS_TEST_ENABLE_EXT        = 1000267009,
+	STENCIL_TEST_ENABLE_EXT             = 1000267010,
+	STENCIL_OP_EXT                      = 1000267011,
+	VERTEX_INPUT_EXT                    = 1000352000,
+	PATCH_CONTROL_POINTS_EXT            = 1000377000,
+	RASTERIZER_DISCARD_ENABLE_EXT       = 1000377001,
+	DEPTH_BIAS_ENABLE_EXT               = 1000377002,
+	LOGIC_OP_EXT                        = 1000377003,
+	PRIMITIVE_RESTART_ENABLE_EXT        = 1000377004,
+	COLOR_WRITE_ENABLE_EXT              = 1000381000,
+}
+
+FrontFace :: enum c.int {
+	COUNTER_CLOCKWISE = 0,
+	CLOCKWISE         = 1,
+}
+
+VertexInputRate :: enum c.int {
+	VERTEX   = 0,
+	INSTANCE = 1,
+}
+
+PrimitiveTopology :: enum c.int {
+	POINT_LIST                    = 0,
+	LINE_LIST                     = 1,
+	LINE_STRIP                    = 2,
+	TRIANGLE_LIST                 = 3,
+	TRIANGLE_STRIP                = 4,
+	TRIANGLE_FAN                  = 5,
+	LINE_LIST_WITH_ADJACENCY      = 6,
+	LINE_STRIP_WITH_ADJACENCY     = 7,
+	TRIANGLE_LIST_WITH_ADJACENCY  = 8,
+	TRIANGLE_STRIP_WITH_ADJACENCY = 9,
+	PATCH_LIST                    = 10,
+}
+
+PolygonMode :: enum c.int {
+	FILL              = 0,
+	LINE              = 1,
+	POINT             = 2,
+	FILL_RECTANGLE_NV = 1000153000,
+}
+
+StencilOp :: enum c.int {
+	KEEP                = 0,
+	ZERO                = 1,
+	REPLACE             = 2,
+	INCREMENT_AND_CLAMP = 3,
+	DECREMENT_AND_CLAMP = 4,
+	INVERT              = 5,
+	INCREMENT_AND_WRAP  = 6,
+	DECREMENT_AND_WRAP  = 7,
+}
+
+LogicOp :: enum c.int {
+	CLEAR         = 0,
+	AND           = 1,
+	AND_REVERSE   = 2,
+	COPY          = 3,
+	AND_INVERTED  = 4,
+	NO_OP         = 5,
+	XOR           = 6,
+	OR            = 7,
+	NOR           = 8,
+	EQUIVALENT    = 9,
+	INVERT        = 10,
+	OR_REVERSE    = 11,
+	COPY_INVERTED = 12,
+	OR_INVERTED   = 13,
+	NAND          = 14,
+	SET           = 15,
+}
+
+BorderColor :: enum c.int {
+	FLOAT_TRANSPARENT_BLACK = 0,
+	INT_TRANSPARENT_BLACK   = 1,
+	FLOAT_OPAQUE_BLACK      = 2,
+	INT_OPAQUE_BLACK        = 3,
+	FLOAT_OPAQUE_WHITE      = 4,
+	INT_OPAQUE_WHITE        = 5,
+	FLOAT_CUSTOM_EXT        = 1000287003,
+	INT_CUSTOM_EXT          = 1000287004,
+}
+
+Filter :: enum c.int {
+	NEAREST   = 0,
+	LINEAR    = 1,
+	CUBIC_IMG = 1000015000,
+	CUBIC_EXT = CUBIC_IMG,
+}
+
+SamplerAddressMode :: enum c.int {
+	REPEAT                   = 0,
+	MIRRORED_REPEAT          = 1,
+	CLAMP_TO_EDGE            = 2,
+	CLAMP_TO_BORDER          = 3,
+	MIRROR_CLAMP_TO_EDGE     = 4,
+	MIRROR_CLAMP_TO_EDGE_KHR = MIRROR_CLAMP_TO_EDGE,
+}
+
+SamplerMipmapMode :: enum c.int {
+	NEAREST = 0,
+	LINEAR  = 1,
+}
+
+DescriptorType :: enum c.int {
+	SAMPLER                    = 0,
+	COMBINED_IMAGE_SAMPLER     = 1,
+	SAMPLED_IMAGE              = 2,
+	STORAGE_IMAGE              = 3,
+	UNIFORM_TEXEL_BUFFER       = 4,
+	STORAGE_TEXEL_BUFFER       = 5,
+	UNIFORM_BUFFER             = 6,
+	STORAGE_BUFFER             = 7,
+	UNIFORM_BUFFER_DYNAMIC     = 8,
+	STORAGE_BUFFER_DYNAMIC     = 9,
+	INPUT_ATTACHMENT           = 10,
+	INLINE_UNIFORM_BLOCK_EXT   = 1000138000,
+	ACCELERATION_STRUCTURE_KHR = 1000150000,
+	ACCELERATION_STRUCTURE_NV  = 1000165000,
+	MUTABLE_VALVE              = 1000351000,
+}
+
+AttachmentLoadOp :: enum c.int {
+	LOAD      = 0,
+	CLEAR     = 1,
+	DONT_CARE = 2,
+	NONE_EXT  = 1000400000,
+}
+
+AttachmentStoreOp :: enum c.int {
+	STORE     = 0,
+	DONT_CARE = 1,
+	NONE_EXT  = 1000301000,
+	NONE_QCOM = NONE_EXT,
+}
+
+PipelineBindPoint :: enum c.int {
+	GRAPHICS               = 0,
+	COMPUTE                = 1,
+	RAY_TRACING_KHR        = 1000165000,
+	SUBPASS_SHADING_HUAWEI = 1000369003,
+	RAY_TRACING_NV         = RAY_TRACING_KHR,
+}
+
+CommandBufferLevel :: enum c.int {
+	PRIMARY   = 0,
+	SECONDARY = 1,
+}
+
+IndexType :: enum c.int {
+	UINT16    = 0,
+	UINT32    = 1,
+	NONE_KHR  = 1000165000,
+	UINT8_EXT = 1000265000,
+	NONE_NV   = NONE_KHR,
+}
+
+SubpassContents :: enum c.int {
+	INLINE                    = 0,
+	SECONDARY_COMMAND_BUFFERS = 1,
+}
+
+AccessFlags :: distinct bit_set[AccessFlag; Flags];
+AccessFlag :: enum Flags {
+	INDIRECT_COMMAND_READ                     = 0,
+	INDEX_READ                                = 1,
+	VERTEX_ATTRIBUTE_READ                     = 2,
+	UNIFORM_READ                              = 3,
+	INPUT_ATTACHMENT_READ                     = 4,
+	SHADER_READ                               = 5,
+	SHADER_WRITE                              = 6,
+	COLOR_ATTACHMENT_READ                     = 7,
+	COLOR_ATTACHMENT_WRITE                    = 8,
+	DEPTH_STENCIL_ATTACHMENT_READ             = 9,
+	DEPTH_STENCIL_ATTACHMENT_WRITE            = 10,
+	TRANSFER_READ                             = 11,
+	TRANSFER_WRITE                            = 12,
+	HOST_READ                                 = 13,
+	HOST_WRITE                                = 14,
+	MEMORY_READ                               = 15,
+	MEMORY_WRITE                              = 16,
+	TRANSFORM_FEEDBACK_WRITE_EXT              = 25,
+	TRANSFORM_FEEDBACK_COUNTER_READ_EXT       = 26,
+	TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT      = 27,
+	CONDITIONAL_RENDERING_READ_EXT            = 20,
+	COLOR_ATTACHMENT_READ_NONCOHERENT_EXT     = 19,
+	ACCELERATION_STRUCTURE_READ_KHR           = 21,
+	ACCELERATION_STRUCTURE_WRITE_KHR          = 22,
+	FRAGMENT_DENSITY_MAP_READ_EXT             = 24,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR = 23,
+	COMMAND_PREPROCESS_READ_NV                = 17,
+	COMMAND_PREPROCESS_WRITE_NV               = 18,
+	SHADING_RATE_IMAGE_READ_NV                = FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR,
+	ACCELERATION_STRUCTURE_READ_NV            = ACCELERATION_STRUCTURE_READ_KHR,
+	ACCELERATION_STRUCTURE_WRITE_NV           = ACCELERATION_STRUCTURE_WRITE_KHR,
+}
+
+AccessFlags_NONE_KHR :: AccessFlags{};
+
+
+ImageAspectFlags :: distinct bit_set[ImageAspectFlag; Flags];
+ImageAspectFlag :: enum Flags {
+	COLOR              = 0,
+	DEPTH              = 1,
+	STENCIL            = 2,
+	METADATA           = 3,
+	PLANE_0            = 4,
+	PLANE_1            = 5,
+	PLANE_2            = 6,
+	MEMORY_PLANE_0_EXT = 7,
+	MEMORY_PLANE_1_EXT = 8,
+	MEMORY_PLANE_2_EXT = 9,
+	MEMORY_PLANE_3_EXT = 10,
+	PLANE_0_KHR        = PLANE_0,
+	PLANE_1_KHR        = PLANE_1,
+	PLANE_2_KHR        = PLANE_2,
+}
+
+FormatFeatureFlags :: distinct bit_set[FormatFeatureFlag; Flags];
+FormatFeatureFlag :: enum Flags {
+	SAMPLED_IMAGE                                                               = 0,
+	STORAGE_IMAGE                                                               = 1,
+	STORAGE_IMAGE_ATOMIC                                                        = 2,
+	UNIFORM_TEXEL_BUFFER                                                        = 3,
+	STORAGE_TEXEL_BUFFER                                                        = 4,
+	STORAGE_TEXEL_BUFFER_ATOMIC                                                 = 5,
+	VERTEX_BUFFER                                                               = 6,
+	COLOR_ATTACHMENT                                                            = 7,
+	COLOR_ATTACHMENT_BLEND                                                      = 8,
+	DEPTH_STENCIL_ATTACHMENT                                                    = 9,
+	BLIT_SRC                                                                    = 10,
+	BLIT_DST                                                                    = 11,
+	SAMPLED_IMAGE_FILTER_LINEAR                                                 = 12,
+	TRANSFER_SRC                                                                = 14,
+	TRANSFER_DST                                                                = 15,
+	MIDPOINT_CHROMA_SAMPLES                                                     = 17,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER                                = 18,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER               = 19,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT               = 20,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE     = 21,
+	DISJOINT                                                                    = 22,
+	COSITED_CHROMA_SAMPLES                                                      = 23,
+	SAMPLED_IMAGE_FILTER_MINMAX                                                 = 16,
+	SAMPLED_IMAGE_FILTER_CUBIC_IMG                                              = 13,
+	VIDEO_DECODE_OUTPUT_KHR                                                     = 25,
+	VIDEO_DECODE_DPB_KHR                                                        = 26,
+	ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR                                    = 29,
+	FRAGMENT_DENSITY_MAP_EXT                                                    = 24,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR                                        = 30,
+	VIDEO_ENCODE_INPUT_KHR                                                      = 27,
+	VIDEO_ENCODE_DPB_KHR                                                        = 28,
+	TRANSFER_SRC_KHR                                                            = TRANSFER_SRC,
+	TRANSFER_DST_KHR                                                            = TRANSFER_DST,
+	SAMPLED_IMAGE_FILTER_MINMAX_EXT                                             = SAMPLED_IMAGE_FILTER_MINMAX,
+	MIDPOINT_CHROMA_SAMPLES_KHR                                                 = MIDPOINT_CHROMA_SAMPLES,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR                            = SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR           = SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR           = SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT,
+	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR = SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE,
+	DISJOINT_KHR                                                                = DISJOINT,
+	COSITED_CHROMA_SAMPLES_KHR                                                  = COSITED_CHROMA_SAMPLES,
+	SAMPLED_IMAGE_FILTER_CUBIC_EXT                                              = SAMPLED_IMAGE_FILTER_CUBIC_IMG,
+}
+
+ImageCreateFlags :: distinct bit_set[ImageCreateFlag; Flags];
+ImageCreateFlag :: enum Flags {
+	SPARSE_BINDING                        = 0,
+	SPARSE_RESIDENCY                      = 1,
+	SPARSE_ALIASED                        = 2,
+	MUTABLE_FORMAT                        = 3,
+	CUBE_COMPATIBLE                       = 4,
+	ALIAS                                 = 10,
+	SPLIT_INSTANCE_BIND_REGIONS           = 6,
+	D2_ARRAY_COMPATIBLE                   = 5,
+	BLOCK_TEXEL_VIEW_COMPATIBLE           = 7,
+	EXTENDED_USAGE                        = 8,
+	PROTECTED                             = 11,
+	DISJOINT                              = 9,
+	CORNER_SAMPLED_NV                     = 13,
+	SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT = 12,
+	SUBSAMPLED_EXT                        = 14,
+	SPLIT_INSTANCE_BIND_REGIONS_KHR       = SPLIT_INSTANCE_BIND_REGIONS,
+	D2_ARRAY_COMPATIBLE_KHR               = D2_ARRAY_COMPATIBLE,
+	BLOCK_TEXEL_VIEW_COMPATIBLE_KHR       = BLOCK_TEXEL_VIEW_COMPATIBLE,
+	EXTENDED_USAGE_KHR                    = EXTENDED_USAGE,
+	DISJOINT_KHR                          = DISJOINT,
+	ALIAS_KHR                             = ALIAS,
+}
+
+SampleCountFlags :: distinct bit_set[SampleCountFlag; Flags];
+SampleCountFlag :: enum Flags {
+	_1  = 0,
+	_2  = 1,
+	_4  = 2,
+	_8  = 3,
+	_16 = 4,
+	_32 = 5,
+	_64 = 6,
+}
+
+ImageUsageFlags :: distinct bit_set[ImageUsageFlag; Flags];
+ImageUsageFlag :: enum Flags {
+	TRANSFER_SRC                         = 0,
+	TRANSFER_DST                         = 1,
+	SAMPLED                              = 2,
+	STORAGE                              = 3,
+	COLOR_ATTACHMENT                     = 4,
+	DEPTH_STENCIL_ATTACHMENT             = 5,
+	TRANSIENT_ATTACHMENT                 = 6,
+	INPUT_ATTACHMENT                     = 7,
+	VIDEO_DECODE_DST_KHR                 = 10,
+	VIDEO_DECODE_SRC_KHR                 = 11,
+	VIDEO_DECODE_DPB_KHR                 = 12,
+	FRAGMENT_DENSITY_MAP_EXT             = 9,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = 8,
+	VIDEO_ENCODE_DST_KHR                 = 13,
+	VIDEO_ENCODE_SRC_KHR                 = 14,
+	VIDEO_ENCODE_DPB_KHR                 = 15,
+	INVOCATION_MASK_HUAWEI               = 18,
+	SHADING_RATE_IMAGE_NV                = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR,
+}
+
+MemoryHeapFlags :: distinct bit_set[MemoryHeapFlag; Flags];
+MemoryHeapFlag :: enum Flags {
+	DEVICE_LOCAL       = 0,
+	MULTI_INSTANCE     = 1,
+	MULTI_INSTANCE_KHR = MULTI_INSTANCE,
+}
+
+MemoryPropertyFlags :: distinct bit_set[MemoryPropertyFlag; Flags];
+MemoryPropertyFlag :: enum Flags {
+	DEVICE_LOCAL        = 0,
+	HOST_VISIBLE        = 1,
+	HOST_COHERENT       = 2,
+	HOST_CACHED         = 3,
+	LAZILY_ALLOCATED    = 4,
+	PROTECTED           = 5,
+	DEVICE_COHERENT_AMD = 6,
+	DEVICE_UNCACHED_AMD = 7,
+	RDMA_CAPABLE_NV     = 8,
+}
+
+QueueFlags :: distinct bit_set[QueueFlag; Flags];
+QueueFlag :: enum Flags {
+	GRAPHICS         = 0,
+	COMPUTE          = 1,
+	TRANSFER         = 2,
+	SPARSE_BINDING   = 3,
+	PROTECTED        = 4,
+	VIDEO_DECODE_KHR = 5,
+	VIDEO_ENCODE_KHR = 6,
+}
+
+DeviceQueueCreateFlags :: distinct bit_set[DeviceQueueCreateFlag; Flags];
+DeviceQueueCreateFlag :: enum Flags {
+	PROTECTED = 0,
+}
+
+PipelineStageFlags :: distinct bit_set[PipelineStageFlag; Flags];
+PipelineStageFlag :: enum Flags {
+	TOP_OF_PIPE                          = 0,
+	DRAW_INDIRECT                        = 1,
+	VERTEX_INPUT                         = 2,
+	VERTEX_SHADER                        = 3,
+	TESSELLATION_CONTROL_SHADER          = 4,
+	TESSELLATION_EVALUATION_SHADER       = 5,
+	GEOMETRY_SHADER                      = 6,
+	FRAGMENT_SHADER                      = 7,
+	EARLY_FRAGMENT_TESTS                 = 8,
+	LATE_FRAGMENT_TESTS                  = 9,
+	COLOR_ATTACHMENT_OUTPUT              = 10,
+	COMPUTE_SHADER                       = 11,
+	TRANSFER                             = 12,
+	BOTTOM_OF_PIPE                       = 13,
+	HOST                                 = 14,
+	ALL_GRAPHICS                         = 15,
+	ALL_COMMANDS                         = 16,
+	TRANSFORM_FEEDBACK_EXT               = 24,
+	CONDITIONAL_RENDERING_EXT            = 18,
+	ACCELERATION_STRUCTURE_BUILD_KHR     = 25,
+	RAY_TRACING_SHADER_KHR               = 21,
+	TASK_SHADER_NV                       = 19,
+	MESH_SHADER_NV                       = 20,
+	FRAGMENT_DENSITY_PROCESS_EXT         = 23,
+	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = 22,
+	COMMAND_PREPROCESS_NV                = 17,
+	SHADING_RATE_IMAGE_NV                = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR,
+	RAY_TRACING_SHADER_NV                = RAY_TRACING_SHADER_KHR,
+	ACCELERATION_STRUCTURE_BUILD_NV      = ACCELERATION_STRUCTURE_BUILD_KHR,
+}
+
+PipelineStageFlags_NONE_KHR :: PipelineStageFlags{};
+
+
+SparseMemoryBindFlags :: distinct bit_set[SparseMemoryBindFlag; Flags];
+SparseMemoryBindFlag :: enum Flags {
+	METADATA = 0,
+}
+
+SparseImageFormatFlags :: distinct bit_set[SparseImageFormatFlag; Flags];
+SparseImageFormatFlag :: enum Flags {
+	SINGLE_MIPTAIL         = 0,
+	ALIGNED_MIP_SIZE       = 1,
+	NONSTANDARD_BLOCK_SIZE = 2,
+}
+
+FenceCreateFlags :: distinct bit_set[FenceCreateFlag; Flags];
+FenceCreateFlag :: enum Flags {
+	SIGNALED = 0,
+}
+
+EventCreateFlags :: distinct bit_set[EventCreateFlag; Flags];
+EventCreateFlag :: enum Flags {
+	DEVICE_ONLY_KHR = 0,
+}
+
+QueryPipelineStatisticFlags :: distinct bit_set[QueryPipelineStatisticFlag; Flags];
+QueryPipelineStatisticFlag :: enum Flags {
+	INPUT_ASSEMBLY_VERTICES                    = 0,
+	INPUT_ASSEMBLY_PRIMITIVES                  = 1,
+	VERTEX_SHADER_INVOCATIONS                  = 2,
+	GEOMETRY_SHADER_INVOCATIONS                = 3,
+	GEOMETRY_SHADER_PRIMITIVES                 = 4,
+	CLIPPING_INVOCATIONS                       = 5,
+	CLIPPING_PRIMITIVES                        = 6,
+	FRAGMENT_SHADER_INVOCATIONS                = 7,
+	TESSELLATION_CONTROL_SHADER_PATCHES        = 8,
+	TESSELLATION_EVALUATION_SHADER_INVOCATIONS = 9,
+	COMPUTE_SHADER_INVOCATIONS                 = 10,
+}
+
+QueryResultFlags :: distinct bit_set[QueryResultFlag; Flags];
+QueryResultFlag :: enum Flags {
+	_64               = 0,
+	WAIT              = 1,
+	WITH_AVAILABILITY = 2,
+	PARTIAL           = 3,
+	WITH_STATUS_KHR   = 4,
+}
+
+BufferCreateFlags :: distinct bit_set[BufferCreateFlag; Flags];
+BufferCreateFlag :: enum Flags {
+	SPARSE_BINDING                    = 0,
+	SPARSE_RESIDENCY                  = 1,
+	SPARSE_ALIASED                    = 2,
+	PROTECTED                         = 3,
+	DEVICE_ADDRESS_CAPTURE_REPLAY     = 4,
+	DEVICE_ADDRESS_CAPTURE_REPLAY_EXT = DEVICE_ADDRESS_CAPTURE_REPLAY,
+	DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY,
+}
+
+BufferUsageFlags :: distinct bit_set[BufferUsageFlag; Flags];
+BufferUsageFlag :: enum Flags {
+	TRANSFER_SRC                                     = 0,
+	TRANSFER_DST                                     = 1,
+	UNIFORM_TEXEL_BUFFER                             = 2,
+	STORAGE_TEXEL_BUFFER                             = 3,
+	UNIFORM_BUFFER                                   = 4,
+	STORAGE_BUFFER                                   = 5,
+	INDEX_BUFFER                                     = 6,
+	VERTEX_BUFFER                                    = 7,
+	INDIRECT_BUFFER                                  = 8,
+	SHADER_DEVICE_ADDRESS                            = 17,
+	VIDEO_DECODE_SRC_KHR                             = 13,
+	VIDEO_DECODE_DST_KHR                             = 14,
+	TRANSFORM_FEEDBACK_BUFFER_EXT                    = 11,
+	TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT            = 12,
+	CONDITIONAL_RENDERING_EXT                        = 9,
+	ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR = 19,
+	ACCELERATION_STRUCTURE_STORAGE_KHR               = 20,
+	SHADER_BINDING_TABLE_KHR                         = 10,
+	VIDEO_ENCODE_DST_KHR                             = 15,
+	VIDEO_ENCODE_SRC_KHR                             = 16,
+	RAY_TRACING_NV                                   = SHADER_BINDING_TABLE_KHR,
+	SHADER_DEVICE_ADDRESS_EXT                        = SHADER_DEVICE_ADDRESS,
+	SHADER_DEVICE_ADDRESS_KHR                        = SHADER_DEVICE_ADDRESS,
+}
+
+ImageViewCreateFlags :: distinct bit_set[ImageViewCreateFlag; Flags];
+ImageViewCreateFlag :: enum Flags {
+	FRAGMENT_DENSITY_MAP_DYNAMIC_EXT  = 0,
+	FRAGMENT_DENSITY_MAP_DEFERRED_EXT = 1,
+}
+
+ShaderModuleCreateFlags :: distinct bit_set[ShaderModuleCreateFlag; Flags];
+ShaderModuleCreateFlag :: enum Flags {
+}
+
+PipelineCacheCreateFlags :: distinct bit_set[PipelineCacheCreateFlag; Flags];
+PipelineCacheCreateFlag :: enum Flags {
+	EXTERNALLY_SYNCHRONIZED_EXT = 0,
+}
+
+ColorComponentFlags :: distinct bit_set[ColorComponentFlag; Flags];
+ColorComponentFlag :: enum Flags {
+	R = 0,
+	G = 1,
+	B = 2,
+	A = 3,
+}
+
+PipelineCreateFlags :: distinct bit_set[PipelineCreateFlag; Flags];
+PipelineCreateFlag :: enum Flags {
+	DISABLE_OPTIMIZATION                               = 0,
+	ALLOW_DERIVATIVES                                  = 1,
+	DERIVATIVE                                         = 2,
+	VIEW_INDEX_FROM_DEVICE_INDEX                       = 3,
+	DISPATCH_BASE                                      = 4,
+	RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR            = 14,
+	RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR        = 15,
+	RAY_TRACING_NO_NULL_MISS_SHADERS_KHR               = 16,
+	RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR       = 17,
+	RAY_TRACING_SKIP_TRIANGLES_KHR                     = 12,
+	RAY_TRACING_SKIP_AABBS_KHR                         = 13,
+	RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR = 19,
+	DEFER_COMPILE_NV                                   = 5,
+	CAPTURE_STATISTICS_KHR                             = 6,
+	CAPTURE_INTERNAL_REPRESENTATIONS_KHR               = 7,
+	INDIRECT_BINDABLE_NV                               = 18,
+	LIBRARY_KHR                                        = 11,
+	FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT              = 8,
+	EARLY_RETURN_ON_FAILURE_EXT                        = 9,
+	RAY_TRACING_ALLOW_MOTION_NV                        = 20,
+	VIEW_INDEX_FROM_DEVICE_INDEX_KHR                   = VIEW_INDEX_FROM_DEVICE_INDEX,
+	DISPATCH_BASE_KHR                                  = DISPATCH_BASE,
+}
+
+PipelineShaderStageCreateFlags :: distinct bit_set[PipelineShaderStageCreateFlag; Flags];
+PipelineShaderStageCreateFlag :: enum Flags {
+	ALLOW_VARYING_SUBGROUP_SIZE_EXT = 0,
+	REQUIRE_FULL_SUBGROUPS_EXT      = 1,
+}
+
+ShaderStageFlags :: distinct bit_set[ShaderStageFlag; Flags];
+ShaderStageFlag :: enum Flags {
+	VERTEX                  = 0,
+	TESSELLATION_CONTROL    = 1,
+	TESSELLATION_EVALUATION = 2,
+	GEOMETRY                = 3,
+	FRAGMENT                = 4,
+	COMPUTE                 = 5,
+	RAYGEN_KHR              = 8,
+	ANY_HIT_KHR             = 9,
+	CLOSEST_HIT_KHR         = 10,
+	MISS_KHR                = 11,
+	INTERSECTION_KHR        = 12,
+	CALLABLE_KHR            = 13,
+	TASK_NV                 = 6,
+	MESH_NV                 = 7,
+	SUBPASS_SHADING_HUAWEI  = 14,
+	RAYGEN_NV               = RAYGEN_KHR,
+	ANY_HIT_NV              = ANY_HIT_KHR,
+	CLOSEST_HIT_NV          = CLOSEST_HIT_KHR,
+	MISS_NV                 = MISS_KHR,
+	INTERSECTION_NV         = INTERSECTION_KHR,
+	CALLABLE_NV             = CALLABLE_KHR,
+	_MAX                    = 31, // Needed for the *_ALL bit set
+}
+
+ShaderStageFlags_ALL_GRAPHICS :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT};
+ShaderStageFlags_ALL :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT, .COMPUTE, .TASK_NV, .MESH_NV, .RAYGEN_KHR, .ANY_HIT_KHR, .CLOSEST_HIT_KHR, .MISS_KHR, .INTERSECTION_KHR, .CALLABLE_KHR, .SUBPASS_SHADING_HUAWEI, ShaderStageFlag(15), ShaderStageFlag(16), ShaderStageFlag(17), ShaderStageFlag(18), ShaderStageFlag(19), ShaderStageFlag(20), ShaderStageFlag(21), ShaderStageFlag(22), ShaderStageFlag(23), ShaderStageFlag(24), ShaderStageFlag(25), ShaderStageFlag(26), ShaderStageFlag(27), ShaderStageFlag(28), ShaderStageFlag(29), ShaderStageFlag(30)};
+
+
+CullModeFlags :: distinct bit_set[CullModeFlag; Flags];
+CullModeFlag :: enum Flags {
+	FRONT = 0,
+	BACK  = 1,
+}
+
+CullModeFlags_NONE :: CullModeFlags{};
+CullModeFlags_FRONT_AND_BACK :: CullModeFlags{.FRONT, .BACK};
+
+
+SamplerCreateFlags :: distinct bit_set[SamplerCreateFlag; Flags];
+SamplerCreateFlag :: enum Flags {
+	SUBSAMPLED_EXT                       = 0,
+	SUBSAMPLED_COARSE_RECONSTRUCTION_EXT = 1,
+}
+
+DescriptorPoolCreateFlags :: distinct bit_set[DescriptorPoolCreateFlag; Flags];
+DescriptorPoolCreateFlag :: enum Flags {
+	FREE_DESCRIPTOR_SET   = 0,
+	UPDATE_AFTER_BIND     = 1,
+	HOST_ONLY_VALVE       = 2,
+	UPDATE_AFTER_BIND_EXT = UPDATE_AFTER_BIND,
+}
+
+DescriptorSetLayoutCreateFlags :: distinct bit_set[DescriptorSetLayoutCreateFlag; Flags];
+DescriptorSetLayoutCreateFlag :: enum Flags {
+	UPDATE_AFTER_BIND_POOL     = 1,
+	PUSH_DESCRIPTOR_KHR        = 0,
+	HOST_ONLY_POOL_VALVE       = 2,
+	UPDATE_AFTER_BIND_POOL_EXT = UPDATE_AFTER_BIND_POOL,
+}
+
+AttachmentDescriptionFlags :: distinct bit_set[AttachmentDescriptionFlag; Flags];
+AttachmentDescriptionFlag :: enum Flags {
+	MAY_ALIAS = 0,
+}
+
+DependencyFlags :: distinct bit_set[DependencyFlag; Flags];
+DependencyFlag :: enum Flags {
+	BY_REGION        = 0,
+	DEVICE_GROUP     = 2,
+	VIEW_LOCAL       = 1,
+	VIEW_LOCAL_KHR   = VIEW_LOCAL,
+	DEVICE_GROUP_KHR = DEVICE_GROUP,
+}
+
+FramebufferCreateFlags :: distinct bit_set[FramebufferCreateFlag; Flags];
+FramebufferCreateFlag :: enum Flags {
+	IMAGELESS     = 0,
+	IMAGELESS_KHR = IMAGELESS,
+}
+
+RenderPassCreateFlags :: distinct bit_set[RenderPassCreateFlag; Flags];
+RenderPassCreateFlag :: enum Flags {
+	TRANSFORM_QCOM = 1,
+}
+
+SubpassDescriptionFlags :: distinct bit_set[SubpassDescriptionFlag; Flags];
+SubpassDescriptionFlag :: enum Flags {
+	PER_VIEW_ATTRIBUTES_NVX      = 0,
+	PER_VIEW_POSITION_X_ONLY_NVX = 1,
+	FRAGMENT_REGION_QCOM         = 2,
+	SHADER_RESOLVE_QCOM          = 3,
+}
+
+CommandPoolCreateFlags :: distinct bit_set[CommandPoolCreateFlag; Flags];
+CommandPoolCreateFlag :: enum Flags {
+	TRANSIENT            = 0,
+	RESET_COMMAND_BUFFER = 1,
+	PROTECTED            = 2,
+}
+
+CommandPoolResetFlags :: distinct bit_set[CommandPoolResetFlag; Flags];
+CommandPoolResetFlag :: enum Flags {
+	RELEASE_RESOURCES = 0,
+}
+
+CommandBufferUsageFlags :: distinct bit_set[CommandBufferUsageFlag; Flags];
+CommandBufferUsageFlag :: enum Flags {
+	ONE_TIME_SUBMIT      = 0,
+	RENDER_PASS_CONTINUE = 1,
+	SIMULTANEOUS_USE     = 2,
+}
+
+QueryControlFlags :: distinct bit_set[QueryControlFlag; Flags];
+QueryControlFlag :: enum Flags {
+	PRECISE = 0,
+}
+
+CommandBufferResetFlags :: distinct bit_set[CommandBufferResetFlag; Flags];
+CommandBufferResetFlag :: enum Flags {
+	RELEASE_RESOURCES = 0,
+}
+
+StencilFaceFlags :: distinct bit_set[StencilFaceFlag; Flags];
+StencilFaceFlag :: enum Flags {
+	FRONT                  = 0,
+	BACK                   = 1,
+}
+
+StencilFaceFlags_FRONT_AND_BACK :: StencilFaceFlags{.FRONT, .BACK};
+
+
+PointClippingBehavior :: enum c.int {
+	ALL_CLIP_PLANES           = 0,
+	USER_CLIP_PLANES_ONLY     = 1,
+	ALL_CLIP_PLANES_KHR       = ALL_CLIP_PLANES,
+	USER_CLIP_PLANES_ONLY_KHR = USER_CLIP_PLANES_ONLY,
+}
+
+TessellationDomainOrigin :: enum c.int {
+	UPPER_LEFT     = 0,
+	LOWER_LEFT     = 1,
+	UPPER_LEFT_KHR = UPPER_LEFT,
+	LOWER_LEFT_KHR = LOWER_LEFT,
+}
+
+SamplerYcbcrModelConversion :: enum c.int {
+	RGB_IDENTITY       = 0,
+	YCBCR_IDENTITY     = 1,
+	YCBCR_709          = 2,
+	YCBCR_601          = 3,
+	YCBCR_2020         = 4,
+	RGB_IDENTITY_KHR   = RGB_IDENTITY,
+	YCBCR_IDENTITY_KHR = YCBCR_IDENTITY,
+	YCBCR_709_KHR      = YCBCR_709,
+	YCBCR_601_KHR      = YCBCR_601,
+	YCBCR_2020_KHR     = YCBCR_2020,
+}
+
+SamplerYcbcrRange :: enum c.int {
+	ITU_FULL       = 0,
+	ITU_NARROW     = 1,
+	ITU_FULL_KHR   = ITU_FULL,
+	ITU_NARROW_KHR = ITU_NARROW,
+}
+
+ChromaLocation :: enum c.int {
+	COSITED_EVEN     = 0,
+	MIDPOINT         = 1,
+	COSITED_EVEN_KHR = COSITED_EVEN,
+	MIDPOINT_KHR     = MIDPOINT,
+}
+
+DescriptorUpdateTemplateType :: enum c.int {
+	DESCRIPTOR_SET       = 0,
+	PUSH_DESCRIPTORS_KHR = 1,
+	DESCRIPTOR_SET_KHR   = DESCRIPTOR_SET,
+}
+
+SubgroupFeatureFlags :: distinct bit_set[SubgroupFeatureFlag; Flags];
+SubgroupFeatureFlag :: enum Flags {
+	BASIC            = 0,
+	VOTE             = 1,
+	ARITHMETIC       = 2,
+	BALLOT           = 3,
+	SHUFFLE          = 4,
+	SHUFFLE_RELATIVE = 5,
+	CLUSTERED        = 6,
+	QUAD             = 7,
+	PARTITIONED_NV   = 8,
+}
+
+PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags];
+PeerMemoryFeatureFlag :: enum Flags {
+	COPY_SRC        = 0,
+	COPY_DST        = 1,
+	GENERIC_SRC     = 2,
+	GENERIC_DST     = 3,
+	COPY_SRC_KHR    = COPY_SRC,
+	COPY_DST_KHR    = COPY_DST,
+	GENERIC_SRC_KHR = GENERIC_SRC,
+	GENERIC_DST_KHR = GENERIC_DST,
+}
+
+MemoryAllocateFlags :: distinct bit_set[MemoryAllocateFlag; Flags];
+MemoryAllocateFlag :: enum Flags {
+	DEVICE_MASK                       = 0,
+	DEVICE_ADDRESS                    = 1,
+	DEVICE_ADDRESS_CAPTURE_REPLAY     = 2,
+	DEVICE_MASK_KHR                   = DEVICE_MASK,
+	DEVICE_ADDRESS_KHR                = DEVICE_ADDRESS,
+	DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY,
+}
+
+ExternalMemoryHandleTypeFlags :: distinct bit_set[ExternalMemoryHandleTypeFlag; Flags];
+ExternalMemoryHandleTypeFlag :: enum Flags {
+	OPAQUE_FD                       = 0,
+	OPAQUE_WIN32                    = 1,
+	OPAQUE_WIN32_KMT                = 2,
+	D3D11_TEXTURE                   = 3,
+	D3D11_TEXTURE_KMT               = 4,
+	D3D12_HEAP                      = 5,
+	D3D12_RESOURCE                  = 6,
+	DMA_BUF_EXT                     = 9,
+	ANDROID_HARDWARE_BUFFER_ANDROID = 10,
+	HOST_ALLOCATION_EXT             = 7,
+	HOST_MAPPED_FOREIGN_MEMORY_EXT  = 8,
+	ZIRCON_VMO_FUCHSIA              = 11,
+	RDMA_ADDRESS_NV                 = 12,
+	OPAQUE_FD_KHR                   = OPAQUE_FD,
+	OPAQUE_WIN32_KHR                = OPAQUE_WIN32,
+	OPAQUE_WIN32_KMT_KHR            = OPAQUE_WIN32_KMT,
+	D3D11_TEXTURE_KHR               = D3D11_TEXTURE,
+	D3D11_TEXTURE_KMT_KHR           = D3D11_TEXTURE_KMT,
+	D3D12_HEAP_KHR                  = D3D12_HEAP,
+	D3D12_RESOURCE_KHR              = D3D12_RESOURCE,
+}
+
+ExternalMemoryFeatureFlags :: distinct bit_set[ExternalMemoryFeatureFlag; Flags];
+ExternalMemoryFeatureFlag :: enum Flags {
+	DEDICATED_ONLY     = 0,
+	EXPORTABLE         = 1,
+	IMPORTABLE         = 2,
+	DEDICATED_ONLY_KHR = DEDICATED_ONLY,
+	EXPORTABLE_KHR     = EXPORTABLE,
+	IMPORTABLE_KHR     = IMPORTABLE,
+}
+
+ExternalFenceHandleTypeFlags :: distinct bit_set[ExternalFenceHandleTypeFlag; Flags];
+ExternalFenceHandleTypeFlag :: enum Flags {
+	OPAQUE_FD            = 0,
+	OPAQUE_WIN32         = 1,
+	OPAQUE_WIN32_KMT     = 2,
+	SYNC_FD              = 3,
+	OPAQUE_FD_KHR        = OPAQUE_FD,
+	OPAQUE_WIN32_KHR     = OPAQUE_WIN32,
+	OPAQUE_WIN32_KMT_KHR = OPAQUE_WIN32_KMT,
+	SYNC_FD_KHR          = SYNC_FD,
+}
+
+ExternalFenceFeatureFlags :: distinct bit_set[ExternalFenceFeatureFlag; Flags];
+ExternalFenceFeatureFlag :: enum Flags {
+	EXPORTABLE     = 0,
+	IMPORTABLE     = 1,
+	EXPORTABLE_KHR = EXPORTABLE,
+	IMPORTABLE_KHR = IMPORTABLE,
+}
+
+FenceImportFlags :: distinct bit_set[FenceImportFlag; Flags];
+FenceImportFlag :: enum Flags {
+	TEMPORARY     = 0,
+	TEMPORARY_KHR = TEMPORARY,
+}
+
+SemaphoreImportFlags :: distinct bit_set[SemaphoreImportFlag; Flags];
+SemaphoreImportFlag :: enum Flags {
+	TEMPORARY     = 0,
+	TEMPORARY_KHR = TEMPORARY,
+}
+
+ExternalSemaphoreHandleTypeFlags :: distinct bit_set[ExternalSemaphoreHandleTypeFlag; Flags];
+ExternalSemaphoreHandleTypeFlag :: enum Flags {
+	OPAQUE_FD            = 0,
+	OPAQUE_WIN32         = 1,
+	OPAQUE_WIN32_KMT     = 2,
+	D3D12_FENCE          = 3,
+	SYNC_FD              = 4,
+	ZIRCON_EVENT_FUCHSIA = 7,
+	D3D11_FENCE          = D3D12_FENCE,
+	OPAQUE_FD_KHR        = OPAQUE_FD,
+	OPAQUE_WIN32_KHR     = OPAQUE_WIN32,
+	OPAQUE_WIN32_KMT_KHR = OPAQUE_WIN32_KMT,
+	D3D12_FENCE_KHR      = D3D12_FENCE,
+	SYNC_FD_KHR          = SYNC_FD,
+}
+
+ExternalSemaphoreFeatureFlags :: distinct bit_set[ExternalSemaphoreFeatureFlag; Flags];
+ExternalSemaphoreFeatureFlag :: enum Flags {
+	EXPORTABLE     = 0,
+	IMPORTABLE     = 1,
+	EXPORTABLE_KHR = EXPORTABLE,
+	IMPORTABLE_KHR = IMPORTABLE,
+}
+
+DriverId :: enum c.int {
+	AMD_PROPRIETARY               = 1,
+	AMD_OPEN_SOURCE               = 2,
+	MESA_RADV                     = 3,
+	NVIDIA_PROPRIETARY            = 4,
+	INTEL_PROPRIETARY_WINDOWS     = 5,
+	INTEL_OPEN_SOURCE_MESA        = 6,
+	IMAGINATION_PROPRIETARY       = 7,
+	QUALCOMM_PROPRIETARY          = 8,
+	ARM_PROPRIETARY               = 9,
+	GOOGLE_SWIFTSHADER            = 10,
+	GGP_PROPRIETARY               = 11,
+	BROADCOM_PROPRIETARY          = 12,
+	MESA_LLVMPIPE                 = 13,
+	MOLTENVK                      = 14,
+	COREAVI_PROPRIETARY           = 15,
+	JUICE_PROPRIETARY             = 16,
+	VERISILICON_PROPRIETARY       = 17,
+	AMD_PROPRIETARY_KHR           = AMD_PROPRIETARY,
+	AMD_OPEN_SOURCE_KHR           = AMD_OPEN_SOURCE,
+	MESA_RADV_KHR                 = MESA_RADV,
+	NVIDIA_PROPRIETARY_KHR        = NVIDIA_PROPRIETARY,
+	INTEL_PROPRIETARY_WINDOWS_KHR = INTEL_PROPRIETARY_WINDOWS,
+	INTEL_OPEN_SOURCE_MESA_KHR    = INTEL_OPEN_SOURCE_MESA,
+	IMAGINATION_PROPRIETARY_KHR   = IMAGINATION_PROPRIETARY,
+	QUALCOMM_PROPRIETARY_KHR      = QUALCOMM_PROPRIETARY,
+	ARM_PROPRIETARY_KHR           = ARM_PROPRIETARY,
+	GOOGLE_SWIFTSHADER_KHR        = GOOGLE_SWIFTSHADER,
+	GGP_PROPRIETARY_KHR           = GGP_PROPRIETARY,
+	BROADCOM_PROPRIETARY_KHR      = BROADCOM_PROPRIETARY,
+}
+
+ShaderFloatControlsIndependence :: enum c.int {
+	_32_BIT_ONLY     = 0,
+	ALL              = 1,
+	NONE             = 2,
+	_32_BIT_ONLY_KHR = _32_BIT_ONLY,
+	ALL_KHR          = ALL,
+}
+
+SamplerReductionMode :: enum c.int {
+	WEIGHTED_AVERAGE     = 0,
+	MIN                  = 1,
+	MAX                  = 2,
+	WEIGHTED_AVERAGE_EXT = WEIGHTED_AVERAGE,
+	MIN_EXT              = MIN,
+	MAX_EXT              = MAX,
+}
+
+SemaphoreType :: enum c.int {
+	BINARY       = 0,
+	TIMELINE     = 1,
+	BINARY_KHR   = BINARY,
+	TIMELINE_KHR = TIMELINE,
+}
+
+ResolveModeFlags :: distinct bit_set[ResolveModeFlag; Flags];
+ResolveModeFlag :: enum Flags {
+	SAMPLE_ZERO     = 0,
+	AVERAGE         = 1,
+	MIN             = 2,
+	MAX             = 3,
+	SAMPLE_ZERO_KHR = SAMPLE_ZERO,
+	AVERAGE_KHR     = AVERAGE,
+	MIN_KHR         = MIN,
+	MAX_KHR         = MAX,
+}
+
+ResolveModeFlags_NONE :: ResolveModeFlags{};
+
+
+DescriptorBindingFlags :: distinct bit_set[DescriptorBindingFlag; Flags];
+DescriptorBindingFlag :: enum Flags {
+	UPDATE_AFTER_BIND               = 0,
+	UPDATE_UNUSED_WHILE_PENDING     = 1,
+	PARTIALLY_BOUND                 = 2,
+	VARIABLE_DESCRIPTOR_COUNT       = 3,
+	UPDATE_AFTER_BIND_EXT           = UPDATE_AFTER_BIND,
+	UPDATE_UNUSED_WHILE_PENDING_EXT = UPDATE_UNUSED_WHILE_PENDING,
+	PARTIALLY_BOUND_EXT             = PARTIALLY_BOUND,
+	VARIABLE_DESCRIPTOR_COUNT_EXT   = VARIABLE_DESCRIPTOR_COUNT,
+}
+
+SemaphoreWaitFlags :: distinct bit_set[SemaphoreWaitFlag; Flags];
+SemaphoreWaitFlag :: enum Flags {
+	ANY     = 0,
+	ANY_KHR = ANY,
+}
+
+PresentModeKHR :: enum c.int {
+	IMMEDIATE                 = 0,
+	MAILBOX                   = 1,
+	FIFO                      = 2,
+	FIFO_RELAXED              = 3,
+	SHARED_DEMAND_REFRESH     = 1000111000,
+	SHARED_CONTINUOUS_REFRESH = 1000111001,
+}
+
+ColorSpaceKHR :: enum c.int {
+	SRGB_NONLINEAR              = 0,
+	DISPLAY_P3_NONLINEAR_EXT    = 1000104001,
+	EXTENDED_SRGB_LINEAR_EXT    = 1000104002,
+	DISPLAY_P3_LINEAR_EXT       = 1000104003,
+	DCI_P3_NONLINEAR_EXT        = 1000104004,
+	BT709_LINEAR_EXT            = 1000104005,
+	BT709_NONLINEAR_EXT         = 1000104006,
+	BT2020_LINEAR_EXT           = 1000104007,
+	HDR10_ST2084_EXT            = 1000104008,
+	DOLBYVISION_EXT             = 1000104009,
+	HDR10_HLG_EXT               = 1000104010,
+	ADOBERGB_LINEAR_EXT         = 1000104011,
+	ADOBERGB_NONLINEAR_EXT      = 1000104012,
+	PASS_THROUGH_EXT            = 1000104013,
+	EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
+	DISPLAY_NATIVE_AMD          = 1000213000,
+	COLORSPACE_SRGB_NONLINEAR   = SRGB_NONLINEAR,
+	DCI_P3_LINEAR_EXT           = DISPLAY_P3_LINEAR_EXT,
+}
+
+SurfaceTransformFlagsKHR :: distinct bit_set[SurfaceTransformFlagKHR; Flags];
+SurfaceTransformFlagKHR :: enum Flags {
+	IDENTITY                     = 0,
+	ROTATE_90                    = 1,
+	ROTATE_180                   = 2,
+	ROTATE_270                   = 3,
+	HORIZONTAL_MIRROR            = 4,
+	HORIZONTAL_MIRROR_ROTATE_90  = 5,
+	HORIZONTAL_MIRROR_ROTATE_180 = 6,
+	HORIZONTAL_MIRROR_ROTATE_270 = 7,
+	INHERIT                      = 8,
+}
+
+CompositeAlphaFlagsKHR :: distinct bit_set[CompositeAlphaFlagKHR; Flags];
+CompositeAlphaFlagKHR :: enum Flags {
+	OPAQUE          = 0,
+	PRE_MULTIPLIED  = 1,
+	POST_MULTIPLIED = 2,
+	INHERIT         = 3,
+}
+
+SwapchainCreateFlagsKHR :: distinct bit_set[SwapchainCreateFlagKHR; Flags];
+SwapchainCreateFlagKHR :: enum Flags {
+	SPLIT_INSTANCE_BIND_REGIONS = 0,
+	PROTECTED                   = 1,
+	MUTABLE_FORMAT              = 2,
+}
+
+DeviceGroupPresentModeFlagsKHR :: distinct bit_set[DeviceGroupPresentModeFlagKHR; Flags];
+DeviceGroupPresentModeFlagKHR :: enum Flags {
+	LOCAL              = 0,
+	REMOTE             = 1,
+	SUM                = 2,
+	LOCAL_MULTI_DEVICE = 3,
+}
+
+DisplayPlaneAlphaFlagsKHR :: distinct bit_set[DisplayPlaneAlphaFlagKHR; Flags];
+DisplayPlaneAlphaFlagKHR :: enum Flags {
+	OPAQUE                  = 0,
+	GLOBAL                  = 1,
+	PER_PIXEL               = 2,
+	PER_PIXEL_PREMULTIPLIED = 3,
+}
+
+PerformanceCounterUnitKHR :: enum c.int {
+	GENERIC          = 0,
+	PERCENTAGE       = 1,
+	NANOSECONDS      = 2,
+	BYTES            = 3,
+	BYTES_PER_SECOND = 4,
+	KELVIN           = 5,
+	WATTS            = 6,
+	VOLTS            = 7,
+	AMPS             = 8,
+	HERTZ            = 9,
+	CYCLES           = 10,
+}
+
+PerformanceCounterScopeKHR :: enum c.int {
+	COMMAND_BUFFER             = 0,
+	RENDER_PASS                = 1,
+	COMMAND                    = 2,
+	QUERY_SCOPE_COMMAND_BUFFER = COMMAND_BUFFER,
+	QUERY_SCOPE_RENDER_PASS    = RENDER_PASS,
+	QUERY_SCOPE_COMMAND        = COMMAND,
+}
+
+PerformanceCounterStorageKHR :: enum c.int {
+	INT32   = 0,
+	INT64   = 1,
+	UINT32  = 2,
+	UINT64  = 3,
+	FLOAT32 = 4,
+	FLOAT64 = 5,
+}
+
+PerformanceCounterDescriptionFlagsKHR :: distinct bit_set[PerformanceCounterDescriptionFlagKHR; Flags];
+PerformanceCounterDescriptionFlagKHR :: enum Flags {
+	PERFORMANCE_IMPACTING = 0,
+	CONCURRENTLY_IMPACTED = 1,
+}
+
+AcquireProfilingLockFlagsKHR :: distinct bit_set[AcquireProfilingLockFlagKHR; Flags];
+AcquireProfilingLockFlagKHR :: enum Flags {
+}
+
+FragmentShadingRateCombinerOpKHR :: enum c.int {
+	KEEP    = 0,
+	REPLACE = 1,
+	MIN     = 2,
+	MAX     = 3,
+	MUL     = 4,
+}
+
+PipelineExecutableStatisticFormatKHR :: enum c.int {
+	BOOL32  = 0,
+	INT64   = 1,
+	UINT64  = 2,
+	FLOAT64 = 3,
+}
+
+SubmitFlagsKHR :: distinct bit_set[SubmitFlagKHR; Flags];
+SubmitFlagKHR :: enum Flags {
+	PROTECTED = 0,
+}
+
+DebugReportObjectTypeEXT :: enum c.int {
+	UNKNOWN                        = 0,
+	INSTANCE                       = 1,
+	PHYSICAL_DEVICE                = 2,
+	DEVICE                         = 3,
+	QUEUE                          = 4,
+	SEMAPHORE                      = 5,
+	COMMAND_BUFFER                 = 6,
+	FENCE                          = 7,
+	DEVICE_MEMORY                  = 8,
+	BUFFER                         = 9,
+	IMAGE                          = 10,
+	EVENT                          = 11,
+	QUERY_POOL                     = 12,
+	BUFFER_VIEW                    = 13,
+	IMAGE_VIEW                     = 14,
+	SHADER_MODULE                  = 15,
+	PIPELINE_CACHE                 = 16,
+	PIPELINE_LAYOUT                = 17,
+	RENDER_PASS                    = 18,
+	PIPELINE                       = 19,
+	DESCRIPTOR_SET_LAYOUT          = 20,
+	SAMPLER                        = 21,
+	DESCRIPTOR_POOL                = 22,
+	DESCRIPTOR_SET                 = 23,
+	FRAMEBUFFER                    = 24,
+	COMMAND_POOL                   = 25,
+	SURFACE_KHR                    = 26,
+	SWAPCHAIN_KHR                  = 27,
+	DEBUG_REPORT_CALLBACK_EXT      = 28,
+	DISPLAY_KHR                    = 29,
+	DISPLAY_MODE_KHR               = 30,
+	VALIDATION_CACHE_EXT           = 33,
+	SAMPLER_YCBCR_CONVERSION       = 1000156000,
+	DESCRIPTOR_UPDATE_TEMPLATE     = 1000085000,
+	CU_MODULE_NVX                  = 1000029000,
+	CU_FUNCTION_NVX                = 1000029001,
+	ACCELERATION_STRUCTURE_KHR     = 1000150000,
+	ACCELERATION_STRUCTURE_NV      = 1000165000,
+	DEBUG_REPORT                   = DEBUG_REPORT_CALLBACK_EXT,
+	VALIDATION_CACHE               = VALIDATION_CACHE_EXT,
+	DESCRIPTOR_UPDATE_TEMPLATE_KHR = DESCRIPTOR_UPDATE_TEMPLATE,
+	SAMPLER_YCBCR_CONVERSION_KHR   = SAMPLER_YCBCR_CONVERSION,
+}
+
+DebugReportFlagsEXT :: distinct bit_set[DebugReportFlagEXT; Flags];
+DebugReportFlagEXT :: enum Flags {
+	INFORMATION         = 0,
+	WARNING             = 1,
+	PERFORMANCE_WARNING = 2,
+	ERROR               = 3,
+	DEBUG               = 4,
+}
+
+RasterizationOrderAMD :: enum c.int {
+	STRICT  = 0,
+	RELAXED = 1,
+}
+
+ShaderInfoTypeAMD :: enum c.int {
+	STATISTICS  = 0,
+	BINARY      = 1,
+	DISASSEMBLY = 2,
+}
+
+ExternalMemoryHandleTypeFlagsNV :: distinct bit_set[ExternalMemoryHandleTypeFlagNV; Flags];
+ExternalMemoryHandleTypeFlagNV :: enum Flags {
+	OPAQUE_WIN32     = 0,
+	OPAQUE_WIN32_KMT = 1,
+	D3D11_IMAGE      = 2,
+	D3D11_IMAGE_KMT  = 3,
+}
+
+ExternalMemoryFeatureFlagsNV :: distinct bit_set[ExternalMemoryFeatureFlagNV; Flags];
+ExternalMemoryFeatureFlagNV :: enum Flags {
+	DEDICATED_ONLY = 0,
+	EXPORTABLE     = 1,
+	IMPORTABLE     = 2,
+}
+
+ValidationCheckEXT :: enum c.int {
+	ALL     = 0,
+	SHADERS = 1,
+}
+
+ConditionalRenderingFlagsEXT :: distinct bit_set[ConditionalRenderingFlagEXT; Flags];
+ConditionalRenderingFlagEXT :: enum Flags {
+	INVERTED = 0,
+}
+
+SurfaceCounterFlagsEXT :: distinct bit_set[SurfaceCounterFlagEXT; Flags];
+SurfaceCounterFlagEXT :: enum Flags {
+	VBLANK = 0,
+}
+
+DisplayPowerStateEXT :: enum c.int {
+	OFF     = 0,
+	SUSPEND = 1,
+	ON      = 2,
+}
+
+DeviceEventTypeEXT :: enum c.int {
+	DISPLAY_HOTPLUG = 0,
+}
+
+DisplayEventTypeEXT :: enum c.int {
+	FIRST_PIXEL_OUT = 0,
+}
+
+ViewportCoordinateSwizzleNV :: enum c.int {
+	POSITIVE_X = 0,
+	NEGATIVE_X = 1,
+	POSITIVE_Y = 2,
+	NEGATIVE_Y = 3,
+	POSITIVE_Z = 4,
+	NEGATIVE_Z = 5,
+	POSITIVE_W = 6,
+	NEGATIVE_W = 7,
+}
+
+DiscardRectangleModeEXT :: enum c.int {
+	INCLUSIVE = 0,
+	EXCLUSIVE = 1,
+}
+
+ConservativeRasterizationModeEXT :: enum c.int {
+	DISABLED      = 0,
+	OVERESTIMATE  = 1,
+	UNDERESTIMATE = 2,
+}
+
+DebugUtilsMessageSeverityFlagsEXT :: distinct bit_set[DebugUtilsMessageSeverityFlagEXT; Flags];
+DebugUtilsMessageSeverityFlagEXT :: enum Flags {
+	VERBOSE = 0,
+	INFO    = 4,
+	WARNING = 8,
+	ERROR   = 12,
+}
+
+DebugUtilsMessageTypeFlagsEXT :: distinct bit_set[DebugUtilsMessageTypeFlagEXT; Flags];
+DebugUtilsMessageTypeFlagEXT :: enum Flags {
+	GENERAL     = 0,
+	VALIDATION  = 1,
+	PERFORMANCE = 2,
+}
+
+BlendOverlapEXT :: enum c.int {
+	UNCORRELATED = 0,
+	DISJOINT     = 1,
+	CONJOINT     = 2,
+}
+
+CoverageModulationModeNV :: enum c.int {
+	NONE  = 0,
+	RGB   = 1,
+	ALPHA = 2,
+	RGBA  = 3,
+}
+
+ValidationCacheHeaderVersionEXT :: enum c.int {
+	ONE = 1,
+}
+
+ShadingRatePaletteEntryNV :: enum c.int {
+	NO_INVOCATIONS               = 0,
+	_16_INVOCATIONS_PER_PIXEL    = 1,
+	_8_INVOCATIONS_PER_PIXEL     = 2,
+	_4_INVOCATIONS_PER_PIXEL     = 3,
+	_2_INVOCATIONS_PER_PIXEL     = 4,
+	_1_INVOCATION_PER_PIXEL      = 5,
+	_1_INVOCATION_PER_2X1_PIXELS = 6,
+	_1_INVOCATION_PER_1X2_PIXELS = 7,
+	_1_INVOCATION_PER_2X2_PIXELS = 8,
+	_1_INVOCATION_PER_4X2_PIXELS = 9,
+	_1_INVOCATION_PER_2X4_PIXELS = 10,
+	_1_INVOCATION_PER_4X4_PIXELS = 11,
+}
+
+CoarseSampleOrderTypeNV :: enum c.int {
+	DEFAULT      = 0,
+	CUSTOM       = 1,
+	PIXEL_MAJOR  = 2,
+	SAMPLE_MAJOR = 3,
+}
+
+RayTracingShaderGroupTypeKHR :: enum c.int {
+	GENERAL                 = 0,
+	TRIANGLES_HIT_GROUP     = 1,
+	PROCEDURAL_HIT_GROUP    = 2,
+	GENERAL_NV              = GENERAL,
+	TRIANGLES_HIT_GROUP_NV  = TRIANGLES_HIT_GROUP,
+	PROCEDURAL_HIT_GROUP_NV = PROCEDURAL_HIT_GROUP,
+}
+
+GeometryTypeKHR :: enum c.int {
+	TRIANGLES    = 0,
+	AABBS        = 1,
+	INSTANCES    = 2,
+	TRIANGLES_NV = TRIANGLES,
+	AABBS_NV     = AABBS,
+}
+
+AccelerationStructureTypeKHR :: enum c.int {
+	TOP_LEVEL       = 0,
+	BOTTOM_LEVEL    = 1,
+	GENERIC         = 2,
+	TOP_LEVEL_NV    = TOP_LEVEL,
+	BOTTOM_LEVEL_NV = BOTTOM_LEVEL,
+}
+
+CopyAccelerationStructureModeKHR :: enum c.int {
+	CLONE       = 0,
+	COMPACT     = 1,
+	SERIALIZE   = 2,
+	DESERIALIZE = 3,
+	CLONE_NV    = CLONE,
+	COMPACT_NV  = COMPACT,
+}
+
+AccelerationStructureMemoryRequirementsTypeNV :: enum c.int {
+	OBJECT         = 0,
+	BUILD_SCRATCH  = 1,
+	UPDATE_SCRATCH = 2,
+}
+
+GeometryFlagsKHR :: distinct bit_set[GeometryFlagKHR; Flags];
+GeometryFlagKHR :: enum Flags {
+	OPAQUE                             = 0,
+	NO_DUPLICATE_ANY_HIT_INVOCATION    = 1,
+	OPAQUE_NV                          = OPAQUE,
+	NO_DUPLICATE_ANY_HIT_INVOCATION_NV = NO_DUPLICATE_ANY_HIT_INVOCATION,
+}
+
+GeometryInstanceFlagsKHR :: distinct bit_set[GeometryInstanceFlagKHR; Flags];
+GeometryInstanceFlagKHR :: enum Flags {
+	TRIANGLE_FACING_CULL_DISABLE       = 0,
+	TRIANGLE_FLIP_FACING               = 1,
+	FORCE_OPAQUE                       = 2,
+	FORCE_NO_OPAQUE                    = 3,
+	TRIANGLE_FRONT_COUNTERCLOCKWISE    = TRIANGLE_FLIP_FACING,
+	TRIANGLE_CULL_DISABLE_NV           = TRIANGLE_FACING_CULL_DISABLE,
+	TRIANGLE_FRONT_COUNTERCLOCKWISE_NV = TRIANGLE_FRONT_COUNTERCLOCKWISE,
+	FORCE_OPAQUE_NV                    = FORCE_OPAQUE,
+	FORCE_NO_OPAQUE_NV                 = FORCE_NO_OPAQUE,
+}
+
+BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags];
+BuildAccelerationStructureFlagKHR :: enum Flags {
+	ALLOW_UPDATE         = 0,
+	ALLOW_COMPACTION     = 1,
+	PREFER_FAST_TRACE    = 2,
+	PREFER_FAST_BUILD    = 3,
+	LOW_MEMORY           = 4,
+	MOTION_NV            = 5,
+	ALLOW_UPDATE_NV      = ALLOW_UPDATE,
+	ALLOW_COMPACTION_NV  = ALLOW_COMPACTION,
+	PREFER_FAST_TRACE_NV = PREFER_FAST_TRACE,
+	PREFER_FAST_BUILD_NV = PREFER_FAST_BUILD,
+	LOW_MEMORY_NV        = LOW_MEMORY,
+}
+
+QueueGlobalPriorityEXT :: enum c.int {
+	LOW      = 128,
+	MEDIUM   = 256,
+	HIGH     = 512,
+	REALTIME = 1024,
+}
+
+PipelineCompilerControlFlagsAMD :: distinct bit_set[PipelineCompilerControlFlagAMD; Flags];
+PipelineCompilerControlFlagAMD :: enum Flags {
+}
+
+TimeDomainEXT :: enum c.int {
+	DEVICE                    = 0,
+	CLOCK_MONOTONIC           = 1,
+	CLOCK_MONOTONIC_RAW       = 2,
+	QUERY_PERFORMANCE_COUNTER = 3,
+}
+
+MemoryOverallocationBehaviorAMD :: enum c.int {
+	DEFAULT    = 0,
+	ALLOWED    = 1,
+	DISALLOWED = 2,
+}
+
+PipelineCreationFeedbackFlagsEXT :: distinct bit_set[PipelineCreationFeedbackFlagEXT; Flags];
+PipelineCreationFeedbackFlagEXT :: enum Flags {
+	VALID                          = 0,
+	APPLICATION_PIPELINE_CACHE_HIT = 1,
+	BASE_PIPELINE_ACCELERATION     = 2,
+}
+
+PerformanceConfigurationTypeINTEL :: enum c.int {
+	PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
+}
+
+QueryPoolSamplingModeINTEL :: enum c.int {
+	QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
+}
+
+PerformanceOverrideTypeINTEL :: enum c.int {
+	PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL    = 0,
+	PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
+}
+
+PerformanceParameterTypeINTEL :: enum c.int {
+	PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL    = 0,
+	PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
+}
+
+PerformanceValueTypeINTEL :: enum c.int {
+	PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
+	PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
+	PERFORMANCE_VALUE_TYPE_FLOAT_INTEL  = 2,
+	PERFORMANCE_VALUE_TYPE_BOOL_INTEL   = 3,
+	PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
+}
+
+ShaderCorePropertiesFlagsAMD :: distinct bit_set[ShaderCorePropertiesFlagAMD; Flags];
+ShaderCorePropertiesFlagAMD :: enum Flags {
+}
+
+ToolPurposeFlagsEXT :: distinct bit_set[ToolPurposeFlagEXT; Flags];
+ToolPurposeFlagEXT :: enum Flags {
+	VALIDATION          = 0,
+	PROFILING           = 1,
+	TRACING             = 2,
+	ADDITIONAL_FEATURES = 3,
+	MODIFYING_FEATURES  = 4,
+	DEBUG_REPORTING     = 5,
+	DEBUG_MARKERS       = 6,
+}
+
+ValidationFeatureEnableEXT :: enum c.int {
+	GPU_ASSISTED                      = 0,
+	GPU_ASSISTED_RESERVE_BINDING_SLOT = 1,
+	BEST_PRACTICES                    = 2,
+	DEBUG_PRINTF                      = 3,
+	SYNCHRONIZATION_VALIDATION        = 4,
+}
+
+ValidationFeatureDisableEXT :: enum c.int {
+	ALL                     = 0,
+	SHADERS                 = 1,
+	THREAD_SAFETY           = 2,
+	API_PARAMETERS          = 3,
+	OBJECT_LIFETIMES        = 4,
+	CORE_CHECKS             = 5,
+	UNIQUE_HANDLES          = 6,
+	SHADER_VALIDATION_CACHE = 7,
+}
+
+ComponentTypeNV :: enum c.int {
+	FLOAT16 = 0,
+	FLOAT32 = 1,
+	FLOAT64 = 2,
+	SINT8   = 3,
+	SINT16  = 4,
+	SINT32  = 5,
+	SINT64  = 6,
+	UINT8   = 7,
+	UINT16  = 8,
+	UINT32  = 9,
+	UINT64  = 10,
+}
+
+ScopeNV :: enum c.int {
+	DEVICE       = 1,
+	WORKGROUP    = 2,
+	SUBGROUP     = 3,
+	QUEUE_FAMILY = 5,
+}
+
+CoverageReductionModeNV :: enum c.int {
+	MERGE    = 0,
+	TRUNCATE = 1,
+}
+
+ProvokingVertexModeEXT :: enum c.int {
+	FIRST_VERTEX = 0,
+	LAST_VERTEX  = 1,
+}
+
+LineRasterizationModeEXT :: enum c.int {
+	DEFAULT            = 0,
+	RECTANGULAR        = 1,
+	BRESENHAM          = 2,
+	RECTANGULAR_SMOOTH = 3,
+}
+
+IndirectCommandsTokenTypeNV :: enum c.int {
+	SHADER_GROUP  = 0,
+	STATE_FLAGS   = 1,
+	INDEX_BUFFER  = 2,
+	VERTEX_BUFFER = 3,
+	PUSH_CONSTANT = 4,
+	DRAW_INDEXED  = 5,
+	DRAW          = 6,
+	DRAW_TASKS    = 7,
+}
+
+IndirectStateFlagsNV :: distinct bit_set[IndirectStateFlagNV; Flags];
+IndirectStateFlagNV :: enum Flags {
+	FLAG_FRONTFACE = 0,
+}
+
+IndirectCommandsLayoutUsageFlagsNV :: distinct bit_set[IndirectCommandsLayoutUsageFlagNV; Flags];
+IndirectCommandsLayoutUsageFlagNV :: enum Flags {
+	EXPLICIT_PREPROCESS = 0,
+	INDEXED_SEQUENCES   = 1,
+	UNORDERED_SEQUENCES = 2,
+}
+
+DeviceMemoryReportEventTypeEXT :: enum c.int {
+	ALLOCATE          = 0,
+	FREE              = 1,
+	IMPORT            = 2,
+	UNIMPORT          = 3,
+	ALLOCATION_FAILED = 4,
+}
+
+PrivateDataSlotCreateFlagsEXT :: distinct bit_set[PrivateDataSlotCreateFlagEXT; Flags];
+PrivateDataSlotCreateFlagEXT :: enum Flags {
+}
+
+DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags];
+DeviceDiagnosticsConfigFlagNV :: enum Flags {
+	ENABLE_SHADER_DEBUG_INFO     = 0,
+	ENABLE_RESOURCE_TRACKING     = 1,
+	ENABLE_AUTOMATIC_CHECKPOINTS = 2,
+}
+
+FragmentShadingRateTypeNV :: enum c.int {
+	FRAGMENT_SIZE = 0,
+	ENUMS         = 1,
+}
+
+FragmentShadingRateNV :: enum c.int {
+	_1_INVOCATION_PER_PIXEL      = 0,
+	_1_INVOCATION_PER_1X2_PIXELS = 1,
+	_1_INVOCATION_PER_2X1_PIXELS = 4,
+	_1_INVOCATION_PER_2X2_PIXELS = 5,
+	_1_INVOCATION_PER_2X4_PIXELS = 6,
+	_1_INVOCATION_PER_4X2_PIXELS = 9,
+	_1_INVOCATION_PER_4X4_PIXELS = 10,
+	_2_INVOCATIONS_PER_PIXEL     = 11,
+	_4_INVOCATIONS_PER_PIXEL     = 12,
+	_8_INVOCATIONS_PER_PIXEL     = 13,
+	_16_INVOCATIONS_PER_PIXEL    = 14,
+	NO_INVOCATIONS               = 15,
+}
+
+AccelerationStructureMotionInstanceTypeNV :: enum c.int {
+	STATIC        = 0,
+	MATRIX_MOTION = 1,
+	SRT_MOTION    = 2,
+}
+
+BuildAccelerationStructureModeKHR :: enum c.int {
+	BUILD  = 0,
+	UPDATE = 1,
+}
+
+AccelerationStructureBuildTypeKHR :: enum c.int {
+	HOST           = 0,
+	DEVICE         = 1,
+	HOST_OR_DEVICE = 2,
+}
+
+AccelerationStructureCompatibilityKHR :: enum c.int {
+	COMPATIBLE   = 0,
+	INCOMPATIBLE = 1,
+}
+
+AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags];
+AccelerationStructureCreateFlagKHR :: enum Flags {
+	DEVICE_ADDRESS_CAPTURE_REPLAY = 0,
+	MOTION_NV                     = 2,
+}
+
+ShaderGroupShaderKHR :: enum c.int {
+	GENERAL      = 0,
+	CLOSEST_HIT  = 1,
+	ANY_HIT      = 2,
+	INTERSECTION = 3,
+}
+
+NegotiateLayerStructType :: enum c.int {
+}
+
+LayerFunction_ :: enum c.int {
+	LAYER_LINK_INFO                     = 0,
+	LOADER_DATA_CALLBACK                = 1,
+	LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2,
+	LOADER_FEATURES                     = 3,
+}
+
+LoaderFeastureFlags :: distinct bit_set[LoaderFeastureFlag; Flags];
+LoaderFeastureFlag :: enum Flags {
+	LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0,
+}
+
+ChainType :: enum c.int {
+	UNKNOWN                                 = 0,
+	ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
+	ENUMERATE_INSTANCE_LAYER_PROPERTIES     = 2,
+	ENUMERATE_INSTANCE_VERSION              = 3,
+}
+
+FullScreenExclusiveEXT :: enum c.int {
+	DEFAULT                = 0,
+	ALLOWED                = 1,
+	DISALLOWED             = 2,
+	APPLICATION_CONTROLLED = 3,
+}
+
+PipelineDynamicStateCreateFlags                      :: distinct bit_set[PipelineDynamicStateCreateFlag; Flags];
+PipelineDynamicStateCreateFlag                       :: enum u32 {};
+PipelineViewportStateCreateFlags                     :: distinct bit_set[PipelineViewportStateCreateFlag; Flags];
+PipelineViewportStateCreateFlag                      :: enum u32 {};
+PipelineDiscardRectangleStateCreateFlagsEXT          :: distinct bit_set[PipelineDiscardRectangleStateCreateFlagEXT; Flags];
+PipelineDiscardRectangleStateCreateFlagEXT           :: enum u32 {};
+DescriptorUpdateTemplateCreateFlags                  :: distinct bit_set[DescriptorUpdateTemplateCreateFlag; Flags];
+DescriptorUpdateTemplateCreateFlag                   :: enum u32 {};
+AccelerationStructureMotionInstanceFlagsNV           :: distinct bit_set[AccelerationStructureMotionInstanceFlagNV; Flags];
+AccelerationStructureMotionInstanceFlagNV            :: enum u32 {};
+PipelineRasterizationConservativeStateCreateFlagsEXT :: distinct bit_set[PipelineRasterizationConservativeStateCreateFlagEXT; Flags];
+PipelineRasterizationConservativeStateCreateFlagEXT  :: enum u32 {};
+PipelineRasterizationDepthClipStateCreateFlagsEXT    :: distinct bit_set[PipelineRasterizationDepthClipStateCreateFlagEXT; Flags];
+PipelineRasterizationDepthClipStateCreateFlagEXT     :: enum u32 {};
+ValidationCacheCreateFlagsEXT                        :: distinct bit_set[ValidationCacheCreateFlagEXT; Flags];
+ValidationCacheCreateFlagEXT                         :: enum u32 {};
+AccelerationStructureMotionInfoFlagsNV               :: distinct bit_set[AccelerationStructureMotionInfoFlagNV; Flags];
+AccelerationStructureMotionInfoFlagNV                :: enum u32 {};
+MacOSSurfaceCreateFlagsMVK                           :: distinct bit_set[MacOSSurfaceCreateFlagMVK; Flags];
+MacOSSurfaceCreateFlagMVK                            :: enum u32 {};
+MetalSurfaceCreateFlagsEXT                           :: distinct bit_set[MetalSurfaceCreateFlagEXT; Flags];
+MetalSurfaceCreateFlagEXT                            :: enum u32 {};
+PipelineInputAssemblyStateCreateFlags                :: distinct bit_set[PipelineInputAssemblyStateCreateFlag; Flags];
+PipelineInputAssemblyStateCreateFlag                 :: enum u32 {};
+PipelineTessellationStateCreateFlags                 :: distinct bit_set[PipelineTessellationStateCreateFlag; Flags];
+PipelineTessellationStateCreateFlag                  :: enum u32 {};
+PipelineCoverageModulationStateCreateFlagsNV         :: distinct bit_set[PipelineCoverageModulationStateCreateFlagNV; Flags];
+PipelineCoverageModulationStateCreateFlagNV          :: enum u32 {};
+CommandPoolTrimFlags                                 :: distinct bit_set[CommandPoolTrimFlag; Flags];
+CommandPoolTrimFlag                                  :: enum u32 {};
+DisplayModeCreateFlagsKHR                            :: distinct bit_set[DisplayModeCreateFlagKHR; Flags];
+DisplayModeCreateFlagKHR                             :: enum u32 {};
+PipelineRasterizationStateStreamCreateFlagsEXT       :: distinct bit_set[PipelineRasterizationStateStreamCreateFlagEXT; Flags];
+PipelineRasterizationStateStreamCreateFlagEXT        :: enum u32 {};
+DisplaySurfaceCreateFlagsKHR                         :: distinct bit_set[DisplaySurfaceCreateFlagKHR; Flags];
+DisplaySurfaceCreateFlagKHR                          :: enum u32 {};
+QueryPoolCreateFlags                                 :: distinct bit_set[QueryPoolCreateFlag; Flags];
+QueryPoolCreateFlag                                  :: enum u32 {};
+PipelineColorBlendStateCreateFlags                   :: distinct bit_set[PipelineColorBlendStateCreateFlag; Flags];
+PipelineColorBlendStateCreateFlag                    :: enum u32 {};
+LoaderFeatureFlags                                   :: distinct bit_set[LoaderFeatureFlag; Flags];
+LoaderFeatureFlag                                    :: enum u32 {};
+PipelineCoverageReductionStateCreateFlagsNV          :: distinct bit_set[PipelineCoverageReductionStateCreateFlagNV; Flags];
+PipelineCoverageReductionStateCreateFlagNV           :: enum u32 {};
+DeviceCreateFlags                                    :: distinct bit_set[DeviceCreateFlag; Flags];
+DeviceCreateFlag                                     :: enum u32 {};
+HeadlessSurfaceCreateFlagsEXT                        :: distinct bit_set[HeadlessSurfaceCreateFlagEXT; Flags];
+HeadlessSurfaceCreateFlagEXT                         :: enum u32 {};
+PipelineMultisampleStateCreateFlags                  :: distinct bit_set[PipelineMultisampleStateCreateFlag; Flags];
+PipelineMultisampleStateCreateFlag                   :: enum u32 {};
+InstanceCreateFlags                                  :: distinct bit_set[InstanceCreateFlag; Flags];
+InstanceCreateFlag                                   :: enum u32 {};
+Win32SurfaceCreateFlagsKHR                           :: distinct bit_set[Win32SurfaceCreateFlagKHR; Flags];
+Win32SurfaceCreateFlagKHR                            :: enum u32 {};
+IOSSurfaceCreateFlagsMVK                             :: distinct bit_set[IOSSurfaceCreateFlagMVK; Flags];
+IOSSurfaceCreateFlagMVK                              :: enum u32 {};
+PipelineLayoutCreateFlags                            :: distinct bit_set[PipelineLayoutCreateFlag; Flags];
+PipelineLayoutCreateFlag                             :: enum u32 {};
+PipelineCoverageToColorStateCreateFlagsNV            :: distinct bit_set[PipelineCoverageToColorStateCreateFlagNV; Flags];
+PipelineCoverageToColorStateCreateFlagNV             :: enum u32 {};
+SemaphoreCreateFlags                                 :: distinct bit_set[SemaphoreCreateFlag; Flags];
+SemaphoreCreateFlag                                  :: enum u32 {};
+PipelineViewportSwizzleStateCreateFlagsNV            :: distinct bit_set[PipelineViewportSwizzleStateCreateFlagNV; Flags];
+PipelineViewportSwizzleStateCreateFlagNV             :: enum u32 {};
+PipelineDepthStencilStateCreateFlags                 :: distinct bit_set[PipelineDepthStencilStateCreateFlag; Flags];
+PipelineDepthStencilStateCreateFlag                  :: enum u32 {};
+MemoryMapFlags                                       :: distinct bit_set[MemoryMapFlag; Flags];
+MemoryMapFlag                                        :: enum u32 {};
+PipelineRasterizationStateCreateFlags                :: distinct bit_set[PipelineRasterizationStateCreateFlag; Flags];
+PipelineRasterizationStateCreateFlag                 :: enum u32 {};
+DeviceMemoryReportFlagsEXT                           :: distinct bit_set[DeviceMemoryReportFlagEXT; Flags];
+DeviceMemoryReportFlagEXT                            :: enum u32 {};
+DebugUtilsMessengerCallbackDataFlagsEXT              :: distinct bit_set[DebugUtilsMessengerCallbackDataFlagEXT; Flags];
+DebugUtilsMessengerCallbackDataFlagEXT               :: enum u32 {};
+DebugUtilsMessengerCreateFlagsEXT                    :: distinct bit_set[DebugUtilsMessengerCreateFlagEXT; Flags];
+DebugUtilsMessengerCreateFlagEXT                     :: enum u32 {};
+DescriptorPoolResetFlags                             :: distinct bit_set[DescriptorPoolResetFlag; Flags];
+DescriptorPoolResetFlag                              :: enum u32 {};
+BufferViewCreateFlags                                :: distinct bit_set[BufferViewCreateFlag; Flags];
+BufferViewCreateFlag                                 :: enum u32 {};
+PipelineVertexInputStateCreateFlags                  :: distinct bit_set[PipelineVertexInputStateCreateFlag; Flags];
+PipelineVertexInputStateCreateFlag                   :: enum u32 {};
+
+

vendor/vulkan/procedures.odin

@@ -0,0 +1,1924 @@
+//
+// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
+//
+package vulkan
+
+import "core:c"
+
+// Procedure Types
+
+when ODIN_OS == "windows" {
+	ProcAllocationFunction                                              :: #type proc "stdcall" (pUserData: rawptr, size: int, alignment: int, allocationScope: SystemAllocationScope) -> rawptr;
+	ProcFreeFunction                                                    :: #type proc "stdcall" (pUserData: rawptr, pMemory: rawptr);
+	ProcInternalAllocationNotification                                  :: #type proc "stdcall" (pUserData: rawptr, size: int, allocationType: InternalAllocationType, allocationScope: SystemAllocationScope);
+	ProcInternalFreeNotification                                        :: #type proc "stdcall" (pUserData: rawptr, size: int, allocationType: InternalAllocationType, allocationScope: SystemAllocationScope);
+	ProcReallocationFunction                                            :: #type proc "stdcall" (pUserData: rawptr, pOriginal: rawptr, size: int, alignment: int, allocationScope: SystemAllocationScope) -> rawptr;
+	ProcVoidFunction                                                    :: #type proc "stdcall" ();
+	ProcCreateInstance                                                  :: #type proc "stdcall" (pCreateInfo: ^InstanceCreateInfo, pAllocator: ^AllocationCallbacks, pInstance: ^Instance) -> Result;
+	ProcDestroyInstance                                                 :: #type proc "stdcall" (instance: Instance, pAllocator: ^AllocationCallbacks);
+	ProcEnumeratePhysicalDevices                                        :: #type proc "stdcall" (instance: Instance, pPhysicalDeviceCount: ^u32, pPhysicalDevices: ^PhysicalDevice) -> Result;
+	ProcGetPhysicalDeviceFeatures                                       :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures);
+	ProcGetPhysicalDeviceFormatProperties                               :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties);
+	ProcGetPhysicalDeviceImageFormatProperties                          :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, pImageFormatProperties: ^ImageFormatProperties) -> Result;
+	ProcGetPhysicalDeviceProperties                                     :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties);
+	ProcGetPhysicalDeviceQueueFamilyProperties                          :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties);
+	ProcGetPhysicalDeviceMemoryProperties                               :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties);
+	ProcGetInstanceProcAddr                                             :: #type proc "stdcall" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcGetDeviceProcAddr                                               :: #type proc "stdcall" (device: Device, pName: cstring) -> ProcVoidFunction;
+	ProcCreateDevice                                                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pCreateInfo: ^DeviceCreateInfo, pAllocator: ^AllocationCallbacks, pDevice: ^Device) -> Result;
+	ProcDestroyDevice                                                   :: #type proc "stdcall" (device: Device, pAllocator: ^AllocationCallbacks);
+	ProcEnumerateInstanceExtensionProperties                            :: #type proc "stdcall" (pLayerName: cstring, pPropertyCount: ^u32, pProperties: ^ExtensionProperties) -> Result;
+	ProcEnumerateDeviceExtensionProperties                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pLayerName: cstring, pPropertyCount: ^u32, pProperties: ^ExtensionProperties) -> Result;
+	ProcEnumerateInstanceLayerProperties                                :: #type proc "stdcall" (pPropertyCount: ^u32, pProperties: ^LayerProperties) -> Result;
+	ProcEnumerateDeviceLayerProperties                                  :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^LayerProperties) -> Result;
+	ProcGetDeviceQueue                                                  :: #type proc "stdcall" (device: Device, queueFamilyIndex: u32, queueIndex: u32, pQueue: ^Queue);
+	ProcQueueSubmit                                                     :: #type proc "stdcall" (queue: Queue, submitCount: u32, pSubmits: ^SubmitInfo, fence: Fence) -> Result;
+	ProcQueueWaitIdle                                                   :: #type proc "stdcall" (queue: Queue) -> Result;
+	ProcDeviceWaitIdle                                                  :: #type proc "stdcall" (device: Device) -> Result;
+	ProcAllocateMemory                                                  :: #type proc "stdcall" (device: Device, pAllocateInfo: ^MemoryAllocateInfo, pAllocator: ^AllocationCallbacks, pMemory: ^DeviceMemory) -> Result;
+	ProcFreeMemory                                                      :: #type proc "stdcall" (device: Device, memory: DeviceMemory, pAllocator: ^AllocationCallbacks);
+	ProcMapMemory                                                       :: #type proc "stdcall" (device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, ppData: ^rawptr) -> Result;
+	ProcUnmapMemory                                                     :: #type proc "stdcall" (device: Device, memory: DeviceMemory);
+	ProcFlushMappedMemoryRanges                                         :: #type proc "stdcall" (device: Device, memoryRangeCount: u32, pMemoryRanges: ^MappedMemoryRange) -> Result;
+	ProcInvalidateMappedMemoryRanges                                    :: #type proc "stdcall" (device: Device, memoryRangeCount: u32, pMemoryRanges: ^MappedMemoryRange) -> Result;
+	ProcGetDeviceMemoryCommitment                                       :: #type proc "stdcall" (device: Device, memory: DeviceMemory, pCommittedMemoryInBytes: ^DeviceSize);
+	ProcBindBufferMemory                                                :: #type proc "stdcall" (device: Device, buffer: Buffer, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result;
+	ProcBindImageMemory                                                 :: #type proc "stdcall" (device: Device, image: Image, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result;
+	ProcGetBufferMemoryRequirements                                     :: #type proc "stdcall" (device: Device, buffer: Buffer, pMemoryRequirements: ^MemoryRequirements);
+	ProcGetImageMemoryRequirements                                      :: #type proc "stdcall" (device: Device, image: Image, pMemoryRequirements: ^MemoryRequirements);
+	ProcGetImageSparseMemoryRequirements                                :: #type proc "stdcall" (device: Device, image: Image, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements);
+	ProcGetPhysicalDeviceSparseImageFormatProperties                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties);
+	ProcQueueBindSparse                                                 :: #type proc "stdcall" (queue: Queue, bindInfoCount: u32, pBindInfo: ^BindSparseInfo, fence: Fence) -> Result;
+	ProcCreateFence                                                     :: #type proc "stdcall" (device: Device, pCreateInfo: ^FenceCreateInfo, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcDestroyFence                                                    :: #type proc "stdcall" (device: Device, fence: Fence, pAllocator: ^AllocationCallbacks);
+	ProcResetFences                                                     :: #type proc "stdcall" (device: Device, fenceCount: u32, pFences: ^Fence) -> Result;
+	ProcGetFenceStatus                                                  :: #type proc "stdcall" (device: Device, fence: Fence) -> Result;
+	ProcWaitForFences                                                   :: #type proc "stdcall" (device: Device, fenceCount: u32, pFences: ^Fence, waitAll: b32, timeout: u64) -> Result;
+	ProcCreateSemaphore                                                 :: #type proc "stdcall" (device: Device, pCreateInfo: ^SemaphoreCreateInfo, pAllocator: ^AllocationCallbacks, pSemaphore: ^Semaphore) -> Result;
+	ProcDestroySemaphore                                                :: #type proc "stdcall" (device: Device, semaphore: Semaphore, pAllocator: ^AllocationCallbacks);
+	ProcCreateEvent                                                     :: #type proc "stdcall" (device: Device, pCreateInfo: ^EventCreateInfo, pAllocator: ^AllocationCallbacks, pEvent: ^Event) -> Result;
+	ProcDestroyEvent                                                    :: #type proc "stdcall" (device: Device, event: Event, pAllocator: ^AllocationCallbacks);
+	ProcGetEventStatus                                                  :: #type proc "stdcall" (device: Device, event: Event) -> Result;
+	ProcSetEvent                                                        :: #type proc "stdcall" (device: Device, event: Event) -> Result;
+	ProcResetEvent                                                      :: #type proc "stdcall" (device: Device, event: Event) -> Result;
+	ProcCreateQueryPool                                                 :: #type proc "stdcall" (device: Device, pCreateInfo: ^QueryPoolCreateInfo, pAllocator: ^AllocationCallbacks, pQueryPool: ^QueryPool) -> Result;
+	ProcDestroyQueryPool                                                :: #type proc "stdcall" (device: Device, queryPool: QueryPool, pAllocator: ^AllocationCallbacks);
+	ProcGetQueryPoolResults                                             :: #type proc "stdcall" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dataSize: int, pData: rawptr, stride: DeviceSize, flags: QueryResultFlags) -> Result;
+	ProcCreateBuffer                                                    :: #type proc "stdcall" (device: Device, pCreateInfo: ^BufferCreateInfo, pAllocator: ^AllocationCallbacks, pBuffer: ^Buffer) -> Result;
+	ProcDestroyBuffer                                                   :: #type proc "stdcall" (device: Device, buffer: Buffer, pAllocator: ^AllocationCallbacks);
+	ProcCreateBufferView                                                :: #type proc "stdcall" (device: Device, pCreateInfo: ^BufferViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^BufferView) -> Result;
+	ProcDestroyBufferView                                               :: #type proc "stdcall" (device: Device, bufferView: BufferView, pAllocator: ^AllocationCallbacks);
+	ProcCreateImage                                                     :: #type proc "stdcall" (device: Device, pCreateInfo: ^ImageCreateInfo, pAllocator: ^AllocationCallbacks, pImage: ^Image) -> Result;
+	ProcDestroyImage                                                    :: #type proc "stdcall" (device: Device, image: Image, pAllocator: ^AllocationCallbacks);
+	ProcGetImageSubresourceLayout                                       :: #type proc "stdcall" (device: Device, image: Image, pSubresource: ^ImageSubresource, pLayout: ^SubresourceLayout);
+	ProcCreateImageView                                                 :: #type proc "stdcall" (device: Device, pCreateInfo: ^ImageViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^ImageView) -> Result;
+	ProcDestroyImageView                                                :: #type proc "stdcall" (device: Device, imageView: ImageView, pAllocator: ^AllocationCallbacks);
+	ProcCreateShaderModule                                              :: #type proc "stdcall" (device: Device, pCreateInfo: ^ShaderModuleCreateInfo, pAllocator: ^AllocationCallbacks, pShaderModule: ^ShaderModule) -> Result;
+	ProcDestroyShaderModule                                             :: #type proc "stdcall" (device: Device, shaderModule: ShaderModule, pAllocator: ^AllocationCallbacks);
+	ProcCreatePipelineCache                                             :: #type proc "stdcall" (device: Device, pCreateInfo: ^PipelineCacheCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineCache: ^PipelineCache) -> Result;
+	ProcDestroyPipelineCache                                            :: #type proc "stdcall" (device: Device, pipelineCache: PipelineCache, pAllocator: ^AllocationCallbacks);
+	ProcGetPipelineCacheData                                            :: #type proc "stdcall" (device: Device, pipelineCache: PipelineCache, pDataSize: ^int, pData: rawptr) -> Result;
+	ProcMergePipelineCaches                                             :: #type proc "stdcall" (device: Device, dstCache: PipelineCache, srcCacheCount: u32, pSrcCaches: ^PipelineCache) -> Result;
+	ProcCreateGraphicsPipelines                                         :: #type proc "stdcall" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^GraphicsPipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcCreateComputePipelines                                          :: #type proc "stdcall" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^ComputePipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcDestroyPipeline                                                 :: #type proc "stdcall" (device: Device, pipeline: Pipeline, pAllocator: ^AllocationCallbacks);
+	ProcCreatePipelineLayout                                            :: #type proc "stdcall" (device: Device, pCreateInfo: ^PipelineLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineLayout: ^PipelineLayout) -> Result;
+	ProcDestroyPipelineLayout                                           :: #type proc "stdcall" (device: Device, pipelineLayout: PipelineLayout, pAllocator: ^AllocationCallbacks);
+	ProcCreateSampler                                                   :: #type proc "stdcall" (device: Device, pCreateInfo: ^SamplerCreateInfo, pAllocator: ^AllocationCallbacks, pSampler: ^Sampler) -> Result;
+	ProcDestroySampler                                                  :: #type proc "stdcall" (device: Device, sampler: Sampler, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorSetLayout                                       :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pSetLayout: ^DescriptorSetLayout) -> Result;
+	ProcDestroyDescriptorSetLayout                                      :: #type proc "stdcall" (device: Device, descriptorSetLayout: DescriptorSetLayout, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorPool                                            :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorPoolCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorPool: ^DescriptorPool) -> Result;
+	ProcDestroyDescriptorPool                                           :: #type proc "stdcall" (device: Device, descriptorPool: DescriptorPool, pAllocator: ^AllocationCallbacks);
+	ProcResetDescriptorPool                                             :: #type proc "stdcall" (device: Device, descriptorPool: DescriptorPool, flags: DescriptorPoolResetFlags) -> Result;
+	ProcAllocateDescriptorSets                                          :: #type proc "stdcall" (device: Device, pAllocateInfo: ^DescriptorSetAllocateInfo, pDescriptorSets: ^DescriptorSet) -> Result;
+	ProcFreeDescriptorSets                                              :: #type proc "stdcall" (device: Device, descriptorPool: DescriptorPool, descriptorSetCount: u32, pDescriptorSets: ^DescriptorSet) -> Result;
+	ProcUpdateDescriptorSets                                            :: #type proc "stdcall" (device: Device, descriptorWriteCount: u32, pDescriptorWrites: ^WriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: ^CopyDescriptorSet);
+	ProcCreateFramebuffer                                               :: #type proc "stdcall" (device: Device, pCreateInfo: ^FramebufferCreateInfo, pAllocator: ^AllocationCallbacks, pFramebuffer: ^Framebuffer) -> Result;
+	ProcDestroyFramebuffer                                              :: #type proc "stdcall" (device: Device, framebuffer: Framebuffer, pAllocator: ^AllocationCallbacks);
+	ProcCreateRenderPass                                                :: #type proc "stdcall" (device: Device, pCreateInfo: ^RenderPassCreateInfo, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcDestroyRenderPass                                               :: #type proc "stdcall" (device: Device, renderPass: RenderPass, pAllocator: ^AllocationCallbacks);
+	ProcGetRenderAreaGranularity                                        :: #type proc "stdcall" (device: Device, renderPass: RenderPass, pGranularity: ^Extent2D);
+	ProcCreateCommandPool                                               :: #type proc "stdcall" (device: Device, pCreateInfo: ^CommandPoolCreateInfo, pAllocator: ^AllocationCallbacks, pCommandPool: ^CommandPool) -> Result;
+	ProcDestroyCommandPool                                              :: #type proc "stdcall" (device: Device, commandPool: CommandPool, pAllocator: ^AllocationCallbacks);
+	ProcResetCommandPool                                                :: #type proc "stdcall" (device: Device, commandPool: CommandPool, flags: CommandPoolResetFlags) -> Result;
+	ProcAllocateCommandBuffers                                          :: #type proc "stdcall" (device: Device, pAllocateInfo: ^CommandBufferAllocateInfo, pCommandBuffers: ^CommandBuffer) -> Result;
+	ProcFreeCommandBuffers                                              :: #type proc "stdcall" (device: Device, commandPool: CommandPool, commandBufferCount: u32, pCommandBuffers: ^CommandBuffer);
+	ProcBeginCommandBuffer                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, pBeginInfo: ^CommandBufferBeginInfo) -> Result;
+	ProcEndCommandBuffer                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer) -> Result;
+	ProcResetCommandBuffer                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result;
+	ProcCmdBindPipeline                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline);
+	ProcCmdSetViewport                                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: ^Viewport);
+	ProcCmdSetScissor                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: ^Rect2D);
+	ProcCmdSetLineWidth                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, lineWidth: f32);
+	ProcCmdSetDepthBias                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
+	ProcCmdSetBlendConstants                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdSetDepthBounds                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
+	ProcCmdSetStencilCompareMask                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, compareMask: u32);
+	ProcCmdSetStencilWriteMask                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, writeMask: u32);
+	ProcCmdSetStencilReference                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, reference: u32);
+	ProcCmdBindDescriptorSets                                           :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: ^DescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: ^u32);
+	ProcCmdBindIndexBuffer                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, indexType: IndexType);
+	ProcCmdBindVertexBuffers                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize);
+	ProcCmdDraw                                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
+	ProcCmdDrawIndexed                                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
+	ProcCmdDrawIndirect                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirect                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDispatch                                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcCmdDispatchIndirect                                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
+	ProcCmdCopyBuffer                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstBuffer: Buffer, regionCount: u32, pRegions: ^BufferCopy);
+	ProcCmdCopyImage                                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageCopy);
+	ProcCmdBlitImage                                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageBlit, filter: Filter);
+	ProcCmdCopyBufferToImage                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^BufferImageCopy);
+	ProcCmdCopyImageToBuffer                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstBuffer: Buffer, regionCount: u32, pRegions: ^BufferImageCopy);
+	ProcCmdUpdateBuffer                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, dataSize: DeviceSize, pData: rawptr);
+	ProcCmdFillBuffer                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, size: DeviceSize, data: u32);
+	ProcCmdClearColorImage                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: ^ClearColorValue, rangeCount: u32, pRanges: ^ImageSubresourceRange);
+	ProcCmdClearDepthStencilImage                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: ^ClearDepthStencilValue, rangeCount: u32, pRanges: ^ImageSubresourceRange);
+	ProcCmdClearAttachments                                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: ^ClearAttachment, rectCount: u32, pRects: ^ClearRect);
+	ProcCmdResolveImage                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageResolve);
+	ProcCmdSetEvent                                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags);
+	ProcCmdResetEvent                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags);
+	ProcCmdWaitEvents                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: ^Event, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: ^MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: ^BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: ^ImageMemoryBarrier);
+	ProcCmdPipelineBarrier                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, dependencyFlags: DependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: ^MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: ^BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: ^ImageMemoryBarrier);
+	ProcCmdBeginQuery                                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags);
+	ProcCmdEndQuery                                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32);
+	ProcCmdResetQueryPool                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcCmdWriteTimestamp                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, queryPool: QueryPool, query: u32);
+	ProcCmdCopyQueryPoolResults                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dstBuffer: Buffer, dstOffset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags);
+	ProcCmdPushConstants                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, layout: PipelineLayout, stageFlags: ShaderStageFlags, offset: u32, size: u32, pValues: rawptr);
+	ProcCmdBeginRenderPass                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, contents: SubpassContents);
+	ProcCmdNextSubpass                                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, contents: SubpassContents);
+	ProcCmdEndRenderPass                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdExecuteCommands                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, commandBufferCount: u32, pCommandBuffers: ^CommandBuffer);
+	ProcEnumerateInstanceVersion                                        :: #type proc "stdcall" (pApiVersion: ^u32) -> Result;
+	ProcBindBufferMemory2                                               :: #type proc "stdcall" (device: Device, bindInfoCount: u32, pBindInfos: ^BindBufferMemoryInfo) -> Result;
+	ProcBindImageMemory2                                                :: #type proc "stdcall" (device: Device, bindInfoCount: u32, pBindInfos: ^BindImageMemoryInfo) -> Result;
+	ProcGetDeviceGroupPeerMemoryFeatures                                :: #type proc "stdcall" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: ^PeerMemoryFeatureFlags);
+	ProcCmdSetDeviceMask                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, deviceMask: u32);
+	ProcCmdDispatchBase                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcEnumeratePhysicalDeviceGroups                                   :: #type proc "stdcall" (instance: Instance, pPhysicalDeviceGroupCount: ^u32, pPhysicalDeviceGroupProperties: ^PhysicalDeviceGroupProperties) -> Result;
+	ProcGetImageMemoryRequirements2                                     :: #type proc "stdcall" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetBufferMemoryRequirements2                                    :: #type proc "stdcall" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetImageSparseMemoryRequirements2                               :: #type proc "stdcall" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements2);
+	ProcGetPhysicalDeviceFeatures2                                      :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures2);
+	ProcGetPhysicalDeviceProperties2                                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties2);
+	ProcGetPhysicalDeviceFormatProperties2                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties2);
+	ProcGetPhysicalDeviceImageFormatProperties2                         :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pImageFormatInfo: ^PhysicalDeviceImageFormatInfo2, pImageFormatProperties: ^ImageFormatProperties2) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyProperties2                         :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties2);
+	ProcGetPhysicalDeviceMemoryProperties2                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties2);
+	ProcGetPhysicalDeviceSparseImageFormatProperties2                   :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFormatInfo: ^PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties2);
+	ProcTrimCommandPool                                                 :: #type proc "stdcall" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags);
+	ProcGetDeviceQueue2                                                 :: #type proc "stdcall" (device: Device, pQueueInfo: ^DeviceQueueInfo2, pQueue: ^Queue);
+	ProcCreateSamplerYcbcrConversion                                    :: #type proc "stdcall" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result;
+	ProcDestroySamplerYcbcrConversion                                   :: #type proc "stdcall" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorUpdateTemplate                                  :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result;
+	ProcDestroyDescriptorUpdateTemplate                                 :: #type proc "stdcall" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks);
+	ProcUpdateDescriptorSetWithTemplate                                 :: #type proc "stdcall" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr);
+	ProcGetPhysicalDeviceExternalBufferProperties                       :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalBufferInfo: ^PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ^ExternalBufferProperties);
+	ProcGetPhysicalDeviceExternalFenceProperties                        :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalFenceInfo: ^PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ^ExternalFenceProperties);
+	ProcGetPhysicalDeviceExternalSemaphoreProperties                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: ^PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ^ExternalSemaphoreProperties);
+	ProcGetDescriptorSetLayoutSupport                                   :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport);
+	ProcCmdDrawIndirectCount                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCount                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCreateRenderPass2                                               :: #type proc "stdcall" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcCmdBeginRenderPass2                                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo);
+	ProcCmdNextSubpass2                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcCmdEndRenderPass2                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcResetQueryPool                                                  :: #type proc "stdcall" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcGetSemaphoreCounterValue                                        :: #type proc "stdcall" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result;
+	ProcWaitSemaphores                                                  :: #type proc "stdcall" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result;
+	ProcSignalSemaphore                                                 :: #type proc "stdcall" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result;
+	ProcGetBufferDeviceAddress                                          :: #type proc "stdcall" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetBufferOpaqueCaptureAddress                                   :: #type proc "stdcall" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64;
+	ProcGetDeviceMemoryOpaqueCaptureAddress                             :: #type proc "stdcall" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64;
+	ProcDestroySurfaceKHR                                               :: #type proc "stdcall" (instance: Instance, surface: SurfaceKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetPhysicalDeviceSurfaceSupportKHR                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, surface: SurfaceKHR, pSupported: ^b32) -> Result;
+	ProcGetPhysicalDeviceSurfaceCapabilitiesKHR                         :: #type proc "stdcall" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: ^SurfaceCapabilitiesKHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceFormatsKHR                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceFormatCount: ^u32, pSurfaceFormats: ^SurfaceFormatKHR) -> Result;
+	ProcGetPhysicalDeviceSurfacePresentModesKHR                         :: #type proc "stdcall" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pPresentModeCount: ^u32, pPresentModes: ^PresentModeKHR) -> Result;
+	ProcCreateSwapchainKHR                                              :: #type proc "stdcall" (device: Device, pCreateInfo: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchain: ^SwapchainKHR) -> Result;
+	ProcDestroySwapchainKHR                                             :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetSwapchainImagesKHR                                           :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, pSwapchainImageCount: ^u32, pSwapchainImages: ^Image) -> Result;
+	ProcAcquireNextImageKHR                                             :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, timeout: u64, semaphore: Semaphore, fence: Fence, pImageIndex: ^u32) -> Result;
+	ProcQueuePresentKHR                                                 :: #type proc "stdcall" (queue: Queue, pPresentInfo: ^PresentInfoKHR) -> Result;
+	ProcGetDeviceGroupPresentCapabilitiesKHR                            :: #type proc "stdcall" (device: Device, pDeviceGroupPresentCapabilities: ^DeviceGroupPresentCapabilitiesKHR) -> Result;
+	ProcGetDeviceGroupSurfacePresentModesKHR                            :: #type proc "stdcall" (device: Device, surface: SurfaceKHR, pModes: ^DeviceGroupPresentModeFlagsKHR) -> Result;
+	ProcGetPhysicalDevicePresentRectanglesKHR                           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pRectCount: ^u32, pRects: ^Rect2D) -> Result;
+	ProcAcquireNextImage2KHR                                            :: #type proc "stdcall" (device: Device, pAcquireInfo: ^AcquireNextImageInfoKHR, pImageIndex: ^u32) -> Result;
+	ProcGetPhysicalDeviceDisplayPropertiesKHR                           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPropertiesKHR) -> Result;
+	ProcGetPhysicalDeviceDisplayPlanePropertiesKHR                      :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPlanePropertiesKHR) -> Result;
+	ProcGetDisplayPlaneSupportedDisplaysKHR                             :: #type proc "stdcall" (physicalDevice: PhysicalDevice, planeIndex: u32, pDisplayCount: ^u32, pDisplays: ^DisplayKHR) -> Result;
+	ProcGetDisplayModePropertiesKHR                                     :: #type proc "stdcall" (physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: ^u32, pProperties: ^DisplayModePropertiesKHR) -> Result;
+	ProcCreateDisplayModeKHR                                            :: #type proc "stdcall" (physicalDevice: PhysicalDevice, display: DisplayKHR, pCreateInfo: ^DisplayModeCreateInfoKHR, pAllocator: ^AllocationCallbacks, pMode: ^DisplayModeKHR) -> Result;
+	ProcGetDisplayPlaneCapabilitiesKHR                                  :: #type proc "stdcall" (physicalDevice: PhysicalDevice, mode: DisplayModeKHR, planeIndex: u32, pCapabilities: ^DisplayPlaneCapabilitiesKHR) -> Result;
+	ProcCreateDisplayPlaneSurfaceKHR                                    :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^DisplaySurfaceCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateSharedSwapchainsKHR                                       :: #type proc "stdcall" (device: Device, swapchainCount: u32, pCreateInfos: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchains: ^SwapchainKHR) -> Result;
+	ProcGetPhysicalDeviceFeatures2KHR                                   :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures2);
+	ProcGetPhysicalDeviceProperties2KHR                                 :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties2);
+	ProcGetPhysicalDeviceFormatProperties2KHR                           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties2);
+	ProcGetPhysicalDeviceImageFormatProperties2KHR                      :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pImageFormatInfo: ^PhysicalDeviceImageFormatInfo2, pImageFormatProperties: ^ImageFormatProperties2) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyProperties2KHR                      :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties2);
+	ProcGetPhysicalDeviceMemoryProperties2KHR                           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties2);
+	ProcGetPhysicalDeviceSparseImageFormatProperties2KHR                :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFormatInfo: ^PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties2);
+	ProcGetDeviceGroupPeerMemoryFeaturesKHR                             :: #type proc "stdcall" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: ^PeerMemoryFeatureFlags);
+	ProcCmdSetDeviceMaskKHR                                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, deviceMask: u32);
+	ProcCmdDispatchBaseKHR                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcTrimCommandPoolKHR                                              :: #type proc "stdcall" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags);
+	ProcEnumeratePhysicalDeviceGroupsKHR                                :: #type proc "stdcall" (instance: Instance, pPhysicalDeviceGroupCount: ^u32, pPhysicalDeviceGroupProperties: ^PhysicalDeviceGroupProperties) -> Result;
+	ProcGetPhysicalDeviceExternalBufferPropertiesKHR                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalBufferInfo: ^PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ^ExternalBufferProperties);
+	ProcGetMemoryFdKHR                                                  :: #type proc "stdcall" (device: Device, pGetFdInfo: ^MemoryGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcGetMemoryFdPropertiesKHR                                        :: #type proc "stdcall" (device: Device, handleType: ExternalMemoryHandleTypeFlags, fd: c.int, pMemoryFdProperties: ^MemoryFdPropertiesKHR) -> Result;
+	ProcGetPhysicalDeviceExternalSemaphorePropertiesKHR                 :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: ^PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ^ExternalSemaphoreProperties);
+	ProcImportSemaphoreFdKHR                                            :: #type proc "stdcall" (device: Device, pImportSemaphoreFdInfo: ^ImportSemaphoreFdInfoKHR) -> Result;
+	ProcGetSemaphoreFdKHR                                               :: #type proc "stdcall" (device: Device, pGetFdInfo: ^SemaphoreGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcCmdPushDescriptorSetKHR                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: ^WriteDescriptorSet);
+	ProcCmdPushDescriptorSetWithTemplateKHR                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, descriptorUpdateTemplate: DescriptorUpdateTemplate, layout: PipelineLayout, set: u32, pData: rawptr);
+	ProcCreateDescriptorUpdateTemplateKHR                               :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result;
+	ProcDestroyDescriptorUpdateTemplateKHR                              :: #type proc "stdcall" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks);
+	ProcUpdateDescriptorSetWithTemplateKHR                              :: #type proc "stdcall" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr);
+	ProcCreateRenderPass2KHR                                            :: #type proc "stdcall" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcCmdBeginRenderPass2KHR                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo);
+	ProcCmdNextSubpass2KHR                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcCmdEndRenderPass2KHR                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcGetSwapchainStatusKHR                                           :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcGetPhysicalDeviceExternalFencePropertiesKHR                     :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pExternalFenceInfo: ^PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ^ExternalFenceProperties);
+	ProcImportFenceFdKHR                                                :: #type proc "stdcall" (device: Device, pImportFenceFdInfo: ^ImportFenceFdInfoKHR) -> Result;
+	ProcGetFenceFdKHR                                                   :: #type proc "stdcall" (device: Device, pGetFdInfo: ^FenceGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR   :: #type proc "stdcall" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, pCounterCount: ^u32, pCounters: ^PerformanceCounterKHR, pCounterDescriptions: ^PerformanceCounterDescriptionKHR) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPerformanceQueryCreateInfo: ^QueryPoolPerformanceCreateInfoKHR, pNumPasses: ^u32);
+	ProcAcquireProfilingLockKHR                                         :: #type proc "stdcall" (device: Device, pInfo: ^AcquireProfilingLockInfoKHR) -> Result;
+	ProcReleaseProfilingLockKHR                                         :: #type proc "stdcall" (device: Device);
+	ProcGetPhysicalDeviceSurfaceCapabilities2KHR                        :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ^SurfaceCapabilities2KHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceFormats2KHR                             :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ^u32, pSurfaceFormats: ^SurfaceFormat2KHR) -> Result;
+	ProcGetPhysicalDeviceDisplayProperties2KHR                          :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayProperties2KHR) -> Result;
+	ProcGetPhysicalDeviceDisplayPlaneProperties2KHR                     :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPlaneProperties2KHR) -> Result;
+	ProcGetDisplayModeProperties2KHR                                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: ^u32, pProperties: ^DisplayModeProperties2KHR) -> Result;
+	ProcGetDisplayPlaneCapabilities2KHR                                 :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pDisplayPlaneInfo: ^DisplayPlaneInfo2KHR, pCapabilities: ^DisplayPlaneCapabilities2KHR) -> Result;
+	ProcGetImageMemoryRequirements2KHR                                  :: #type proc "stdcall" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetBufferMemoryRequirements2KHR                                 :: #type proc "stdcall" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetImageSparseMemoryRequirements2KHR                            :: #type proc "stdcall" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements2);
+	ProcCreateSamplerYcbcrConversionKHR                                 :: #type proc "stdcall" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result;
+	ProcDestroySamplerYcbcrConversionKHR                                :: #type proc "stdcall" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks);
+	ProcBindBufferMemory2KHR                                            :: #type proc "stdcall" (device: Device, bindInfoCount: u32, pBindInfos: ^BindBufferMemoryInfo) -> Result;
+	ProcBindImageMemory2KHR                                             :: #type proc "stdcall" (device: Device, bindInfoCount: u32, pBindInfos: ^BindImageMemoryInfo) -> Result;
+	ProcGetDescriptorSetLayoutSupportKHR                                :: #type proc "stdcall" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport);
+	ProcCmdDrawIndirectCountKHR                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCountKHR                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcGetSemaphoreCounterValueKHR                                     :: #type proc "stdcall" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result;
+	ProcWaitSemaphoresKHR                                               :: #type proc "stdcall" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result;
+	ProcSignalSemaphoreKHR                                              :: #type proc "stdcall" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result;
+	ProcGetPhysicalDeviceFragmentShadingRatesKHR                        :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pFragmentShadingRateCount: ^u32, pFragmentShadingRates: ^PhysicalDeviceFragmentShadingRateKHR) -> Result;
+	ProcCmdSetFragmentShadingRateKHR                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, pFragmentSize: ^Extent2D);
+	ProcWaitForPresentKHR                                               :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, presentId: u64, timeout: u64) -> Result;
+	ProcGetBufferDeviceAddressKHR                                       :: #type proc "stdcall" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetBufferOpaqueCaptureAddressKHR                                :: #type proc "stdcall" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64;
+	ProcGetDeviceMemoryOpaqueCaptureAddressKHR                          :: #type proc "stdcall" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64;
+	ProcCreateDeferredOperationKHR                                      :: #type proc "stdcall" (device: Device, pAllocator: ^AllocationCallbacks, pDeferredOperation: ^DeferredOperationKHR) -> Result;
+	ProcDestroyDeferredOperationKHR                                     :: #type proc "stdcall" (device: Device, operation: DeferredOperationKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetDeferredOperationMaxConcurrencyKHR                           :: #type proc "stdcall" (device: Device, operation: DeferredOperationKHR) -> u32;
+	ProcGetDeferredOperationResultKHR                                   :: #type proc "stdcall" (device: Device, operation: DeferredOperationKHR) -> Result;
+	ProcDeferredOperationJoinKHR                                        :: #type proc "stdcall" (device: Device, operation: DeferredOperationKHR) -> Result;
+	ProcGetPipelineExecutablePropertiesKHR                              :: #type proc "stdcall" (device: Device, pPipelineInfo: ^PipelineInfoKHR, pExecutableCount: ^u32, pProperties: ^PipelineExecutablePropertiesKHR) -> Result;
+	ProcGetPipelineExecutableStatisticsKHR                              :: #type proc "stdcall" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pStatisticCount: ^u32, pStatistics: ^PipelineExecutableStatisticKHR) -> Result;
+	ProcGetPipelineExecutableInternalRepresentationsKHR                 :: #type proc "stdcall" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pInternalRepresentationCount: ^u32, pInternalRepresentations: ^PipelineExecutableInternalRepresentationKHR) -> Result;
+	ProcCmdSetEvent2KHR                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfoKHR);
+	ProcCmdResetEvent2KHR                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2KHR);
+	ProcCmdWaitEvents2KHR                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: ^Event, pDependencyInfos: ^DependencyInfoKHR);
+	ProcCmdPipelineBarrier2KHR                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfoKHR);
+	ProcCmdWriteTimestamp2KHR                                           :: #type proc "stdcall" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2KHR, queryPool: QueryPool, query: u32);
+	ProcQueueSubmit2KHR                                                 :: #type proc "stdcall" (queue: Queue, submitCount: u32, pSubmits: ^SubmitInfo2KHR, fence: Fence) -> Result;
+	ProcCmdWriteBufferMarker2AMD                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2KHR, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32);
+	ProcGetQueueCheckpointData2NV                                       :: #type proc "stdcall" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointData2NV);
+	ProcCmdCopyBuffer2KHR                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2KHR);
+	ProcCmdCopyImage2KHR                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2KHR);
+	ProcCmdCopyBufferToImage2KHR                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2KHR);
+	ProcCmdCopyImageToBuffer2KHR                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2KHR);
+	ProcCmdBlitImage2KHR                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2KHR);
+	ProcCmdResolveImage2KHR                                             :: #type proc "stdcall" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2KHR);
+	ProcDebugReportCallbackEXT                                          :: #type proc "stdcall" (flags: DebugReportFlagsEXT, objectType: DebugReportObjectTypeEXT, object: u64, location: int, messageCode: i32, pLayerPrefix: cstring, pMessage: cstring, pUserData: rawptr) -> b32;
+	ProcCreateDebugReportCallbackEXT                                    :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^DebugReportCallbackCreateInfoEXT, pAllocator: ^AllocationCallbacks, pCallback: ^DebugReportCallbackEXT) -> Result;
+	ProcDestroyDebugReportCallbackEXT                                   :: #type proc "stdcall" (instance: Instance, callback: DebugReportCallbackEXT, pAllocator: ^AllocationCallbacks);
+	ProcDebugReportMessageEXT                                           :: #type proc "stdcall" (instance: Instance, flags: DebugReportFlagsEXT, objectType: DebugReportObjectTypeEXT, object: u64, location: int, messageCode: i32, pLayerPrefix: cstring, pMessage: cstring);
+	ProcDebugMarkerSetObjectTagEXT                                      :: #type proc "stdcall" (device: Device, pTagInfo: ^DebugMarkerObjectTagInfoEXT) -> Result;
+	ProcDebugMarkerSetObjectNameEXT                                     :: #type proc "stdcall" (device: Device, pNameInfo: ^DebugMarkerObjectNameInfoEXT) -> Result;
+	ProcCmdDebugMarkerBeginEXT                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT);
+	ProcCmdDebugMarkerEndEXT                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdDebugMarkerInsertEXT                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT);
+	ProcCmdBindTransformFeedbackBuffersEXT                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize, pSizes: ^DeviceSize);
+	ProcCmdBeginTransformFeedbackEXT                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: ^Buffer, pCounterBufferOffsets: ^DeviceSize);
+	ProcCmdEndTransformFeedbackEXT                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: ^Buffer, pCounterBufferOffsets: ^DeviceSize);
+	ProcCmdBeginQueryIndexedEXT                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags, index: u32);
+	ProcCmdEndQueryIndexedEXT                                           :: #type proc "stdcall" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, index: u32);
+	ProcCmdDrawIndirectByteCountEXT                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: Buffer, counterBufferOffset: DeviceSize, counterOffset: u32, vertexStride: u32);
+	ProcCreateCuModuleNVX                                               :: #type proc "stdcall" (device: Device, pCreateInfo: ^CuModuleCreateInfoNVX, pAllocator: ^AllocationCallbacks, pModule: ^CuModuleNVX) -> Result;
+	ProcCreateCuFunctionNVX                                             :: #type proc "stdcall" (device: Device, pCreateInfo: ^CuFunctionCreateInfoNVX, pAllocator: ^AllocationCallbacks, pFunction: ^CuFunctionNVX) -> Result;
+	ProcDestroyCuModuleNVX                                              :: #type proc "stdcall" (device: Device, module: CuModuleNVX, pAllocator: ^AllocationCallbacks);
+	ProcDestroyCuFunctionNVX                                            :: #type proc "stdcall" (device: Device, function: CuFunctionNVX, pAllocator: ^AllocationCallbacks);
+	ProcCmdCuLaunchKernelNVX                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, pLaunchInfo: ^CuLaunchInfoNVX);
+	ProcGetImageViewHandleNVX                                           :: #type proc "stdcall" (device: Device, pInfo: ^ImageViewHandleInfoNVX) -> u32;
+	ProcGetImageViewAddressNVX                                          :: #type proc "stdcall" (device: Device, imageView: ImageView, pProperties: ^ImageViewAddressPropertiesNVX) -> Result;
+	ProcCmdDrawIndirectCountAMD                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCountAMD                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcGetShaderInfoAMD                                                :: #type proc "stdcall" (device: Device, pipeline: Pipeline, shaderStage: ShaderStageFlags, infoType: ShaderInfoTypeAMD, pInfoSize: ^int, pInfo: rawptr) -> Result;
+	ProcGetPhysicalDeviceExternalImageFormatPropertiesNV                :: #type proc "stdcall" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, externalHandleType: ExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ^ExternalImageFormatPropertiesNV) -> Result;
+	ProcCmdBeginConditionalRenderingEXT                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pConditionalRenderingBegin: ^ConditionalRenderingBeginInfoEXT);
+	ProcCmdEndConditionalRenderingEXT                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdSetViewportWScalingNV                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: ^ViewportWScalingNV);
+	ProcReleaseDisplayEXT                                               :: #type proc "stdcall" (physicalDevice: PhysicalDevice, display: DisplayKHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceCapabilities2EXT                        :: #type proc "stdcall" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: ^SurfaceCapabilities2EXT) -> Result;
+	ProcDisplayPowerControlEXT                                          :: #type proc "stdcall" (device: Device, display: DisplayKHR, pDisplayPowerInfo: ^DisplayPowerInfoEXT) -> Result;
+	ProcRegisterDeviceEventEXT                                          :: #type proc "stdcall" (device: Device, pDeviceEventInfo: ^DeviceEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcRegisterDisplayEventEXT                                         :: #type proc "stdcall" (device: Device, display: DisplayKHR, pDisplayEventInfo: ^DisplayEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcGetSwapchainCounterEXT                                          :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, pCounterValue: ^u64) -> Result;
+	ProcGetRefreshCycleDurationGOOGLE                                   :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, pDisplayTimingProperties: ^RefreshCycleDurationGOOGLE) -> Result;
+	ProcGetPastPresentationTimingGOOGLE                                 :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: ^u32, pPresentationTimings: ^PastPresentationTimingGOOGLE) -> Result;
+	ProcCmdSetDiscardRectangleEXT                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: ^Rect2D);
+	ProcSetHdrMetadataEXT                                               :: #type proc "stdcall" (device: Device, swapchainCount: u32, pSwapchains: ^SwapchainKHR, pMetadata: ^HdrMetadataEXT);
+	ProcDebugUtilsMessengerCallbackEXT                                  :: #type proc "stdcall" (messageSeverity: DebugUtilsMessageSeverityFlagsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: ^DebugUtilsMessengerCallbackDataEXT, pUserData: rawptr) -> b32;
+	ProcSetDebugUtilsObjectNameEXT                                      :: #type proc "stdcall" (device: Device, pNameInfo: ^DebugUtilsObjectNameInfoEXT) -> Result;
+	ProcSetDebugUtilsObjectTagEXT                                       :: #type proc "stdcall" (device: Device, pTagInfo: ^DebugUtilsObjectTagInfoEXT) -> Result;
+	ProcQueueBeginDebugUtilsLabelEXT                                    :: #type proc "stdcall" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcQueueEndDebugUtilsLabelEXT                                      :: #type proc "stdcall" (queue: Queue);
+	ProcQueueInsertDebugUtilsLabelEXT                                   :: #type proc "stdcall" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCmdBeginDebugUtilsLabelEXT                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCmdEndDebugUtilsLabelEXT                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdInsertDebugUtilsLabelEXT                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCreateDebugUtilsMessengerEXT                                    :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^DebugUtilsMessengerCreateInfoEXT, pAllocator: ^AllocationCallbacks, pMessenger: ^DebugUtilsMessengerEXT) -> Result;
+	ProcDestroyDebugUtilsMessengerEXT                                   :: #type proc "stdcall" (instance: Instance, messenger: DebugUtilsMessengerEXT, pAllocator: ^AllocationCallbacks);
+	ProcSubmitDebugUtilsMessageEXT                                      :: #type proc "stdcall" (instance: Instance, messageSeverity: DebugUtilsMessageSeverityFlagsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: ^DebugUtilsMessengerCallbackDataEXT);
+	ProcCmdSetSampleLocationsEXT                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, pSampleLocationsInfo: ^SampleLocationsInfoEXT);
+	ProcGetPhysicalDeviceMultisamplePropertiesEXT                       :: #type proc "stdcall" (physicalDevice: PhysicalDevice, samples: SampleCountFlags, pMultisampleProperties: ^MultisamplePropertiesEXT);
+	ProcGetImageDrmFormatModifierPropertiesEXT                          :: #type proc "stdcall" (device: Device, image: Image, pProperties: ^ImageDrmFormatModifierPropertiesEXT) -> Result;
+	ProcCreateValidationCacheEXT                                        :: #type proc "stdcall" (device: Device, pCreateInfo: ^ValidationCacheCreateInfoEXT, pAllocator: ^AllocationCallbacks, pValidationCache: ^ValidationCacheEXT) -> Result;
+	ProcDestroyValidationCacheEXT                                       :: #type proc "stdcall" (device: Device, validationCache: ValidationCacheEXT, pAllocator: ^AllocationCallbacks);
+	ProcMergeValidationCachesEXT                                        :: #type proc "stdcall" (device: Device, dstCache: ValidationCacheEXT, srcCacheCount: u32, pSrcCaches: ^ValidationCacheEXT) -> Result;
+	ProcGetValidationCacheDataEXT                                       :: #type proc "stdcall" (device: Device, validationCache: ValidationCacheEXT, pDataSize: ^int, pData: rawptr) -> Result;
+	ProcCmdBindShadingRateImageNV                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout);
+	ProcCmdSetViewportShadingRatePaletteNV                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: ^ShadingRatePaletteNV);
+	ProcCmdSetCoarseSampleOrderNV                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, sampleOrderType: CoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: ^CoarseSampleOrderCustomNV);
+	ProcCreateAccelerationStructureNV                                   :: #type proc "stdcall" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoNV, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureNV) -> Result;
+	ProcDestroyAccelerationStructureNV                                  :: #type proc "stdcall" (device: Device, accelerationStructure: AccelerationStructureNV, pAllocator: ^AllocationCallbacks);
+	ProcGetAccelerationStructureMemoryRequirementsNV                    :: #type proc "stdcall" (device: Device, pInfo: ^AccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ^MemoryRequirements2KHR);
+	ProcBindAccelerationStructureMemoryNV                               :: #type proc "stdcall" (device: Device, bindInfoCount: u32, pBindInfos: ^BindAccelerationStructureMemoryInfoNV) -> Result;
+	ProcCmdBuildAccelerationStructureNV                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pInfo: ^AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: b32, dst: AccelerationStructureNV, src: AccelerationStructureNV, scratch: Buffer, scratchOffset: DeviceSize);
+	ProcCmdCopyAccelerationStructureNV                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, dst: AccelerationStructureNV, src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR);
+	ProcCmdTraceRaysNV                                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, raygenShaderBindingTableBuffer: Buffer, raygenShaderBindingOffset: DeviceSize, missShaderBindingTableBuffer: Buffer, missShaderBindingOffset: DeviceSize, missShaderBindingStride: DeviceSize, hitShaderBindingTableBuffer: Buffer, hitShaderBindingOffset: DeviceSize, hitShaderBindingStride: DeviceSize, callableShaderBindingTableBuffer: Buffer, callableShaderBindingOffset: DeviceSize, callableShaderBindingStride: DeviceSize, width: u32, height: u32, depth: u32);
+	ProcCreateRayTracingPipelinesNV                                     :: #type proc "stdcall" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^RayTracingPipelineCreateInfoNV, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcGetRayTracingShaderGroupHandlesKHR                              :: #type proc "stdcall" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcGetRayTracingShaderGroupHandlesNV                               :: #type proc "stdcall" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcGetAccelerationStructureHandleNV                                :: #type proc "stdcall" (device: Device, accelerationStructure: AccelerationStructureNV, dataSize: int, pData: rawptr) -> Result;
+	ProcCmdWriteAccelerationStructuresPropertiesNV                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureNV, queryType: QueryType, queryPool: QueryPool, firstQuery: u32);
+	ProcCompileDeferredNV                                               :: #type proc "stdcall" (device: Device, pipeline: Pipeline, shader: u32) -> Result;
+	ProcGetMemoryHostPointerPropertiesEXT                               :: #type proc "stdcall" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHostPointer: rawptr, pMemoryHostPointerProperties: ^MemoryHostPointerPropertiesEXT) -> Result;
+	ProcCmdWriteBufferMarkerAMD                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32);
+	ProcGetPhysicalDeviceCalibrateableTimeDomainsEXT                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pTimeDomainCount: ^u32, pTimeDomains: ^TimeDomainEXT) -> Result;
+	ProcGetCalibratedTimestampsEXT                                      :: #type proc "stdcall" (device: Device, timestampCount: u32, pTimestampInfos: ^CalibratedTimestampInfoEXT, pTimestamps: ^u64, pMaxDeviation: ^u64) -> Result;
+	ProcCmdDrawMeshTasksNV                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, taskCount: u32, firstTask: u32);
+	ProcCmdDrawMeshTasksIndirectNV                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDrawMeshTasksIndirectCountNV                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdSetExclusiveScissorNV                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: ^Rect2D);
+	ProcCmdSetCheckpointNV                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, pCheckpointMarker: rawptr);
+	ProcGetQueueCheckpointDataNV                                        :: #type proc "stdcall" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointDataNV);
+	ProcInitializePerformanceApiINTEL                                   :: #type proc "stdcall" (device: Device, pInitializeInfo: ^InitializePerformanceApiInfoINTEL) -> Result;
+	ProcUninitializePerformanceApiINTEL                                 :: #type proc "stdcall" (device: Device);
+	ProcCmdSetPerformanceMarkerINTEL                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceMarkerInfoINTEL) -> Result;
+	ProcCmdSetPerformanceStreamMarkerINTEL                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceStreamMarkerInfoINTEL) -> Result;
+	ProcCmdSetPerformanceOverrideINTEL                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, pOverrideInfo: ^PerformanceOverrideInfoINTEL) -> Result;
+	ProcAcquirePerformanceConfigurationINTEL                            :: #type proc "stdcall" (device: Device, pAcquireInfo: ^PerformanceConfigurationAcquireInfoINTEL, pConfiguration: ^PerformanceConfigurationINTEL) -> Result;
+	ProcReleasePerformanceConfigurationINTEL                            :: #type proc "stdcall" (device: Device, configuration: PerformanceConfigurationINTEL) -> Result;
+	ProcQueueSetPerformanceConfigurationINTEL                           :: #type proc "stdcall" (queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result;
+	ProcGetPerformanceParameterINTEL                                    :: #type proc "stdcall" (device: Device, parameter: PerformanceParameterTypeINTEL, pValue: ^PerformanceValueINTEL) -> Result;
+	ProcSetLocalDimmingAMD                                              :: #type proc "stdcall" (device: Device, swapChain: SwapchainKHR, localDimmingEnable: b32);
+	ProcGetBufferDeviceAddressEXT                                       :: #type proc "stdcall" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetPhysicalDeviceToolPropertiesEXT                              :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pToolCount: ^u32, pToolProperties: ^PhysicalDeviceToolPropertiesEXT) -> Result;
+	ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV                  :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^CooperativeMatrixPropertiesNV) -> Result;
+	ProcGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pCombinationCount: ^u32, pCombinations: ^FramebufferMixedSamplesCombinationNV) -> Result;
+	ProcCreateHeadlessSurfaceEXT                                        :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^HeadlessSurfaceCreateInfoEXT, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCmdSetLineStippleEXT                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
+	ProcResetQueryPoolEXT                                               :: #type proc "stdcall" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcCmdSetCullModeEXT                                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, cullMode: CullModeFlags);
+	ProcCmdSetFrontFaceEXT                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, frontFace: FrontFace);
+	ProcCmdSetPrimitiveTopologyEXT                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology);
+	ProcCmdSetViewportWithCountEXT                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: ^Viewport);
+	ProcCmdSetScissorWithCountEXT                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: ^Rect2D);
+	ProcCmdBindVertexBuffers2EXT                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize, pSizes: ^DeviceSize, pStrides: ^DeviceSize);
+	ProcCmdSetDepthTestEnableEXT                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthTestEnable: b32);
+	ProcCmdSetDepthWriteEnableEXT                                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthWriteEnable: b32);
+	ProcCmdSetDepthCompareOpEXT                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp);
+	ProcCmdSetDepthBoundsTestEnableEXT                                  :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32);
+	ProcCmdSetStencilTestEnableEXT                                      :: #type proc "stdcall" (commandBuffer: CommandBuffer, stencilTestEnable: b32);
+	ProcCmdSetStencilOpEXT                                              :: #type proc "stdcall" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp);
+	ProcGetGeneratedCommandsMemoryRequirementsNV                        :: #type proc "stdcall" (device: Device, pInfo: ^GeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ^MemoryRequirements2);
+	ProcCmdPreprocessGeneratedCommandsNV                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV);
+	ProcCmdExecuteGeneratedCommandsNV                                   :: #type proc "stdcall" (commandBuffer: CommandBuffer, isPreprocessed: b32, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV);
+	ProcCmdBindPipelineShaderGroupNV                                    :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline, groupIndex: u32);
+	ProcCreateIndirectCommandsLayoutNV                                  :: #type proc "stdcall" (device: Device, pCreateInfo: ^IndirectCommandsLayoutCreateInfoNV, pAllocator: ^AllocationCallbacks, pIndirectCommandsLayout: ^IndirectCommandsLayoutNV) -> Result;
+	ProcDestroyIndirectCommandsLayoutNV                                 :: #type proc "stdcall" (device: Device, indirectCommandsLayout: IndirectCommandsLayoutNV, pAllocator: ^AllocationCallbacks);
+	ProcDeviceMemoryReportCallbackEXT                                   :: #type proc "stdcall" (pCallbackData: ^DeviceMemoryReportCallbackDataEXT, pUserData: rawptr);
+	ProcAcquireDrmDisplayEXT                                            :: #type proc "stdcall" (physicalDevice: PhysicalDevice, drmFd: i32, display: DisplayKHR) -> Result;
+	ProcGetDrmDisplayEXT                                                :: #type proc "stdcall" (physicalDevice: PhysicalDevice, drmFd: i32, connectorId: u32, display: ^DisplayKHR) -> Result;
+	ProcCreatePrivateDataSlotEXT                                        :: #type proc "stdcall" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfoEXT, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlotEXT) -> Result;
+	ProcDestroyPrivateDataSlotEXT                                       :: #type proc "stdcall" (device: Device, privateDataSlot: PrivateDataSlotEXT, pAllocator: ^AllocationCallbacks);
+	ProcSetPrivateDataEXT                                               :: #type proc "stdcall" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, data: u64) -> Result;
+	ProcGetPrivateDataEXT                                               :: #type proc "stdcall" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, pData: ^u64);
+	ProcCmdSetFragmentShadingRateEnumNV                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, shadingRate: FragmentShadingRateNV);
+	ProcAcquireWinrtDisplayNV                                           :: #type proc "stdcall" (physicalDevice: PhysicalDevice, display: DisplayKHR) -> Result;
+	ProcGetWinrtDisplayNV                                               :: #type proc "stdcall" (physicalDevice: PhysicalDevice, deviceRelativeId: u32, pDisplay: ^DisplayKHR) -> Result;
+	ProcCmdSetVertexInputEXT                                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: ^VertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: ^VertexInputAttributeDescription2EXT);
+	ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI                   :: #type proc "stdcall" (device: Device, renderpass: RenderPass, pMaxWorkgroupSize: ^Extent2D) -> Result;
+	ProcCmdSubpassShadingHUAWEI                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer);
+	ProcCmdBindInvocationMaskHUAWEI                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout);
+	ProcGetMemoryRemoteAddressNV                                        :: #type proc "stdcall" (device: Device, pMemoryGetRemoteAddressInfo: ^MemoryGetRemoteAddressInfoNV, pAddress: ^RemoteAddressNV) -> Result;
+	ProcCmdSetPatchControlPointsEXT                                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, patchControlPoints: u32);
+	ProcCmdSetRasterizerDiscardEnableEXT                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32);
+	ProcCmdSetDepthBiasEnableEXT                                        :: #type proc "stdcall" (commandBuffer: CommandBuffer, depthBiasEnable: b32);
+	ProcCmdSetLogicOpEXT                                                :: #type proc "stdcall" (commandBuffer: CommandBuffer, logicOp: LogicOp);
+	ProcCmdSetPrimitiveRestartEnableEXT                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32);
+	ProcCmdDrawMultiEXT                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, drawCount: u32, pVertexInfo: ^MultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
+	ProcCmdDrawMultiIndexedEXT                                          :: #type proc "stdcall" (commandBuffer: CommandBuffer, drawCount: u32, pIndexInfo: ^MultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: ^i32);
+	ProcCreateAccelerationStructureKHR                                  :: #type proc "stdcall" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoKHR, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureKHR) -> Result;
+	ProcDestroyAccelerationStructureKHR                                 :: #type proc "stdcall" (device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: ^AllocationCallbacks);
+	ProcCmdBuildAccelerationStructuresKHR                               :: #type proc "stdcall" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^^AccelerationStructureBuildRangeInfoKHR);
+	ProcCmdBuildAccelerationStructuresIndirectKHR                       :: #type proc "stdcall" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: ^DeviceAddress, pIndirectStrides: ^u32, ppMaxPrimitiveCounts: ^^u32);
+	ProcBuildAccelerationStructuresKHR                                  :: #type proc "stdcall" (device: Device, deferredOperation: DeferredOperationKHR, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^^AccelerationStructureBuildRangeInfoKHR) -> Result;
+	ProcCopyAccelerationStructureKHR                                    :: #type proc "stdcall" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureInfoKHR) -> Result;
+	ProcCopyAccelerationStructureToMemoryKHR                            :: #type proc "stdcall" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -> Result;
+	ProcCopyMemoryToAccelerationStructureKHR                            :: #type proc "stdcall" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) -> Result;
+	ProcWriteAccelerationStructuresPropertiesKHR                        :: #type proc "stdcall" (device: Device, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureKHR, queryType: QueryType, dataSize: int, pData: rawptr, stride: int) -> Result;
+	ProcCmdCopyAccelerationStructureKHR                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureInfoKHR);
+	ProcCmdCopyAccelerationStructureToMemoryKHR                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR);
+	ProcCmdCopyMemoryToAccelerationStructureKHR                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR);
+	ProcGetAccelerationStructureDeviceAddressKHR                        :: #type proc "stdcall" (device: Device, pInfo: ^AccelerationStructureDeviceAddressInfoKHR) -> DeviceAddress;
+	ProcCmdWriteAccelerationStructuresPropertiesKHR                     :: #type proc "stdcall" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32);
+	ProcGetDeviceAccelerationStructureCompatibilityKHR                  :: #type proc "stdcall" (device: Device, pVersionInfo: ^AccelerationStructureVersionInfoKHR, pCompatibility: ^AccelerationStructureCompatibilityKHR);
+	ProcGetAccelerationStructureBuildSizesKHR                           :: #type proc "stdcall" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^AccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ^u32, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR);
+	ProcCmdTraceRaysKHR                                                 :: #type proc "stdcall" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: ^StridedDeviceAddressRegionKHR, pMissShaderBindingTable: ^StridedDeviceAddressRegionKHR, pHitShaderBindingTable: ^StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ^StridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
+	ProcCreateRayTracingPipelinesKHR                                    :: #type proc "stdcall" (device: Device, deferredOperation: DeferredOperationKHR, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^RayTracingPipelineCreateInfoKHR, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR                 :: #type proc "stdcall" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcCmdTraceRaysIndirectKHR                                         :: #type proc "stdcall" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: ^StridedDeviceAddressRegionKHR, pMissShaderBindingTable: ^StridedDeviceAddressRegionKHR, pHitShaderBindingTable: ^StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ^StridedDeviceAddressRegionKHR, indirectDeviceAddress: DeviceAddress);
+	ProcGetRayTracingShaderGroupStackSizeKHR                            :: #type proc "stdcall" (device: Device, pipeline: Pipeline, group: u32, groupShader: ShaderGroupShaderKHR) -> DeviceSize;
+	ProcCmdSetRayTracingPipelineStackSizeKHR                            :: #type proc "stdcall" (commandBuffer: CommandBuffer, pipelineStackSize: u32);
+	ProcGetPhysicalDeviceProcAddr                                       :: #type proc "stdcall" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcNegotiateLoaderLayerInterfaceVersion                            :: #type proc "stdcall" (pVersionStruct: ^NegotiateLayerInterface ) -> Result;
+	ProcSetInstanceLoaderData                                           :: #type proc "stdcall" (instance: Instance, object: rawptr) -> Result;
+	ProcSetDeviceLoaderData                                             :: #type proc "stdcall" (device: Device, object: rawptr) -> Result;
+	ProcLayerCreateDevice                                               :: #type proc "stdcall" (instance: Instance, physicalDevice: PhysicalDevice, pCreateInfo: ^DeviceCreateInfo , pAllocator: ^AllocationCallbacks , pDevice: ^Device , layerGIPA: ProcGetInstanceProcAddr, nextGDPA: ^ProcGetDeviceProcAddr ) -> Result;
+	ProcLayerDestroyDevice                                              :: #type proc "stdcall" (physicalDevice: Device, pAllocator: ^AllocationCallbacks , destroyFunction: ProcDestroyDevice);
+	ProcicdNegotiateLoaderICDInterfaceVersion                           :: #type proc "stdcall" (pVersion: ^u32) -> Result;
+	ProcicdGetInstanceProcAddr                                          :: #type proc "stdcall" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcicdGetPhysicalDeviceProcAddr                                    :: #type proc "stdcall" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcicdEnumerateAdapterPhysicalDevices                              :: #type proc "stdcall" (instance: Instance, adapterLUID: LUID, pPhysicalDeviceCount: ^u32, pPhysicalDevices: ^PhysicalDevice) -> Result;
+	ProcCreateWin32SurfaceKHR                                           :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^Win32SurfaceCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcGetPhysicalDeviceWin32PresentationSupportKHR                    :: #type proc "stdcall" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32) -> b32;
+	ProcGetMemoryWin32HandleKHR                                         :: #type proc "stdcall" (device: Device, pGetWin32HandleInfo: ^MemoryGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcGetMemoryWin32HandlePropertiesKHR                               :: #type proc "stdcall" (device: Device, handleType: ExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: ^MemoryWin32HandlePropertiesKHR) -> Result;
+	ProcImportSemaphoreWin32HandleKHR                                   :: #type proc "stdcall" (device: Device, pImportSemaphoreWin32HandleInfo: ^ImportSemaphoreWin32HandleInfoKHR) -> Result;
+	ProcGetSemaphoreWin32HandleKHR                                      :: #type proc "stdcall" (device: Device, pGetWin32HandleInfo: ^SemaphoreGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcImportFenceWin32HandleKHR                                       :: #type proc "stdcall" (device: Device, pImportFenceWin32HandleInfo: ^ImportFenceWin32HandleInfoKHR) -> Result;
+	ProcGetFenceWin32HandleKHR                                          :: #type proc "stdcall" (device: Device, pGetWin32HandleInfo: ^FenceGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcGetMemoryWin32HandleNV                                          :: #type proc "stdcall" (device: Device, memory: DeviceMemory, handleType: ExternalMemoryHandleTypeFlagsNV, pHandle: ^HANDLE) -> Result;
+	ProcGetPhysicalDeviceSurfacePresentModes2EXT                        :: #type proc "stdcall" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pPresentModeCount: ^u32, pPresentModes: ^PresentModeKHR) -> Result;
+	ProcAcquireFullScreenExclusiveModeEXT                               :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcReleaseFullScreenExclusiveModeEXT                               :: #type proc "stdcall" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcGetDeviceGroupSurfacePresentModes2EXT                           :: #type proc "stdcall" (device: Device, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pModes: ^DeviceGroupPresentModeFlagsKHR) -> Result;
+	ProcCreateMetalSurfaceEXT                                           :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^MetalSurfaceCreateInfoEXT, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateMacOSSurfaceMVK                                           :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^MacOSSurfaceCreateInfoMVK, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateIOSSurfaceMVK                                             :: #type proc "stdcall" (instance: Instance, pCreateInfo: ^IOSSurfaceCreateInfoMVK, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+} else {
+	ProcAllocationFunction                                              :: #type proc "c" (pUserData: rawptr, size: int, alignment: int, allocationScope: SystemAllocationScope) -> rawptr;
+	ProcFreeFunction                                                    :: #type proc "c" (pUserData: rawptr, pMemory: rawptr);
+	ProcInternalAllocationNotification                                  :: #type proc "c" (pUserData: rawptr, size: int, allocationType: InternalAllocationType, allocationScope: SystemAllocationScope);
+	ProcInternalFreeNotification                                        :: #type proc "c" (pUserData: rawptr, size: int, allocationType: InternalAllocationType, allocationScope: SystemAllocationScope);
+	ProcReallocationFunction                                            :: #type proc "c" (pUserData: rawptr, pOriginal: rawptr, size: int, alignment: int, allocationScope: SystemAllocationScope) -> rawptr;
+	ProcVoidFunction                                                    :: #type proc "c" ();
+	ProcCreateInstance                                                  :: #type proc "c" (pCreateInfo: ^InstanceCreateInfo, pAllocator: ^AllocationCallbacks, pInstance: ^Instance) -> Result;
+	ProcDestroyInstance                                                 :: #type proc "c" (instance: Instance, pAllocator: ^AllocationCallbacks);
+	ProcEnumeratePhysicalDevices                                        :: #type proc "c" (instance: Instance, pPhysicalDeviceCount: ^u32, pPhysicalDevices: ^PhysicalDevice) -> Result;
+	ProcGetPhysicalDeviceFeatures                                       :: #type proc "c" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures);
+	ProcGetPhysicalDeviceFormatProperties                               :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties);
+	ProcGetPhysicalDeviceImageFormatProperties                          :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, pImageFormatProperties: ^ImageFormatProperties) -> Result;
+	ProcGetPhysicalDeviceProperties                                     :: #type proc "c" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties);
+	ProcGetPhysicalDeviceQueueFamilyProperties                          :: #type proc "c" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties);
+	ProcGetPhysicalDeviceMemoryProperties                               :: #type proc "c" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties);
+	ProcGetInstanceProcAddr                                             :: #type proc "c" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcGetDeviceProcAddr                                               :: #type proc "c" (device: Device, pName: cstring) -> ProcVoidFunction;
+	ProcCreateDevice                                                    :: #type proc "c" (physicalDevice: PhysicalDevice, pCreateInfo: ^DeviceCreateInfo, pAllocator: ^AllocationCallbacks, pDevice: ^Device) -> Result;
+	ProcDestroyDevice                                                   :: #type proc "c" (device: Device, pAllocator: ^AllocationCallbacks);
+	ProcEnumerateInstanceExtensionProperties                            :: #type proc "c" (pLayerName: cstring, pPropertyCount: ^u32, pProperties: ^ExtensionProperties) -> Result;
+	ProcEnumerateDeviceExtensionProperties                              :: #type proc "c" (physicalDevice: PhysicalDevice, pLayerName: cstring, pPropertyCount: ^u32, pProperties: ^ExtensionProperties) -> Result;
+	ProcEnumerateInstanceLayerProperties                                :: #type proc "c" (pPropertyCount: ^u32, pProperties: ^LayerProperties) -> Result;
+	ProcEnumerateDeviceLayerProperties                                  :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^LayerProperties) -> Result;
+	ProcGetDeviceQueue                                                  :: #type proc "c" (device: Device, queueFamilyIndex: u32, queueIndex: u32, pQueue: ^Queue);
+	ProcQueueSubmit                                                     :: #type proc "c" (queue: Queue, submitCount: u32, pSubmits: ^SubmitInfo, fence: Fence) -> Result;
+	ProcQueueWaitIdle                                                   :: #type proc "c" (queue: Queue) -> Result;
+	ProcDeviceWaitIdle                                                  :: #type proc "c" (device: Device) -> Result;
+	ProcAllocateMemory                                                  :: #type proc "c" (device: Device, pAllocateInfo: ^MemoryAllocateInfo, pAllocator: ^AllocationCallbacks, pMemory: ^DeviceMemory) -> Result;
+	ProcFreeMemory                                                      :: #type proc "c" (device: Device, memory: DeviceMemory, pAllocator: ^AllocationCallbacks);
+	ProcMapMemory                                                       :: #type proc "c" (device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, ppData: ^rawptr) -> Result;
+	ProcUnmapMemory                                                     :: #type proc "c" (device: Device, memory: DeviceMemory);
+	ProcFlushMappedMemoryRanges                                         :: #type proc "c" (device: Device, memoryRangeCount: u32, pMemoryRanges: ^MappedMemoryRange) -> Result;
+	ProcInvalidateMappedMemoryRanges                                    :: #type proc "c" (device: Device, memoryRangeCount: u32, pMemoryRanges: ^MappedMemoryRange) -> Result;
+	ProcGetDeviceMemoryCommitment                                       :: #type proc "c" (device: Device, memory: DeviceMemory, pCommittedMemoryInBytes: ^DeviceSize);
+	ProcBindBufferMemory                                                :: #type proc "c" (device: Device, buffer: Buffer, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result;
+	ProcBindImageMemory                                                 :: #type proc "c" (device: Device, image: Image, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result;
+	ProcGetBufferMemoryRequirements                                     :: #type proc "c" (device: Device, buffer: Buffer, pMemoryRequirements: ^MemoryRequirements);
+	ProcGetImageMemoryRequirements                                      :: #type proc "c" (device: Device, image: Image, pMemoryRequirements: ^MemoryRequirements);
+	ProcGetImageSparseMemoryRequirements                                :: #type proc "c" (device: Device, image: Image, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements);
+	ProcGetPhysicalDeviceSparseImageFormatProperties                    :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties);
+	ProcQueueBindSparse                                                 :: #type proc "c" (queue: Queue, bindInfoCount: u32, pBindInfo: ^BindSparseInfo, fence: Fence) -> Result;
+	ProcCreateFence                                                     :: #type proc "c" (device: Device, pCreateInfo: ^FenceCreateInfo, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcDestroyFence                                                    :: #type proc "c" (device: Device, fence: Fence, pAllocator: ^AllocationCallbacks);
+	ProcResetFences                                                     :: #type proc "c" (device: Device, fenceCount: u32, pFences: ^Fence) -> Result;
+	ProcGetFenceStatus                                                  :: #type proc "c" (device: Device, fence: Fence) -> Result;
+	ProcWaitForFences                                                   :: #type proc "c" (device: Device, fenceCount: u32, pFences: ^Fence, waitAll: b32, timeout: u64) -> Result;
+	ProcCreateSemaphore                                                 :: #type proc "c" (device: Device, pCreateInfo: ^SemaphoreCreateInfo, pAllocator: ^AllocationCallbacks, pSemaphore: ^Semaphore) -> Result;
+	ProcDestroySemaphore                                                :: #type proc "c" (device: Device, semaphore: Semaphore, pAllocator: ^AllocationCallbacks);
+	ProcCreateEvent                                                     :: #type proc "c" (device: Device, pCreateInfo: ^EventCreateInfo, pAllocator: ^AllocationCallbacks, pEvent: ^Event) -> Result;
+	ProcDestroyEvent                                                    :: #type proc "c" (device: Device, event: Event, pAllocator: ^AllocationCallbacks);
+	ProcGetEventStatus                                                  :: #type proc "c" (device: Device, event: Event) -> Result;
+	ProcSetEvent                                                        :: #type proc "c" (device: Device, event: Event) -> Result;
+	ProcResetEvent                                                      :: #type proc "c" (device: Device, event: Event) -> Result;
+	ProcCreateQueryPool                                                 :: #type proc "c" (device: Device, pCreateInfo: ^QueryPoolCreateInfo, pAllocator: ^AllocationCallbacks, pQueryPool: ^QueryPool) -> Result;
+	ProcDestroyQueryPool                                                :: #type proc "c" (device: Device, queryPool: QueryPool, pAllocator: ^AllocationCallbacks);
+	ProcGetQueryPoolResults                                             :: #type proc "c" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dataSize: int, pData: rawptr, stride: DeviceSize, flags: QueryResultFlags) -> Result;
+	ProcCreateBuffer                                                    :: #type proc "c" (device: Device, pCreateInfo: ^BufferCreateInfo, pAllocator: ^AllocationCallbacks, pBuffer: ^Buffer) -> Result;
+	ProcDestroyBuffer                                                   :: #type proc "c" (device: Device, buffer: Buffer, pAllocator: ^AllocationCallbacks);
+	ProcCreateBufferView                                                :: #type proc "c" (device: Device, pCreateInfo: ^BufferViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^BufferView) -> Result;
+	ProcDestroyBufferView                                               :: #type proc "c" (device: Device, bufferView: BufferView, pAllocator: ^AllocationCallbacks);
+	ProcCreateImage                                                     :: #type proc "c" (device: Device, pCreateInfo: ^ImageCreateInfo, pAllocator: ^AllocationCallbacks, pImage: ^Image) -> Result;
+	ProcDestroyImage                                                    :: #type proc "c" (device: Device, image: Image, pAllocator: ^AllocationCallbacks);
+	ProcGetImageSubresourceLayout                                       :: #type proc "c" (device: Device, image: Image, pSubresource: ^ImageSubresource, pLayout: ^SubresourceLayout);
+	ProcCreateImageView                                                 :: #type proc "c" (device: Device, pCreateInfo: ^ImageViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^ImageView) -> Result;
+	ProcDestroyImageView                                                :: #type proc "c" (device: Device, imageView: ImageView, pAllocator: ^AllocationCallbacks);
+	ProcCreateShaderModule                                              :: #type proc "c" (device: Device, pCreateInfo: ^ShaderModuleCreateInfo, pAllocator: ^AllocationCallbacks, pShaderModule: ^ShaderModule) -> Result;
+	ProcDestroyShaderModule                                             :: #type proc "c" (device: Device, shaderModule: ShaderModule, pAllocator: ^AllocationCallbacks);
+	ProcCreatePipelineCache                                             :: #type proc "c" (device: Device, pCreateInfo: ^PipelineCacheCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineCache: ^PipelineCache) -> Result;
+	ProcDestroyPipelineCache                                            :: #type proc "c" (device: Device, pipelineCache: PipelineCache, pAllocator: ^AllocationCallbacks);
+	ProcGetPipelineCacheData                                            :: #type proc "c" (device: Device, pipelineCache: PipelineCache, pDataSize: ^int, pData: rawptr) -> Result;
+	ProcMergePipelineCaches                                             :: #type proc "c" (device: Device, dstCache: PipelineCache, srcCacheCount: u32, pSrcCaches: ^PipelineCache) -> Result;
+	ProcCreateGraphicsPipelines                                         :: #type proc "c" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^GraphicsPipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcCreateComputePipelines                                          :: #type proc "c" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^ComputePipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcDestroyPipeline                                                 :: #type proc "c" (device: Device, pipeline: Pipeline, pAllocator: ^AllocationCallbacks);
+	ProcCreatePipelineLayout                                            :: #type proc "c" (device: Device, pCreateInfo: ^PipelineLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineLayout: ^PipelineLayout) -> Result;
+	ProcDestroyPipelineLayout                                           :: #type proc "c" (device: Device, pipelineLayout: PipelineLayout, pAllocator: ^AllocationCallbacks);
+	ProcCreateSampler                                                   :: #type proc "c" (device: Device, pCreateInfo: ^SamplerCreateInfo, pAllocator: ^AllocationCallbacks, pSampler: ^Sampler) -> Result;
+	ProcDestroySampler                                                  :: #type proc "c" (device: Device, sampler: Sampler, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorSetLayout                                       :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pSetLayout: ^DescriptorSetLayout) -> Result;
+	ProcDestroyDescriptorSetLayout                                      :: #type proc "c" (device: Device, descriptorSetLayout: DescriptorSetLayout, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorPool                                            :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorPoolCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorPool: ^DescriptorPool) -> Result;
+	ProcDestroyDescriptorPool                                           :: #type proc "c" (device: Device, descriptorPool: DescriptorPool, pAllocator: ^AllocationCallbacks);
+	ProcResetDescriptorPool                                             :: #type proc "c" (device: Device, descriptorPool: DescriptorPool, flags: DescriptorPoolResetFlags) -> Result;
+	ProcAllocateDescriptorSets                                          :: #type proc "c" (device: Device, pAllocateInfo: ^DescriptorSetAllocateInfo, pDescriptorSets: ^DescriptorSet) -> Result;
+	ProcFreeDescriptorSets                                              :: #type proc "c" (device: Device, descriptorPool: DescriptorPool, descriptorSetCount: u32, pDescriptorSets: ^DescriptorSet) -> Result;
+	ProcUpdateDescriptorSets                                            :: #type proc "c" (device: Device, descriptorWriteCount: u32, pDescriptorWrites: ^WriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: ^CopyDescriptorSet);
+	ProcCreateFramebuffer                                               :: #type proc "c" (device: Device, pCreateInfo: ^FramebufferCreateInfo, pAllocator: ^AllocationCallbacks, pFramebuffer: ^Framebuffer) -> Result;
+	ProcDestroyFramebuffer                                              :: #type proc "c" (device: Device, framebuffer: Framebuffer, pAllocator: ^AllocationCallbacks);
+	ProcCreateRenderPass                                                :: #type proc "c" (device: Device, pCreateInfo: ^RenderPassCreateInfo, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcDestroyRenderPass                                               :: #type proc "c" (device: Device, renderPass: RenderPass, pAllocator: ^AllocationCallbacks);
+	ProcGetRenderAreaGranularity                                        :: #type proc "c" (device: Device, renderPass: RenderPass, pGranularity: ^Extent2D);
+	ProcCreateCommandPool                                               :: #type proc "c" (device: Device, pCreateInfo: ^CommandPoolCreateInfo, pAllocator: ^AllocationCallbacks, pCommandPool: ^CommandPool) -> Result;
+	ProcDestroyCommandPool                                              :: #type proc "c" (device: Device, commandPool: CommandPool, pAllocator: ^AllocationCallbacks);
+	ProcResetCommandPool                                                :: #type proc "c" (device: Device, commandPool: CommandPool, flags: CommandPoolResetFlags) -> Result;
+	ProcAllocateCommandBuffers                                          :: #type proc "c" (device: Device, pAllocateInfo: ^CommandBufferAllocateInfo, pCommandBuffers: ^CommandBuffer) -> Result;
+	ProcFreeCommandBuffers                                              :: #type proc "c" (device: Device, commandPool: CommandPool, commandBufferCount: u32, pCommandBuffers: ^CommandBuffer);
+	ProcBeginCommandBuffer                                              :: #type proc "c" (commandBuffer: CommandBuffer, pBeginInfo: ^CommandBufferBeginInfo) -> Result;
+	ProcEndCommandBuffer                                                :: #type proc "c" (commandBuffer: CommandBuffer) -> Result;
+	ProcResetCommandBuffer                                              :: #type proc "c" (commandBuffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result;
+	ProcCmdBindPipeline                                                 :: #type proc "c" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline);
+	ProcCmdSetViewport                                                  :: #type proc "c" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: ^Viewport);
+	ProcCmdSetScissor                                                   :: #type proc "c" (commandBuffer: CommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: ^Rect2D);
+	ProcCmdSetLineWidth                                                 :: #type proc "c" (commandBuffer: CommandBuffer, lineWidth: f32);
+	ProcCmdSetDepthBias                                                 :: #type proc "c" (commandBuffer: CommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
+	ProcCmdSetBlendConstants                                            :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdSetDepthBounds                                               :: #type proc "c" (commandBuffer: CommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
+	ProcCmdSetStencilCompareMask                                        :: #type proc "c" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, compareMask: u32);
+	ProcCmdSetStencilWriteMask                                          :: #type proc "c" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, writeMask: u32);
+	ProcCmdSetStencilReference                                          :: #type proc "c" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, reference: u32);
+	ProcCmdBindDescriptorSets                                           :: #type proc "c" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: ^DescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: ^u32);
+	ProcCmdBindIndexBuffer                                              :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, indexType: IndexType);
+	ProcCmdBindVertexBuffers                                            :: #type proc "c" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize);
+	ProcCmdDraw                                                         :: #type proc "c" (commandBuffer: CommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
+	ProcCmdDrawIndexed                                                  :: #type proc "c" (commandBuffer: CommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
+	ProcCmdDrawIndirect                                                 :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirect                                          :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDispatch                                                     :: #type proc "c" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcCmdDispatchIndirect                                             :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
+	ProcCmdCopyBuffer                                                   :: #type proc "c" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstBuffer: Buffer, regionCount: u32, pRegions: ^BufferCopy);
+	ProcCmdCopyImage                                                    :: #type proc "c" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageCopy);
+	ProcCmdBlitImage                                                    :: #type proc "c" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageBlit, filter: Filter);
+	ProcCmdCopyBufferToImage                                            :: #type proc "c" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^BufferImageCopy);
+	ProcCmdCopyImageToBuffer                                            :: #type proc "c" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstBuffer: Buffer, regionCount: u32, pRegions: ^BufferImageCopy);
+	ProcCmdUpdateBuffer                                                 :: #type proc "c" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, dataSize: DeviceSize, pData: rawptr);
+	ProcCmdFillBuffer                                                   :: #type proc "c" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, size: DeviceSize, data: u32);
+	ProcCmdClearColorImage                                              :: #type proc "c" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: ^ClearColorValue, rangeCount: u32, pRanges: ^ImageSubresourceRange);
+	ProcCmdClearDepthStencilImage                                       :: #type proc "c" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: ^ClearDepthStencilValue, rangeCount: u32, pRanges: ^ImageSubresourceRange);
+	ProcCmdClearAttachments                                             :: #type proc "c" (commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: ^ClearAttachment, rectCount: u32, pRects: ^ClearRect);
+	ProcCmdResolveImage                                                 :: #type proc "c" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: ^ImageResolve);
+	ProcCmdSetEvent                                                     :: #type proc "c" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags);
+	ProcCmdResetEvent                                                   :: #type proc "c" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags);
+	ProcCmdWaitEvents                                                   :: #type proc "c" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: ^Event, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: ^MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: ^BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: ^ImageMemoryBarrier);
+	ProcCmdPipelineBarrier                                              :: #type proc "c" (commandBuffer: CommandBuffer, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, dependencyFlags: DependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: ^MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: ^BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: ^ImageMemoryBarrier);
+	ProcCmdBeginQuery                                                   :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags);
+	ProcCmdEndQuery                                                     :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32);
+	ProcCmdResetQueryPool                                               :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcCmdWriteTimestamp                                               :: #type proc "c" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, queryPool: QueryPool, query: u32);
+	ProcCmdCopyQueryPoolResults                                         :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dstBuffer: Buffer, dstOffset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags);
+	ProcCmdPushConstants                                                :: #type proc "c" (commandBuffer: CommandBuffer, layout: PipelineLayout, stageFlags: ShaderStageFlags, offset: u32, size: u32, pValues: rawptr);
+	ProcCmdBeginRenderPass                                              :: #type proc "c" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, contents: SubpassContents);
+	ProcCmdNextSubpass                                                  :: #type proc "c" (commandBuffer: CommandBuffer, contents: SubpassContents);
+	ProcCmdEndRenderPass                                                :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdExecuteCommands                                              :: #type proc "c" (commandBuffer: CommandBuffer, commandBufferCount: u32, pCommandBuffers: ^CommandBuffer);
+	ProcEnumerateInstanceVersion                                        :: #type proc "c" (pApiVersion: ^u32) -> Result;
+	ProcBindBufferMemory2                                               :: #type proc "c" (device: Device, bindInfoCount: u32, pBindInfos: ^BindBufferMemoryInfo) -> Result;
+	ProcBindImageMemory2                                                :: #type proc "c" (device: Device, bindInfoCount: u32, pBindInfos: ^BindImageMemoryInfo) -> Result;
+	ProcGetDeviceGroupPeerMemoryFeatures                                :: #type proc "c" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: ^PeerMemoryFeatureFlags);
+	ProcCmdSetDeviceMask                                                :: #type proc "c" (commandBuffer: CommandBuffer, deviceMask: u32);
+	ProcCmdDispatchBase                                                 :: #type proc "c" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcEnumeratePhysicalDeviceGroups                                   :: #type proc "c" (instance: Instance, pPhysicalDeviceGroupCount: ^u32, pPhysicalDeviceGroupProperties: ^PhysicalDeviceGroupProperties) -> Result;
+	ProcGetImageMemoryRequirements2                                     :: #type proc "c" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetBufferMemoryRequirements2                                    :: #type proc "c" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetImageSparseMemoryRequirements2                               :: #type proc "c" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements2);
+	ProcGetPhysicalDeviceFeatures2                                      :: #type proc "c" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures2);
+	ProcGetPhysicalDeviceProperties2                                    :: #type proc "c" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties2);
+	ProcGetPhysicalDeviceFormatProperties2                              :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties2);
+	ProcGetPhysicalDeviceImageFormatProperties2                         :: #type proc "c" (physicalDevice: PhysicalDevice, pImageFormatInfo: ^PhysicalDeviceImageFormatInfo2, pImageFormatProperties: ^ImageFormatProperties2) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyProperties2                         :: #type proc "c" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties2);
+	ProcGetPhysicalDeviceMemoryProperties2                              :: #type proc "c" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties2);
+	ProcGetPhysicalDeviceSparseImageFormatProperties2                   :: #type proc "c" (physicalDevice: PhysicalDevice, pFormatInfo: ^PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties2);
+	ProcTrimCommandPool                                                 :: #type proc "c" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags);
+	ProcGetDeviceQueue2                                                 :: #type proc "c" (device: Device, pQueueInfo: ^DeviceQueueInfo2, pQueue: ^Queue);
+	ProcCreateSamplerYcbcrConversion                                    :: #type proc "c" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result;
+	ProcDestroySamplerYcbcrConversion                                   :: #type proc "c" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks);
+	ProcCreateDescriptorUpdateTemplate                                  :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result;
+	ProcDestroyDescriptorUpdateTemplate                                 :: #type proc "c" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks);
+	ProcUpdateDescriptorSetWithTemplate                                 :: #type proc "c" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr);
+	ProcGetPhysicalDeviceExternalBufferProperties                       :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalBufferInfo: ^PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ^ExternalBufferProperties);
+	ProcGetPhysicalDeviceExternalFenceProperties                        :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalFenceInfo: ^PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ^ExternalFenceProperties);
+	ProcGetPhysicalDeviceExternalSemaphoreProperties                    :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: ^PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ^ExternalSemaphoreProperties);
+	ProcGetDescriptorSetLayoutSupport                                   :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport);
+	ProcCmdDrawIndirectCount                                            :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCount                                     :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCreateRenderPass2                                               :: #type proc "c" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcCmdBeginRenderPass2                                             :: #type proc "c" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo);
+	ProcCmdNextSubpass2                                                 :: #type proc "c" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcCmdEndRenderPass2                                               :: #type proc "c" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcResetQueryPool                                                  :: #type proc "c" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcGetSemaphoreCounterValue                                        :: #type proc "c" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result;
+	ProcWaitSemaphores                                                  :: #type proc "c" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result;
+	ProcSignalSemaphore                                                 :: #type proc "c" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result;
+	ProcGetBufferDeviceAddress                                          :: #type proc "c" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetBufferOpaqueCaptureAddress                                   :: #type proc "c" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64;
+	ProcGetDeviceMemoryOpaqueCaptureAddress                             :: #type proc "c" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64;
+	ProcDestroySurfaceKHR                                               :: #type proc "c" (instance: Instance, surface: SurfaceKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetPhysicalDeviceSurfaceSupportKHR                              :: #type proc "c" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, surface: SurfaceKHR, pSupported: ^b32) -> Result;
+	ProcGetPhysicalDeviceSurfaceCapabilitiesKHR                         :: #type proc "c" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: ^SurfaceCapabilitiesKHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceFormatsKHR                              :: #type proc "c" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceFormatCount: ^u32, pSurfaceFormats: ^SurfaceFormatKHR) -> Result;
+	ProcGetPhysicalDeviceSurfacePresentModesKHR                         :: #type proc "c" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pPresentModeCount: ^u32, pPresentModes: ^PresentModeKHR) -> Result;
+	ProcCreateSwapchainKHR                                              :: #type proc "c" (device: Device, pCreateInfo: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchain: ^SwapchainKHR) -> Result;
+	ProcDestroySwapchainKHR                                             :: #type proc "c" (device: Device, swapchain: SwapchainKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetSwapchainImagesKHR                                           :: #type proc "c" (device: Device, swapchain: SwapchainKHR, pSwapchainImageCount: ^u32, pSwapchainImages: ^Image) -> Result;
+	ProcAcquireNextImageKHR                                             :: #type proc "c" (device: Device, swapchain: SwapchainKHR, timeout: u64, semaphore: Semaphore, fence: Fence, pImageIndex: ^u32) -> Result;
+	ProcQueuePresentKHR                                                 :: #type proc "c" (queue: Queue, pPresentInfo: ^PresentInfoKHR) -> Result;
+	ProcGetDeviceGroupPresentCapabilitiesKHR                            :: #type proc "c" (device: Device, pDeviceGroupPresentCapabilities: ^DeviceGroupPresentCapabilitiesKHR) -> Result;
+	ProcGetDeviceGroupSurfacePresentModesKHR                            :: #type proc "c" (device: Device, surface: SurfaceKHR, pModes: ^DeviceGroupPresentModeFlagsKHR) -> Result;
+	ProcGetPhysicalDevicePresentRectanglesKHR                           :: #type proc "c" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pRectCount: ^u32, pRects: ^Rect2D) -> Result;
+	ProcAcquireNextImage2KHR                                            :: #type proc "c" (device: Device, pAcquireInfo: ^AcquireNextImageInfoKHR, pImageIndex: ^u32) -> Result;
+	ProcGetPhysicalDeviceDisplayPropertiesKHR                           :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPropertiesKHR) -> Result;
+	ProcGetPhysicalDeviceDisplayPlanePropertiesKHR                      :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPlanePropertiesKHR) -> Result;
+	ProcGetDisplayPlaneSupportedDisplaysKHR                             :: #type proc "c" (physicalDevice: PhysicalDevice, planeIndex: u32, pDisplayCount: ^u32, pDisplays: ^DisplayKHR) -> Result;
+	ProcGetDisplayModePropertiesKHR                                     :: #type proc "c" (physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: ^u32, pProperties: ^DisplayModePropertiesKHR) -> Result;
+	ProcCreateDisplayModeKHR                                            :: #type proc "c" (physicalDevice: PhysicalDevice, display: DisplayKHR, pCreateInfo: ^DisplayModeCreateInfoKHR, pAllocator: ^AllocationCallbacks, pMode: ^DisplayModeKHR) -> Result;
+	ProcGetDisplayPlaneCapabilitiesKHR                                  :: #type proc "c" (physicalDevice: PhysicalDevice, mode: DisplayModeKHR, planeIndex: u32, pCapabilities: ^DisplayPlaneCapabilitiesKHR) -> Result;
+	ProcCreateDisplayPlaneSurfaceKHR                                    :: #type proc "c" (instance: Instance, pCreateInfo: ^DisplaySurfaceCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateSharedSwapchainsKHR                                       :: #type proc "c" (device: Device, swapchainCount: u32, pCreateInfos: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchains: ^SwapchainKHR) -> Result;
+	ProcGetPhysicalDeviceFeatures2KHR                                   :: #type proc "c" (physicalDevice: PhysicalDevice, pFeatures: ^PhysicalDeviceFeatures2);
+	ProcGetPhysicalDeviceProperties2KHR                                 :: #type proc "c" (physicalDevice: PhysicalDevice, pProperties: ^PhysicalDeviceProperties2);
+	ProcGetPhysicalDeviceFormatProperties2KHR                           :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, pFormatProperties: ^FormatProperties2);
+	ProcGetPhysicalDeviceImageFormatProperties2KHR                      :: #type proc "c" (physicalDevice: PhysicalDevice, pImageFormatInfo: ^PhysicalDeviceImageFormatInfo2, pImageFormatProperties: ^ImageFormatProperties2) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyProperties2KHR                      :: #type proc "c" (physicalDevice: PhysicalDevice, pQueueFamilyPropertyCount: ^u32, pQueueFamilyProperties: ^QueueFamilyProperties2);
+	ProcGetPhysicalDeviceMemoryProperties2KHR                           :: #type proc "c" (physicalDevice: PhysicalDevice, pMemoryProperties: ^PhysicalDeviceMemoryProperties2);
+	ProcGetPhysicalDeviceSparseImageFormatProperties2KHR                :: #type proc "c" (physicalDevice: PhysicalDevice, pFormatInfo: ^PhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ^u32, pProperties: ^SparseImageFormatProperties2);
+	ProcGetDeviceGroupPeerMemoryFeaturesKHR                             :: #type proc "c" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: ^PeerMemoryFeatureFlags);
+	ProcCmdSetDeviceMaskKHR                                             :: #type proc "c" (commandBuffer: CommandBuffer, deviceMask: u32);
+	ProcCmdDispatchBaseKHR                                              :: #type proc "c" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
+	ProcTrimCommandPoolKHR                                              :: #type proc "c" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags);
+	ProcEnumeratePhysicalDeviceGroupsKHR                                :: #type proc "c" (instance: Instance, pPhysicalDeviceGroupCount: ^u32, pPhysicalDeviceGroupProperties: ^PhysicalDeviceGroupProperties) -> Result;
+	ProcGetPhysicalDeviceExternalBufferPropertiesKHR                    :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalBufferInfo: ^PhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ^ExternalBufferProperties);
+	ProcGetMemoryFdKHR                                                  :: #type proc "c" (device: Device, pGetFdInfo: ^MemoryGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcGetMemoryFdPropertiesKHR                                        :: #type proc "c" (device: Device, handleType: ExternalMemoryHandleTypeFlags, fd: c.int, pMemoryFdProperties: ^MemoryFdPropertiesKHR) -> Result;
+	ProcGetPhysicalDeviceExternalSemaphorePropertiesKHR                 :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalSemaphoreInfo: ^PhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ^ExternalSemaphoreProperties);
+	ProcImportSemaphoreFdKHR                                            :: #type proc "c" (device: Device, pImportSemaphoreFdInfo: ^ImportSemaphoreFdInfoKHR) -> Result;
+	ProcGetSemaphoreFdKHR                                               :: #type proc "c" (device: Device, pGetFdInfo: ^SemaphoreGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcCmdPushDescriptorSetKHR                                         :: #type proc "c" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: ^WriteDescriptorSet);
+	ProcCmdPushDescriptorSetWithTemplateKHR                             :: #type proc "c" (commandBuffer: CommandBuffer, descriptorUpdateTemplate: DescriptorUpdateTemplate, layout: PipelineLayout, set: u32, pData: rawptr);
+	ProcCreateDescriptorUpdateTemplateKHR                               :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result;
+	ProcDestroyDescriptorUpdateTemplateKHR                              :: #type proc "c" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks);
+	ProcUpdateDescriptorSetWithTemplateKHR                              :: #type proc "c" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr);
+	ProcCreateRenderPass2KHR                                            :: #type proc "c" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: ^RenderPass) -> Result;
+	ProcCmdBeginRenderPass2KHR                                          :: #type proc "c" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo);
+	ProcCmdNextSubpass2KHR                                              :: #type proc "c" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcCmdEndRenderPass2KHR                                            :: #type proc "c" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo);
+	ProcGetSwapchainStatusKHR                                           :: #type proc "c" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcGetPhysicalDeviceExternalFencePropertiesKHR                     :: #type proc "c" (physicalDevice: PhysicalDevice, pExternalFenceInfo: ^PhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ^ExternalFenceProperties);
+	ProcImportFenceFdKHR                                                :: #type proc "c" (device: Device, pImportFenceFdInfo: ^ImportFenceFdInfoKHR) -> Result;
+	ProcGetFenceFdKHR                                                   :: #type proc "c" (device: Device, pGetFdInfo: ^FenceGetFdInfoKHR, pFd: ^c.int) -> Result;
+	ProcEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR   :: #type proc "c" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, pCounterCount: ^u32, pCounters: ^PerformanceCounterKHR, pCounterDescriptions: ^PerformanceCounterDescriptionKHR) -> Result;
+	ProcGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR           :: #type proc "c" (physicalDevice: PhysicalDevice, pPerformanceQueryCreateInfo: ^QueryPoolPerformanceCreateInfoKHR, pNumPasses: ^u32);
+	ProcAcquireProfilingLockKHR                                         :: #type proc "c" (device: Device, pInfo: ^AcquireProfilingLockInfoKHR) -> Result;
+	ProcReleaseProfilingLockKHR                                         :: #type proc "c" (device: Device);
+	ProcGetPhysicalDeviceSurfaceCapabilities2KHR                        :: #type proc "c" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ^SurfaceCapabilities2KHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceFormats2KHR                             :: #type proc "c" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ^u32, pSurfaceFormats: ^SurfaceFormat2KHR) -> Result;
+	ProcGetPhysicalDeviceDisplayProperties2KHR                          :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayProperties2KHR) -> Result;
+	ProcGetPhysicalDeviceDisplayPlaneProperties2KHR                     :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^DisplayPlaneProperties2KHR) -> Result;
+	ProcGetDisplayModeProperties2KHR                                    :: #type proc "c" (physicalDevice: PhysicalDevice, display: DisplayKHR, pPropertyCount: ^u32, pProperties: ^DisplayModeProperties2KHR) -> Result;
+	ProcGetDisplayPlaneCapabilities2KHR                                 :: #type proc "c" (physicalDevice: PhysicalDevice, pDisplayPlaneInfo: ^DisplayPlaneInfo2KHR, pCapabilities: ^DisplayPlaneCapabilities2KHR) -> Result;
+	ProcGetImageMemoryRequirements2KHR                                  :: #type proc "c" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetBufferMemoryRequirements2KHR                                 :: #type proc "c" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: ^MemoryRequirements2);
+	ProcGetImageSparseMemoryRequirements2KHR                            :: #type proc "c" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: ^SparseImageMemoryRequirements2);
+	ProcCreateSamplerYcbcrConversionKHR                                 :: #type proc "c" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result;
+	ProcDestroySamplerYcbcrConversionKHR                                :: #type proc "c" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks);
+	ProcBindBufferMemory2KHR                                            :: #type proc "c" (device: Device, bindInfoCount: u32, pBindInfos: ^BindBufferMemoryInfo) -> Result;
+	ProcBindImageMemory2KHR                                             :: #type proc "c" (device: Device, bindInfoCount: u32, pBindInfos: ^BindImageMemoryInfo) -> Result;
+	ProcGetDescriptorSetLayoutSupportKHR                                :: #type proc "c" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport);
+	ProcCmdDrawIndirectCountKHR                                         :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCountKHR                                  :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcGetSemaphoreCounterValueKHR                                     :: #type proc "c" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result;
+	ProcWaitSemaphoresKHR                                               :: #type proc "c" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result;
+	ProcSignalSemaphoreKHR                                              :: #type proc "c" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result;
+	ProcGetPhysicalDeviceFragmentShadingRatesKHR                        :: #type proc "c" (physicalDevice: PhysicalDevice, pFragmentShadingRateCount: ^u32, pFragmentShadingRates: ^PhysicalDeviceFragmentShadingRateKHR) -> Result;
+	ProcCmdSetFragmentShadingRateKHR                                    :: #type proc "c" (commandBuffer: CommandBuffer, pFragmentSize: ^Extent2D);
+	ProcWaitForPresentKHR                                               :: #type proc "c" (device: Device, swapchain: SwapchainKHR, presentId: u64, timeout: u64) -> Result;
+	ProcGetBufferDeviceAddressKHR                                       :: #type proc "c" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetBufferOpaqueCaptureAddressKHR                                :: #type proc "c" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64;
+	ProcGetDeviceMemoryOpaqueCaptureAddressKHR                          :: #type proc "c" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64;
+	ProcCreateDeferredOperationKHR                                      :: #type proc "c" (device: Device, pAllocator: ^AllocationCallbacks, pDeferredOperation: ^DeferredOperationKHR) -> Result;
+	ProcDestroyDeferredOperationKHR                                     :: #type proc "c" (device: Device, operation: DeferredOperationKHR, pAllocator: ^AllocationCallbacks);
+	ProcGetDeferredOperationMaxConcurrencyKHR                           :: #type proc "c" (device: Device, operation: DeferredOperationKHR) -> u32;
+	ProcGetDeferredOperationResultKHR                                   :: #type proc "c" (device: Device, operation: DeferredOperationKHR) -> Result;
+	ProcDeferredOperationJoinKHR                                        :: #type proc "c" (device: Device, operation: DeferredOperationKHR) -> Result;
+	ProcGetPipelineExecutablePropertiesKHR                              :: #type proc "c" (device: Device, pPipelineInfo: ^PipelineInfoKHR, pExecutableCount: ^u32, pProperties: ^PipelineExecutablePropertiesKHR) -> Result;
+	ProcGetPipelineExecutableStatisticsKHR                              :: #type proc "c" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pStatisticCount: ^u32, pStatistics: ^PipelineExecutableStatisticKHR) -> Result;
+	ProcGetPipelineExecutableInternalRepresentationsKHR                 :: #type proc "c" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pInternalRepresentationCount: ^u32, pInternalRepresentations: ^PipelineExecutableInternalRepresentationKHR) -> Result;
+	ProcCmdSetEvent2KHR                                                 :: #type proc "c" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfoKHR);
+	ProcCmdResetEvent2KHR                                               :: #type proc "c" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2KHR);
+	ProcCmdWaitEvents2KHR                                               :: #type proc "c" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: ^Event, pDependencyInfos: ^DependencyInfoKHR);
+	ProcCmdPipelineBarrier2KHR                                          :: #type proc "c" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfoKHR);
+	ProcCmdWriteTimestamp2KHR                                           :: #type proc "c" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2KHR, queryPool: QueryPool, query: u32);
+	ProcQueueSubmit2KHR                                                 :: #type proc "c" (queue: Queue, submitCount: u32, pSubmits: ^SubmitInfo2KHR, fence: Fence) -> Result;
+	ProcCmdWriteBufferMarker2AMD                                        :: #type proc "c" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2KHR, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32);
+	ProcGetQueueCheckpointData2NV                                       :: #type proc "c" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointData2NV);
+	ProcCmdCopyBuffer2KHR                                               :: #type proc "c" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2KHR);
+	ProcCmdCopyImage2KHR                                                :: #type proc "c" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2KHR);
+	ProcCmdCopyBufferToImage2KHR                                        :: #type proc "c" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2KHR);
+	ProcCmdCopyImageToBuffer2KHR                                        :: #type proc "c" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2KHR);
+	ProcCmdBlitImage2KHR                                                :: #type proc "c" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2KHR);
+	ProcCmdResolveImage2KHR                                             :: #type proc "c" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2KHR);
+	ProcDebugReportCallbackEXT                                          :: #type proc "c" (flags: DebugReportFlagsEXT, objectType: DebugReportObjectTypeEXT, object: u64, location: int, messageCode: i32, pLayerPrefix: cstring, pMessage: cstring, pUserData: rawptr) -> b32;
+	ProcCreateDebugReportCallbackEXT                                    :: #type proc "c" (instance: Instance, pCreateInfo: ^DebugReportCallbackCreateInfoEXT, pAllocator: ^AllocationCallbacks, pCallback: ^DebugReportCallbackEXT) -> Result;
+	ProcDestroyDebugReportCallbackEXT                                   :: #type proc "c" (instance: Instance, callback: DebugReportCallbackEXT, pAllocator: ^AllocationCallbacks);
+	ProcDebugReportMessageEXT                                           :: #type proc "c" (instance: Instance, flags: DebugReportFlagsEXT, objectType: DebugReportObjectTypeEXT, object: u64, location: int, messageCode: i32, pLayerPrefix: cstring, pMessage: cstring);
+	ProcDebugMarkerSetObjectTagEXT                                      :: #type proc "c" (device: Device, pTagInfo: ^DebugMarkerObjectTagInfoEXT) -> Result;
+	ProcDebugMarkerSetObjectNameEXT                                     :: #type proc "c" (device: Device, pNameInfo: ^DebugMarkerObjectNameInfoEXT) -> Result;
+	ProcCmdDebugMarkerBeginEXT                                          :: #type proc "c" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT);
+	ProcCmdDebugMarkerEndEXT                                            :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdDebugMarkerInsertEXT                                         :: #type proc "c" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT);
+	ProcCmdBindTransformFeedbackBuffersEXT                              :: #type proc "c" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize, pSizes: ^DeviceSize);
+	ProcCmdBeginTransformFeedbackEXT                                    :: #type proc "c" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: ^Buffer, pCounterBufferOffsets: ^DeviceSize);
+	ProcCmdEndTransformFeedbackEXT                                      :: #type proc "c" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: ^Buffer, pCounterBufferOffsets: ^DeviceSize);
+	ProcCmdBeginQueryIndexedEXT                                         :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags, index: u32);
+	ProcCmdEndQueryIndexedEXT                                           :: #type proc "c" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, index: u32);
+	ProcCmdDrawIndirectByteCountEXT                                     :: #type proc "c" (commandBuffer: CommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: Buffer, counterBufferOffset: DeviceSize, counterOffset: u32, vertexStride: u32);
+	ProcCreateCuModuleNVX                                               :: #type proc "c" (device: Device, pCreateInfo: ^CuModuleCreateInfoNVX, pAllocator: ^AllocationCallbacks, pModule: ^CuModuleNVX) -> Result;
+	ProcCreateCuFunctionNVX                                             :: #type proc "c" (device: Device, pCreateInfo: ^CuFunctionCreateInfoNVX, pAllocator: ^AllocationCallbacks, pFunction: ^CuFunctionNVX) -> Result;
+	ProcDestroyCuModuleNVX                                              :: #type proc "c" (device: Device, module: CuModuleNVX, pAllocator: ^AllocationCallbacks);
+	ProcDestroyCuFunctionNVX                                            :: #type proc "c" (device: Device, function: CuFunctionNVX, pAllocator: ^AllocationCallbacks);
+	ProcCmdCuLaunchKernelNVX                                            :: #type proc "c" (commandBuffer: CommandBuffer, pLaunchInfo: ^CuLaunchInfoNVX);
+	ProcGetImageViewHandleNVX                                           :: #type proc "c" (device: Device, pInfo: ^ImageViewHandleInfoNVX) -> u32;
+	ProcGetImageViewAddressNVX                                          :: #type proc "c" (device: Device, imageView: ImageView, pProperties: ^ImageViewAddressPropertiesNVX) -> Result;
+	ProcCmdDrawIndirectCountAMD                                         :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdDrawIndexedIndirectCountAMD                                  :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcGetShaderInfoAMD                                                :: #type proc "c" (device: Device, pipeline: Pipeline, shaderStage: ShaderStageFlags, infoType: ShaderInfoTypeAMD, pInfoSize: ^int, pInfo: rawptr) -> Result;
+	ProcGetPhysicalDeviceExternalImageFormatPropertiesNV                :: #type proc "c" (physicalDevice: PhysicalDevice, format: Format, type: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, externalHandleType: ExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ^ExternalImageFormatPropertiesNV) -> Result;
+	ProcCmdBeginConditionalRenderingEXT                                 :: #type proc "c" (commandBuffer: CommandBuffer, pConditionalRenderingBegin: ^ConditionalRenderingBeginInfoEXT);
+	ProcCmdEndConditionalRenderingEXT                                   :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdSetViewportWScalingNV                                        :: #type proc "c" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: ^ViewportWScalingNV);
+	ProcReleaseDisplayEXT                                               :: #type proc "c" (physicalDevice: PhysicalDevice, display: DisplayKHR) -> Result;
+	ProcGetPhysicalDeviceSurfaceCapabilities2EXT                        :: #type proc "c" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pSurfaceCapabilities: ^SurfaceCapabilities2EXT) -> Result;
+	ProcDisplayPowerControlEXT                                          :: #type proc "c" (device: Device, display: DisplayKHR, pDisplayPowerInfo: ^DisplayPowerInfoEXT) -> Result;
+	ProcRegisterDeviceEventEXT                                          :: #type proc "c" (device: Device, pDeviceEventInfo: ^DeviceEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcRegisterDisplayEventEXT                                         :: #type proc "c" (device: Device, display: DisplayKHR, pDisplayEventInfo: ^DisplayEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result;
+	ProcGetSwapchainCounterEXT                                          :: #type proc "c" (device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, pCounterValue: ^u64) -> Result;
+	ProcGetRefreshCycleDurationGOOGLE                                   :: #type proc "c" (device: Device, swapchain: SwapchainKHR, pDisplayTimingProperties: ^RefreshCycleDurationGOOGLE) -> Result;
+	ProcGetPastPresentationTimingGOOGLE                                 :: #type proc "c" (device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: ^u32, pPresentationTimings: ^PastPresentationTimingGOOGLE) -> Result;
+	ProcCmdSetDiscardRectangleEXT                                       :: #type proc "c" (commandBuffer: CommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: ^Rect2D);
+	ProcSetHdrMetadataEXT                                               :: #type proc "c" (device: Device, swapchainCount: u32, pSwapchains: ^SwapchainKHR, pMetadata: ^HdrMetadataEXT);
+	ProcDebugUtilsMessengerCallbackEXT                                  :: #type proc "c" (messageSeverity: DebugUtilsMessageSeverityFlagsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: ^DebugUtilsMessengerCallbackDataEXT, pUserData: rawptr) -> b32;
+	ProcSetDebugUtilsObjectNameEXT                                      :: #type proc "c" (device: Device, pNameInfo: ^DebugUtilsObjectNameInfoEXT) -> Result;
+	ProcSetDebugUtilsObjectTagEXT                                       :: #type proc "c" (device: Device, pTagInfo: ^DebugUtilsObjectTagInfoEXT) -> Result;
+	ProcQueueBeginDebugUtilsLabelEXT                                    :: #type proc "c" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcQueueEndDebugUtilsLabelEXT                                      :: #type proc "c" (queue: Queue);
+	ProcQueueInsertDebugUtilsLabelEXT                                   :: #type proc "c" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCmdBeginDebugUtilsLabelEXT                                      :: #type proc "c" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCmdEndDebugUtilsLabelEXT                                        :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdInsertDebugUtilsLabelEXT                                     :: #type proc "c" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT);
+	ProcCreateDebugUtilsMessengerEXT                                    :: #type proc "c" (instance: Instance, pCreateInfo: ^DebugUtilsMessengerCreateInfoEXT, pAllocator: ^AllocationCallbacks, pMessenger: ^DebugUtilsMessengerEXT) -> Result;
+	ProcDestroyDebugUtilsMessengerEXT                                   :: #type proc "c" (instance: Instance, messenger: DebugUtilsMessengerEXT, pAllocator: ^AllocationCallbacks);
+	ProcSubmitDebugUtilsMessageEXT                                      :: #type proc "c" (instance: Instance, messageSeverity: DebugUtilsMessageSeverityFlagsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: ^DebugUtilsMessengerCallbackDataEXT);
+	ProcCmdSetSampleLocationsEXT                                        :: #type proc "c" (commandBuffer: CommandBuffer, pSampleLocationsInfo: ^SampleLocationsInfoEXT);
+	ProcGetPhysicalDeviceMultisamplePropertiesEXT                       :: #type proc "c" (physicalDevice: PhysicalDevice, samples: SampleCountFlags, pMultisampleProperties: ^MultisamplePropertiesEXT);
+	ProcGetImageDrmFormatModifierPropertiesEXT                          :: #type proc "c" (device: Device, image: Image, pProperties: ^ImageDrmFormatModifierPropertiesEXT) -> Result;
+	ProcCreateValidationCacheEXT                                        :: #type proc "c" (device: Device, pCreateInfo: ^ValidationCacheCreateInfoEXT, pAllocator: ^AllocationCallbacks, pValidationCache: ^ValidationCacheEXT) -> Result;
+	ProcDestroyValidationCacheEXT                                       :: #type proc "c" (device: Device, validationCache: ValidationCacheEXT, pAllocator: ^AllocationCallbacks);
+	ProcMergeValidationCachesEXT                                        :: #type proc "c" (device: Device, dstCache: ValidationCacheEXT, srcCacheCount: u32, pSrcCaches: ^ValidationCacheEXT) -> Result;
+	ProcGetValidationCacheDataEXT                                       :: #type proc "c" (device: Device, validationCache: ValidationCacheEXT, pDataSize: ^int, pData: rawptr) -> Result;
+	ProcCmdBindShadingRateImageNV                                       :: #type proc "c" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout);
+	ProcCmdSetViewportShadingRatePaletteNV                              :: #type proc "c" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: ^ShadingRatePaletteNV);
+	ProcCmdSetCoarseSampleOrderNV                                       :: #type proc "c" (commandBuffer: CommandBuffer, sampleOrderType: CoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: ^CoarseSampleOrderCustomNV);
+	ProcCreateAccelerationStructureNV                                   :: #type proc "c" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoNV, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureNV) -> Result;
+	ProcDestroyAccelerationStructureNV                                  :: #type proc "c" (device: Device, accelerationStructure: AccelerationStructureNV, pAllocator: ^AllocationCallbacks);
+	ProcGetAccelerationStructureMemoryRequirementsNV                    :: #type proc "c" (device: Device, pInfo: ^AccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ^MemoryRequirements2KHR);
+	ProcBindAccelerationStructureMemoryNV                               :: #type proc "c" (device: Device, bindInfoCount: u32, pBindInfos: ^BindAccelerationStructureMemoryInfoNV) -> Result;
+	ProcCmdBuildAccelerationStructureNV                                 :: #type proc "c" (commandBuffer: CommandBuffer, pInfo: ^AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: b32, dst: AccelerationStructureNV, src: AccelerationStructureNV, scratch: Buffer, scratchOffset: DeviceSize);
+	ProcCmdCopyAccelerationStructureNV                                  :: #type proc "c" (commandBuffer: CommandBuffer, dst: AccelerationStructureNV, src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR);
+	ProcCmdTraceRaysNV                                                  :: #type proc "c" (commandBuffer: CommandBuffer, raygenShaderBindingTableBuffer: Buffer, raygenShaderBindingOffset: DeviceSize, missShaderBindingTableBuffer: Buffer, missShaderBindingOffset: DeviceSize, missShaderBindingStride: DeviceSize, hitShaderBindingTableBuffer: Buffer, hitShaderBindingOffset: DeviceSize, hitShaderBindingStride: DeviceSize, callableShaderBindingTableBuffer: Buffer, callableShaderBindingOffset: DeviceSize, callableShaderBindingStride: DeviceSize, width: u32, height: u32, depth: u32);
+	ProcCreateRayTracingPipelinesNV                                     :: #type proc "c" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^RayTracingPipelineCreateInfoNV, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcGetRayTracingShaderGroupHandlesKHR                              :: #type proc "c" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcGetRayTracingShaderGroupHandlesNV                               :: #type proc "c" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcGetAccelerationStructureHandleNV                                :: #type proc "c" (device: Device, accelerationStructure: AccelerationStructureNV, dataSize: int, pData: rawptr) -> Result;
+	ProcCmdWriteAccelerationStructuresPropertiesNV                      :: #type proc "c" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureNV, queryType: QueryType, queryPool: QueryPool, firstQuery: u32);
+	ProcCompileDeferredNV                                               :: #type proc "c" (device: Device, pipeline: Pipeline, shader: u32) -> Result;
+	ProcGetMemoryHostPointerPropertiesEXT                               :: #type proc "c" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHostPointer: rawptr, pMemoryHostPointerProperties: ^MemoryHostPointerPropertiesEXT) -> Result;
+	ProcCmdWriteBufferMarkerAMD                                         :: #type proc "c" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32);
+	ProcGetPhysicalDeviceCalibrateableTimeDomainsEXT                    :: #type proc "c" (physicalDevice: PhysicalDevice, pTimeDomainCount: ^u32, pTimeDomains: ^TimeDomainEXT) -> Result;
+	ProcGetCalibratedTimestampsEXT                                      :: #type proc "c" (device: Device, timestampCount: u32, pTimestampInfos: ^CalibratedTimestampInfoEXT, pTimestamps: ^u64, pMaxDeviation: ^u64) -> Result;
+	ProcCmdDrawMeshTasksNV                                              :: #type proc "c" (commandBuffer: CommandBuffer, taskCount: u32, firstTask: u32);
+	ProcCmdDrawMeshTasksIndirectNV                                      :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32);
+	ProcCmdDrawMeshTasksIndirectCountNV                                 :: #type proc "c" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32);
+	ProcCmdSetExclusiveScissorNV                                        :: #type proc "c" (commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: ^Rect2D);
+	ProcCmdSetCheckpointNV                                              :: #type proc "c" (commandBuffer: CommandBuffer, pCheckpointMarker: rawptr);
+	ProcGetQueueCheckpointDataNV                                        :: #type proc "c" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointDataNV);
+	ProcInitializePerformanceApiINTEL                                   :: #type proc "c" (device: Device, pInitializeInfo: ^InitializePerformanceApiInfoINTEL) -> Result;
+	ProcUninitializePerformanceApiINTEL                                 :: #type proc "c" (device: Device);
+	ProcCmdSetPerformanceMarkerINTEL                                    :: #type proc "c" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceMarkerInfoINTEL) -> Result;
+	ProcCmdSetPerformanceStreamMarkerINTEL                              :: #type proc "c" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceStreamMarkerInfoINTEL) -> Result;
+	ProcCmdSetPerformanceOverrideINTEL                                  :: #type proc "c" (commandBuffer: CommandBuffer, pOverrideInfo: ^PerformanceOverrideInfoINTEL) -> Result;
+	ProcAcquirePerformanceConfigurationINTEL                            :: #type proc "c" (device: Device, pAcquireInfo: ^PerformanceConfigurationAcquireInfoINTEL, pConfiguration: ^PerformanceConfigurationINTEL) -> Result;
+	ProcReleasePerformanceConfigurationINTEL                            :: #type proc "c" (device: Device, configuration: PerformanceConfigurationINTEL) -> Result;
+	ProcQueueSetPerformanceConfigurationINTEL                           :: #type proc "c" (queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result;
+	ProcGetPerformanceParameterINTEL                                    :: #type proc "c" (device: Device, parameter: PerformanceParameterTypeINTEL, pValue: ^PerformanceValueINTEL) -> Result;
+	ProcSetLocalDimmingAMD                                              :: #type proc "c" (device: Device, swapChain: SwapchainKHR, localDimmingEnable: b32);
+	ProcGetBufferDeviceAddressEXT                                       :: #type proc "c" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress;
+	ProcGetPhysicalDeviceToolPropertiesEXT                              :: #type proc "c" (physicalDevice: PhysicalDevice, pToolCount: ^u32, pToolProperties: ^PhysicalDeviceToolPropertiesEXT) -> Result;
+	ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV                  :: #type proc "c" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: ^CooperativeMatrixPropertiesNV) -> Result;
+	ProcGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV :: #type proc "c" (physicalDevice: PhysicalDevice, pCombinationCount: ^u32, pCombinations: ^FramebufferMixedSamplesCombinationNV) -> Result;
+	ProcCreateHeadlessSurfaceEXT                                        :: #type proc "c" (instance: Instance, pCreateInfo: ^HeadlessSurfaceCreateInfoEXT, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCmdSetLineStippleEXT                                            :: #type proc "c" (commandBuffer: CommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
+	ProcResetQueryPoolEXT                                               :: #type proc "c" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32);
+	ProcCmdSetCullModeEXT                                               :: #type proc "c" (commandBuffer: CommandBuffer, cullMode: CullModeFlags);
+	ProcCmdSetFrontFaceEXT                                              :: #type proc "c" (commandBuffer: CommandBuffer, frontFace: FrontFace);
+	ProcCmdSetPrimitiveTopologyEXT                                      :: #type proc "c" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology);
+	ProcCmdSetViewportWithCountEXT                                      :: #type proc "c" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: ^Viewport);
+	ProcCmdSetScissorWithCountEXT                                       :: #type proc "c" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: ^Rect2D);
+	ProcCmdBindVertexBuffers2EXT                                        :: #type proc "c" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: ^Buffer, pOffsets: ^DeviceSize, pSizes: ^DeviceSize, pStrides: ^DeviceSize);
+	ProcCmdSetDepthTestEnableEXT                                        :: #type proc "c" (commandBuffer: CommandBuffer, depthTestEnable: b32);
+	ProcCmdSetDepthWriteEnableEXT                                       :: #type proc "c" (commandBuffer: CommandBuffer, depthWriteEnable: b32);
+	ProcCmdSetDepthCompareOpEXT                                         :: #type proc "c" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp);
+	ProcCmdSetDepthBoundsTestEnableEXT                                  :: #type proc "c" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32);
+	ProcCmdSetStencilTestEnableEXT                                      :: #type proc "c" (commandBuffer: CommandBuffer, stencilTestEnable: b32);
+	ProcCmdSetStencilOpEXT                                              :: #type proc "c" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp);
+	ProcGetGeneratedCommandsMemoryRequirementsNV                        :: #type proc "c" (device: Device, pInfo: ^GeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ^MemoryRequirements2);
+	ProcCmdPreprocessGeneratedCommandsNV                                :: #type proc "c" (commandBuffer: CommandBuffer, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV);
+	ProcCmdExecuteGeneratedCommandsNV                                   :: #type proc "c" (commandBuffer: CommandBuffer, isPreprocessed: b32, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV);
+	ProcCmdBindPipelineShaderGroupNV                                    :: #type proc "c" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline, groupIndex: u32);
+	ProcCreateIndirectCommandsLayoutNV                                  :: #type proc "c" (device: Device, pCreateInfo: ^IndirectCommandsLayoutCreateInfoNV, pAllocator: ^AllocationCallbacks, pIndirectCommandsLayout: ^IndirectCommandsLayoutNV) -> Result;
+	ProcDestroyIndirectCommandsLayoutNV                                 :: #type proc "c" (device: Device, indirectCommandsLayout: IndirectCommandsLayoutNV, pAllocator: ^AllocationCallbacks);
+	ProcDeviceMemoryReportCallbackEXT                                   :: #type proc "c" (pCallbackData: ^DeviceMemoryReportCallbackDataEXT, pUserData: rawptr);
+	ProcAcquireDrmDisplayEXT                                            :: #type proc "c" (physicalDevice: PhysicalDevice, drmFd: i32, display: DisplayKHR) -> Result;
+	ProcGetDrmDisplayEXT                                                :: #type proc "c" (physicalDevice: PhysicalDevice, drmFd: i32, connectorId: u32, display: ^DisplayKHR) -> Result;
+	ProcCreatePrivateDataSlotEXT                                        :: #type proc "c" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfoEXT, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlotEXT) -> Result;
+	ProcDestroyPrivateDataSlotEXT                                       :: #type proc "c" (device: Device, privateDataSlot: PrivateDataSlotEXT, pAllocator: ^AllocationCallbacks);
+	ProcSetPrivateDataEXT                                               :: #type proc "c" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, data: u64) -> Result;
+	ProcGetPrivateDataEXT                                               :: #type proc "c" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlotEXT, pData: ^u64);
+	ProcCmdSetFragmentShadingRateEnumNV                                 :: #type proc "c" (commandBuffer: CommandBuffer, shadingRate: FragmentShadingRateNV);
+	ProcAcquireWinrtDisplayNV                                           :: #type proc "c" (physicalDevice: PhysicalDevice, display: DisplayKHR) -> Result;
+	ProcGetWinrtDisplayNV                                               :: #type proc "c" (physicalDevice: PhysicalDevice, deviceRelativeId: u32, pDisplay: ^DisplayKHR) -> Result;
+	ProcCmdSetVertexInputEXT                                            :: #type proc "c" (commandBuffer: CommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: ^VertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: ^VertexInputAttributeDescription2EXT);
+	ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI                   :: #type proc "c" (device: Device, renderpass: RenderPass, pMaxWorkgroupSize: ^Extent2D) -> Result;
+	ProcCmdSubpassShadingHUAWEI                                         :: #type proc "c" (commandBuffer: CommandBuffer);
+	ProcCmdBindInvocationMaskHUAWEI                                     :: #type proc "c" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout);
+	ProcGetMemoryRemoteAddressNV                                        :: #type proc "c" (device: Device, pMemoryGetRemoteAddressInfo: ^MemoryGetRemoteAddressInfoNV, pAddress: ^RemoteAddressNV) -> Result;
+	ProcCmdSetPatchControlPointsEXT                                     :: #type proc "c" (commandBuffer: CommandBuffer, patchControlPoints: u32);
+	ProcCmdSetRasterizerDiscardEnableEXT                                :: #type proc "c" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32);
+	ProcCmdSetDepthBiasEnableEXT                                        :: #type proc "c" (commandBuffer: CommandBuffer, depthBiasEnable: b32);
+	ProcCmdSetLogicOpEXT                                                :: #type proc "c" (commandBuffer: CommandBuffer, logicOp: LogicOp);
+	ProcCmdSetPrimitiveRestartEnableEXT                                 :: #type proc "c" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32);
+	ProcCmdDrawMultiEXT                                                 :: #type proc "c" (commandBuffer: CommandBuffer, drawCount: u32, pVertexInfo: ^MultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
+	ProcCmdDrawMultiIndexedEXT                                          :: #type proc "c" (commandBuffer: CommandBuffer, drawCount: u32, pIndexInfo: ^MultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: ^i32);
+	ProcCreateAccelerationStructureKHR                                  :: #type proc "c" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoKHR, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureKHR) -> Result;
+	ProcDestroyAccelerationStructureKHR                                 :: #type proc "c" (device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: ^AllocationCallbacks);
+	ProcCmdBuildAccelerationStructuresKHR                               :: #type proc "c" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^^AccelerationStructureBuildRangeInfoKHR);
+	ProcCmdBuildAccelerationStructuresIndirectKHR                       :: #type proc "c" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: ^DeviceAddress, pIndirectStrides: ^u32, ppMaxPrimitiveCounts: ^^u32);
+	ProcBuildAccelerationStructuresKHR                                  :: #type proc "c" (device: Device, deferredOperation: DeferredOperationKHR, infoCount: u32, pInfos: ^AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^^AccelerationStructureBuildRangeInfoKHR) -> Result;
+	ProcCopyAccelerationStructureKHR                                    :: #type proc "c" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureInfoKHR) -> Result;
+	ProcCopyAccelerationStructureToMemoryKHR                            :: #type proc "c" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -> Result;
+	ProcCopyMemoryToAccelerationStructureKHR                            :: #type proc "c" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) -> Result;
+	ProcWriteAccelerationStructuresPropertiesKHR                        :: #type proc "c" (device: Device, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureKHR, queryType: QueryType, dataSize: int, pData: rawptr, stride: int) -> Result;
+	ProcCmdCopyAccelerationStructureKHR                                 :: #type proc "c" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureInfoKHR);
+	ProcCmdCopyAccelerationStructureToMemoryKHR                         :: #type proc "c" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR);
+	ProcCmdCopyMemoryToAccelerationStructureKHR                         :: #type proc "c" (commandBuffer: CommandBuffer, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR);
+	ProcGetAccelerationStructureDeviceAddressKHR                        :: #type proc "c" (device: Device, pInfo: ^AccelerationStructureDeviceAddressInfoKHR) -> DeviceAddress;
+	ProcCmdWriteAccelerationStructuresPropertiesKHR                     :: #type proc "c" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: ^AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32);
+	ProcGetDeviceAccelerationStructureCompatibilityKHR                  :: #type proc "c" (device: Device, pVersionInfo: ^AccelerationStructureVersionInfoKHR, pCompatibility: ^AccelerationStructureCompatibilityKHR);
+	ProcGetAccelerationStructureBuildSizesKHR                           :: #type proc "c" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^AccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ^u32, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR);
+	ProcCmdTraceRaysKHR                                                 :: #type proc "c" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: ^StridedDeviceAddressRegionKHR, pMissShaderBindingTable: ^StridedDeviceAddressRegionKHR, pHitShaderBindingTable: ^StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ^StridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
+	ProcCreateRayTracingPipelinesKHR                                    :: #type proc "c" (device: Device, deferredOperation: DeferredOperationKHR, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: ^RayTracingPipelineCreateInfoKHR, pAllocator: ^AllocationCallbacks, pPipelines: ^Pipeline) -> Result;
+	ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR                 :: #type proc "c" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result;
+	ProcCmdTraceRaysIndirectKHR                                         :: #type proc "c" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: ^StridedDeviceAddressRegionKHR, pMissShaderBindingTable: ^StridedDeviceAddressRegionKHR, pHitShaderBindingTable: ^StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ^StridedDeviceAddressRegionKHR, indirectDeviceAddress: DeviceAddress);
+	ProcGetRayTracingShaderGroupStackSizeKHR                            :: #type proc "c" (device: Device, pipeline: Pipeline, group: u32, groupShader: ShaderGroupShaderKHR) -> DeviceSize;
+	ProcCmdSetRayTracingPipelineStackSizeKHR                            :: #type proc "c" (commandBuffer: CommandBuffer, pipelineStackSize: u32);
+	ProcGetPhysicalDeviceProcAddr                                       :: #type proc "c" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcNegotiateLoaderLayerInterfaceVersion                            :: #type proc "c" (pVersionStruct: ^NegotiateLayerInterface ) -> Result;
+	ProcSetInstanceLoaderData                                           :: #type proc "c" (instance: Instance, object: rawptr) -> Result;
+	ProcSetDeviceLoaderData                                             :: #type proc "c" (device: Device, object: rawptr) -> Result;
+	ProcLayerCreateDevice                                               :: #type proc "c" (instance: Instance, physicalDevice: PhysicalDevice, pCreateInfo: ^DeviceCreateInfo , pAllocator: ^AllocationCallbacks , pDevice: ^Device , layerGIPA: ProcGetInstanceProcAddr, nextGDPA: ^ProcGetDeviceProcAddr ) -> Result;
+	ProcLayerDestroyDevice                                              :: #type proc "c" (physicalDevice: Device, pAllocator: ^AllocationCallbacks , destroyFunction: ProcDestroyDevice);
+	ProcicdNegotiateLoaderICDInterfaceVersion                           :: #type proc "c" (pVersion: ^u32) -> Result;
+	ProcicdGetInstanceProcAddr                                          :: #type proc "c" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcicdGetPhysicalDeviceProcAddr                                    :: #type proc "c" (instance: Instance, pName: cstring) -> ProcVoidFunction;
+	ProcicdEnumerateAdapterPhysicalDevices                              :: #type proc "c" (instance: Instance, adapterLUID: LUID, pPhysicalDeviceCount: ^u32, pPhysicalDevices: ^PhysicalDevice) -> Result;
+	ProcCreateWin32SurfaceKHR                                           :: #type proc "c" (instance: Instance, pCreateInfo: ^Win32SurfaceCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcGetPhysicalDeviceWin32PresentationSupportKHR                    :: #type proc "c" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32) -> b32;
+	ProcGetMemoryWin32HandleKHR                                         :: #type proc "c" (device: Device, pGetWin32HandleInfo: ^MemoryGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcGetMemoryWin32HandlePropertiesKHR                               :: #type proc "c" (device: Device, handleType: ExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: ^MemoryWin32HandlePropertiesKHR) -> Result;
+	ProcImportSemaphoreWin32HandleKHR                                   :: #type proc "c" (device: Device, pImportSemaphoreWin32HandleInfo: ^ImportSemaphoreWin32HandleInfoKHR) -> Result;
+	ProcGetSemaphoreWin32HandleKHR                                      :: #type proc "c" (device: Device, pGetWin32HandleInfo: ^SemaphoreGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcImportFenceWin32HandleKHR                                       :: #type proc "c" (device: Device, pImportFenceWin32HandleInfo: ^ImportFenceWin32HandleInfoKHR) -> Result;
+	ProcGetFenceWin32HandleKHR                                          :: #type proc "c" (device: Device, pGetWin32HandleInfo: ^FenceGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result;
+	ProcGetMemoryWin32HandleNV                                          :: #type proc "c" (device: Device, memory: DeviceMemory, handleType: ExternalMemoryHandleTypeFlagsNV, pHandle: ^HANDLE) -> Result;
+	ProcGetPhysicalDeviceSurfacePresentModes2EXT                        :: #type proc "c" (physicalDevice: PhysicalDevice, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pPresentModeCount: ^u32, pPresentModes: ^PresentModeKHR) -> Result;
+	ProcAcquireFullScreenExclusiveModeEXT                               :: #type proc "c" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcReleaseFullScreenExclusiveModeEXT                               :: #type proc "c" (device: Device, swapchain: SwapchainKHR) -> Result;
+	ProcGetDeviceGroupSurfacePresentModes2EXT                           :: #type proc "c" (device: Device, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pModes: ^DeviceGroupPresentModeFlagsKHR) -> Result;
+	ProcCreateMetalSurfaceEXT                                           :: #type proc "c" (instance: Instance, pCreateInfo: ^MetalSurfaceCreateInfoEXT, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateMacOSSurfaceMVK                                           :: #type proc "c" (instance: Instance, pCreateInfo: ^MacOSSurfaceCreateInfoMVK, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+	ProcCreateIOSSurfaceMVK                                             :: #type proc "c" (instance: Instance, pCreateInfo: ^IOSSurfaceCreateInfoMVK, pAllocator: ^AllocationCallbacks, pSurface: ^SurfaceKHR) -> Result;
+}
+
+
+// Instance Procedures
+DestroyInstance:                                                 ProcDestroyInstance;
+EnumeratePhysicalDevices:                                        ProcEnumeratePhysicalDevices;
+GetPhysicalDeviceFeatures:                                       ProcGetPhysicalDeviceFeatures;
+GetPhysicalDeviceFormatProperties:                               ProcGetPhysicalDeviceFormatProperties;
+GetPhysicalDeviceImageFormatProperties:                          ProcGetPhysicalDeviceImageFormatProperties;
+GetPhysicalDeviceProperties:                                     ProcGetPhysicalDeviceProperties;
+GetPhysicalDeviceQueueFamilyProperties:                          ProcGetPhysicalDeviceQueueFamilyProperties;
+GetPhysicalDeviceMemoryProperties:                               ProcGetPhysicalDeviceMemoryProperties;
+GetInstanceProcAddr:                                             ProcGetInstanceProcAddr;
+CreateDevice:                                                    ProcCreateDevice;
+EnumerateDeviceExtensionProperties:                              ProcEnumerateDeviceExtensionProperties;
+EnumerateDeviceLayerProperties:                                  ProcEnumerateDeviceLayerProperties;
+GetPhysicalDeviceSparseImageFormatProperties:                    ProcGetPhysicalDeviceSparseImageFormatProperties;
+EnumeratePhysicalDeviceGroups:                                   ProcEnumeratePhysicalDeviceGroups;
+GetPhysicalDeviceFeatures2:                                      ProcGetPhysicalDeviceFeatures2;
+GetPhysicalDeviceProperties2:                                    ProcGetPhysicalDeviceProperties2;
+GetPhysicalDeviceFormatProperties2:                              ProcGetPhysicalDeviceFormatProperties2;
+GetPhysicalDeviceImageFormatProperties2:                         ProcGetPhysicalDeviceImageFormatProperties2;
+GetPhysicalDeviceQueueFamilyProperties2:                         ProcGetPhysicalDeviceQueueFamilyProperties2;
+GetPhysicalDeviceMemoryProperties2:                              ProcGetPhysicalDeviceMemoryProperties2;
+GetPhysicalDeviceSparseImageFormatProperties2:                   ProcGetPhysicalDeviceSparseImageFormatProperties2;
+GetPhysicalDeviceExternalBufferProperties:                       ProcGetPhysicalDeviceExternalBufferProperties;
+GetPhysicalDeviceExternalFenceProperties:                        ProcGetPhysicalDeviceExternalFenceProperties;
+GetPhysicalDeviceExternalSemaphoreProperties:                    ProcGetPhysicalDeviceExternalSemaphoreProperties;
+DestroySurfaceKHR:                                               ProcDestroySurfaceKHR;
+GetPhysicalDeviceSurfaceSupportKHR:                              ProcGetPhysicalDeviceSurfaceSupportKHR;
+GetPhysicalDeviceSurfaceCapabilitiesKHR:                         ProcGetPhysicalDeviceSurfaceCapabilitiesKHR;
+GetPhysicalDeviceSurfaceFormatsKHR:                              ProcGetPhysicalDeviceSurfaceFormatsKHR;
+GetPhysicalDeviceSurfacePresentModesKHR:                         ProcGetPhysicalDeviceSurfacePresentModesKHR;
+GetPhysicalDevicePresentRectanglesKHR:                           ProcGetPhysicalDevicePresentRectanglesKHR;
+GetPhysicalDeviceDisplayPropertiesKHR:                           ProcGetPhysicalDeviceDisplayPropertiesKHR;
+GetPhysicalDeviceDisplayPlanePropertiesKHR:                      ProcGetPhysicalDeviceDisplayPlanePropertiesKHR;
+GetDisplayPlaneSupportedDisplaysKHR:                             ProcGetDisplayPlaneSupportedDisplaysKHR;
+GetDisplayModePropertiesKHR:                                     ProcGetDisplayModePropertiesKHR;
+CreateDisplayModeKHR:                                            ProcCreateDisplayModeKHR;
+GetDisplayPlaneCapabilitiesKHR:                                  ProcGetDisplayPlaneCapabilitiesKHR;
+CreateDisplayPlaneSurfaceKHR:                                    ProcCreateDisplayPlaneSurfaceKHR;
+GetPhysicalDeviceFeatures2KHR:                                   ProcGetPhysicalDeviceFeatures2KHR;
+GetPhysicalDeviceProperties2KHR:                                 ProcGetPhysicalDeviceProperties2KHR;
+GetPhysicalDeviceFormatProperties2KHR:                           ProcGetPhysicalDeviceFormatProperties2KHR;
+GetPhysicalDeviceImageFormatProperties2KHR:                      ProcGetPhysicalDeviceImageFormatProperties2KHR;
+GetPhysicalDeviceQueueFamilyProperties2KHR:                      ProcGetPhysicalDeviceQueueFamilyProperties2KHR;
+GetPhysicalDeviceMemoryProperties2KHR:                           ProcGetPhysicalDeviceMemoryProperties2KHR;
+GetPhysicalDeviceSparseImageFormatProperties2KHR:                ProcGetPhysicalDeviceSparseImageFormatProperties2KHR;
+EnumeratePhysicalDeviceGroupsKHR:                                ProcEnumeratePhysicalDeviceGroupsKHR;
+GetPhysicalDeviceExternalBufferPropertiesKHR:                    ProcGetPhysicalDeviceExternalBufferPropertiesKHR;
+GetPhysicalDeviceExternalSemaphorePropertiesKHR:                 ProcGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+GetPhysicalDeviceExternalFencePropertiesKHR:                     ProcGetPhysicalDeviceExternalFencePropertiesKHR;
+EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR:   ProcEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR:           ProcGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
+GetPhysicalDeviceSurfaceCapabilities2KHR:                        ProcGetPhysicalDeviceSurfaceCapabilities2KHR;
+GetPhysicalDeviceSurfaceFormats2KHR:                             ProcGetPhysicalDeviceSurfaceFormats2KHR;
+GetPhysicalDeviceDisplayProperties2KHR:                          ProcGetPhysicalDeviceDisplayProperties2KHR;
+GetPhysicalDeviceDisplayPlaneProperties2KHR:                     ProcGetPhysicalDeviceDisplayPlaneProperties2KHR;
+GetDisplayModeProperties2KHR:                                    ProcGetDisplayModeProperties2KHR;
+GetDisplayPlaneCapabilities2KHR:                                 ProcGetDisplayPlaneCapabilities2KHR;
+GetPhysicalDeviceFragmentShadingRatesKHR:                        ProcGetPhysicalDeviceFragmentShadingRatesKHR;
+CreateDebugReportCallbackEXT:                                    ProcCreateDebugReportCallbackEXT;
+DestroyDebugReportCallbackEXT:                                   ProcDestroyDebugReportCallbackEXT;
+DebugReportMessageEXT:                                           ProcDebugReportMessageEXT;
+GetPhysicalDeviceExternalImageFormatPropertiesNV:                ProcGetPhysicalDeviceExternalImageFormatPropertiesNV;
+ReleaseDisplayEXT:                                               ProcReleaseDisplayEXT;
+GetPhysicalDeviceSurfaceCapabilities2EXT:                        ProcGetPhysicalDeviceSurfaceCapabilities2EXT;
+CreateDebugUtilsMessengerEXT:                                    ProcCreateDebugUtilsMessengerEXT;
+DestroyDebugUtilsMessengerEXT:                                   ProcDestroyDebugUtilsMessengerEXT;
+SubmitDebugUtilsMessageEXT:                                      ProcSubmitDebugUtilsMessageEXT;
+GetPhysicalDeviceMultisamplePropertiesEXT:                       ProcGetPhysicalDeviceMultisamplePropertiesEXT;
+GetPhysicalDeviceCalibrateableTimeDomainsEXT:                    ProcGetPhysicalDeviceCalibrateableTimeDomainsEXT;
+GetPhysicalDeviceToolPropertiesEXT:                              ProcGetPhysicalDeviceToolPropertiesEXT;
+GetPhysicalDeviceCooperativeMatrixPropertiesNV:                  ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV;
+GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: ProcGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
+CreateHeadlessSurfaceEXT:                                        ProcCreateHeadlessSurfaceEXT;
+AcquireDrmDisplayEXT:                                            ProcAcquireDrmDisplayEXT;
+GetDrmDisplayEXT:                                                ProcGetDrmDisplayEXT;
+AcquireWinrtDisplayNV:                                           ProcAcquireWinrtDisplayNV;
+GetWinrtDisplayNV:                                               ProcGetWinrtDisplayNV;
+GetPhysicalDeviceProcAddr:                                       ProcGetPhysicalDeviceProcAddr;
+SetInstanceLoaderData:                                           ProcSetInstanceLoaderData;
+LayerCreateDevice:                                               ProcLayerCreateDevice;
+icdGetInstanceProcAddr:                                          ProcicdGetInstanceProcAddr;
+icdGetPhysicalDeviceProcAddr:                                    ProcicdGetPhysicalDeviceProcAddr;
+icdEnumerateAdapterPhysicalDevices:                              ProcicdEnumerateAdapterPhysicalDevices;
+CreateWin32SurfaceKHR:                                           ProcCreateWin32SurfaceKHR;
+GetPhysicalDeviceWin32PresentationSupportKHR:                    ProcGetPhysicalDeviceWin32PresentationSupportKHR;
+GetPhysicalDeviceSurfacePresentModes2EXT:                        ProcGetPhysicalDeviceSurfacePresentModes2EXT;
+CreateMetalSurfaceEXT:                                           ProcCreateMetalSurfaceEXT;
+CreateMacOSSurfaceMVK:                                           ProcCreateMacOSSurfaceMVK;
+CreateIOSSurfaceMVK:                                             ProcCreateIOSSurfaceMVK;
+
+// Device Procedures
+GetDeviceProcAddr:                               ProcGetDeviceProcAddr;
+DestroyDevice:                                   ProcDestroyDevice;
+GetDeviceQueue:                                  ProcGetDeviceQueue;
+QueueSubmit:                                     ProcQueueSubmit;
+QueueWaitIdle:                                   ProcQueueWaitIdle;
+DeviceWaitIdle:                                  ProcDeviceWaitIdle;
+AllocateMemory:                                  ProcAllocateMemory;
+FreeMemory:                                      ProcFreeMemory;
+MapMemory:                                       ProcMapMemory;
+UnmapMemory:                                     ProcUnmapMemory;
+FlushMappedMemoryRanges:                         ProcFlushMappedMemoryRanges;
+InvalidateMappedMemoryRanges:                    ProcInvalidateMappedMemoryRanges;
+GetDeviceMemoryCommitment:                       ProcGetDeviceMemoryCommitment;
+BindBufferMemory:                                ProcBindBufferMemory;
+BindImageMemory:                                 ProcBindImageMemory;
+GetBufferMemoryRequirements:                     ProcGetBufferMemoryRequirements;
+GetImageMemoryRequirements:                      ProcGetImageMemoryRequirements;
+GetImageSparseMemoryRequirements:                ProcGetImageSparseMemoryRequirements;
+QueueBindSparse:                                 ProcQueueBindSparse;
+CreateFence:                                     ProcCreateFence;
+DestroyFence:                                    ProcDestroyFence;
+ResetFences:                                     ProcResetFences;
+GetFenceStatus:                                  ProcGetFenceStatus;
+WaitForFences:                                   ProcWaitForFences;
+CreateSemaphore:                                 ProcCreateSemaphore;
+DestroySemaphore:                                ProcDestroySemaphore;
+CreateEvent:                                     ProcCreateEvent;
+DestroyEvent:                                    ProcDestroyEvent;
+GetEventStatus:                                  ProcGetEventStatus;
+SetEvent:                                        ProcSetEvent;
+ResetEvent:                                      ProcResetEvent;
+CreateQueryPool:                                 ProcCreateQueryPool;
+DestroyQueryPool:                                ProcDestroyQueryPool;
+GetQueryPoolResults:                             ProcGetQueryPoolResults;
+CreateBuffer:                                    ProcCreateBuffer;
+DestroyBuffer:                                   ProcDestroyBuffer;
+CreateBufferView:                                ProcCreateBufferView;
+DestroyBufferView:                               ProcDestroyBufferView;
+CreateImage:                                     ProcCreateImage;
+DestroyImage:                                    ProcDestroyImage;
+GetImageSubresourceLayout:                       ProcGetImageSubresourceLayout;
+CreateImageView:                                 ProcCreateImageView;
+DestroyImageView:                                ProcDestroyImageView;
+CreateShaderModule:                              ProcCreateShaderModule;
+DestroyShaderModule:                             ProcDestroyShaderModule;
+CreatePipelineCache:                             ProcCreatePipelineCache;
+DestroyPipelineCache:                            ProcDestroyPipelineCache;
+GetPipelineCacheData:                            ProcGetPipelineCacheData;
+MergePipelineCaches:                             ProcMergePipelineCaches;
+CreateGraphicsPipelines:                         ProcCreateGraphicsPipelines;
+CreateComputePipelines:                          ProcCreateComputePipelines;
+DestroyPipeline:                                 ProcDestroyPipeline;
+CreatePipelineLayout:                            ProcCreatePipelineLayout;
+DestroyPipelineLayout:                           ProcDestroyPipelineLayout;
+CreateSampler:                                   ProcCreateSampler;
+DestroySampler:                                  ProcDestroySampler;
+CreateDescriptorSetLayout:                       ProcCreateDescriptorSetLayout;
+DestroyDescriptorSetLayout:                      ProcDestroyDescriptorSetLayout;
+CreateDescriptorPool:                            ProcCreateDescriptorPool;
+DestroyDescriptorPool:                           ProcDestroyDescriptorPool;
+ResetDescriptorPool:                             ProcResetDescriptorPool;
+AllocateDescriptorSets:                          ProcAllocateDescriptorSets;
+FreeDescriptorSets:                              ProcFreeDescriptorSets;
+UpdateDescriptorSets:                            ProcUpdateDescriptorSets;
+CreateFramebuffer:                               ProcCreateFramebuffer;
+DestroyFramebuffer:                              ProcDestroyFramebuffer;
+CreateRenderPass:                                ProcCreateRenderPass;
+DestroyRenderPass:                               ProcDestroyRenderPass;
+GetRenderAreaGranularity:                        ProcGetRenderAreaGranularity;
+CreateCommandPool:                               ProcCreateCommandPool;
+DestroyCommandPool:                              ProcDestroyCommandPool;
+ResetCommandPool:                                ProcResetCommandPool;
+AllocateCommandBuffers:                          ProcAllocateCommandBuffers;
+FreeCommandBuffers:                              ProcFreeCommandBuffers;
+BeginCommandBuffer:                              ProcBeginCommandBuffer;
+EndCommandBuffer:                                ProcEndCommandBuffer;
+ResetCommandBuffer:                              ProcResetCommandBuffer;
+CmdBindPipeline:                                 ProcCmdBindPipeline;
+CmdSetViewport:                                  ProcCmdSetViewport;
+CmdSetScissor:                                   ProcCmdSetScissor;
+CmdSetLineWidth:                                 ProcCmdSetLineWidth;
+CmdSetDepthBias:                                 ProcCmdSetDepthBias;
+CmdSetBlendConstants:                            ProcCmdSetBlendConstants;
+CmdSetDepthBounds:                               ProcCmdSetDepthBounds;
+CmdSetStencilCompareMask:                        ProcCmdSetStencilCompareMask;
+CmdSetStencilWriteMask:                          ProcCmdSetStencilWriteMask;
+CmdSetStencilReference:                          ProcCmdSetStencilReference;
+CmdBindDescriptorSets:                           ProcCmdBindDescriptorSets;
+CmdBindIndexBuffer:                              ProcCmdBindIndexBuffer;
+CmdBindVertexBuffers:                            ProcCmdBindVertexBuffers;
+CmdDraw:                                         ProcCmdDraw;
+CmdDrawIndexed:                                  ProcCmdDrawIndexed;
+CmdDrawIndirect:                                 ProcCmdDrawIndirect;
+CmdDrawIndexedIndirect:                          ProcCmdDrawIndexedIndirect;
+CmdDispatch:                                     ProcCmdDispatch;
+CmdDispatchIndirect:                             ProcCmdDispatchIndirect;
+CmdCopyBuffer:                                   ProcCmdCopyBuffer;
+CmdCopyImage:                                    ProcCmdCopyImage;
+CmdBlitImage:                                    ProcCmdBlitImage;
+CmdCopyBufferToImage:                            ProcCmdCopyBufferToImage;
+CmdCopyImageToBuffer:                            ProcCmdCopyImageToBuffer;
+CmdUpdateBuffer:                                 ProcCmdUpdateBuffer;
+CmdFillBuffer:                                   ProcCmdFillBuffer;
+CmdClearColorImage:                              ProcCmdClearColorImage;
+CmdClearDepthStencilImage:                       ProcCmdClearDepthStencilImage;
+CmdClearAttachments:                             ProcCmdClearAttachments;
+CmdResolveImage:                                 ProcCmdResolveImage;
+CmdSetEvent:                                     ProcCmdSetEvent;
+CmdResetEvent:                                   ProcCmdResetEvent;
+CmdWaitEvents:                                   ProcCmdWaitEvents;
+CmdPipelineBarrier:                              ProcCmdPipelineBarrier;
+CmdBeginQuery:                                   ProcCmdBeginQuery;
+CmdEndQuery:                                     ProcCmdEndQuery;
+CmdResetQueryPool:                               ProcCmdResetQueryPool;
+CmdWriteTimestamp:                               ProcCmdWriteTimestamp;
+CmdCopyQueryPoolResults:                         ProcCmdCopyQueryPoolResults;
+CmdPushConstants:                                ProcCmdPushConstants;
+CmdBeginRenderPass:                              ProcCmdBeginRenderPass;
+CmdNextSubpass:                                  ProcCmdNextSubpass;
+CmdEndRenderPass:                                ProcCmdEndRenderPass;
+CmdExecuteCommands:                              ProcCmdExecuteCommands;
+BindBufferMemory2:                               ProcBindBufferMemory2;
+BindImageMemory2:                                ProcBindImageMemory2;
+GetDeviceGroupPeerMemoryFeatures:                ProcGetDeviceGroupPeerMemoryFeatures;
+CmdSetDeviceMask:                                ProcCmdSetDeviceMask;
+CmdDispatchBase:                                 ProcCmdDispatchBase;
+GetImageMemoryRequirements2:                     ProcGetImageMemoryRequirements2;
+GetBufferMemoryRequirements2:                    ProcGetBufferMemoryRequirements2;
+GetImageSparseMemoryRequirements2:               ProcGetImageSparseMemoryRequirements2;
+TrimCommandPool:                                 ProcTrimCommandPool;
+GetDeviceQueue2:                                 ProcGetDeviceQueue2;
+CreateSamplerYcbcrConversion:                    ProcCreateSamplerYcbcrConversion;
+DestroySamplerYcbcrConversion:                   ProcDestroySamplerYcbcrConversion;
+CreateDescriptorUpdateTemplate:                  ProcCreateDescriptorUpdateTemplate;
+DestroyDescriptorUpdateTemplate:                 ProcDestroyDescriptorUpdateTemplate;
+UpdateDescriptorSetWithTemplate:                 ProcUpdateDescriptorSetWithTemplate;
+GetDescriptorSetLayoutSupport:                   ProcGetDescriptorSetLayoutSupport;
+CmdDrawIndirectCount:                            ProcCmdDrawIndirectCount;
+CmdDrawIndexedIndirectCount:                     ProcCmdDrawIndexedIndirectCount;
+CreateRenderPass2:                               ProcCreateRenderPass2;
+CmdBeginRenderPass2:                             ProcCmdBeginRenderPass2;
+CmdNextSubpass2:                                 ProcCmdNextSubpass2;
+CmdEndRenderPass2:                               ProcCmdEndRenderPass2;
+ResetQueryPool:                                  ProcResetQueryPool;
+GetSemaphoreCounterValue:                        ProcGetSemaphoreCounterValue;
+WaitSemaphores:                                  ProcWaitSemaphores;
+SignalSemaphore:                                 ProcSignalSemaphore;
+GetBufferDeviceAddress:                          ProcGetBufferDeviceAddress;
+GetBufferOpaqueCaptureAddress:                   ProcGetBufferOpaqueCaptureAddress;
+GetDeviceMemoryOpaqueCaptureAddress:             ProcGetDeviceMemoryOpaqueCaptureAddress;
+CreateSwapchainKHR:                              ProcCreateSwapchainKHR;
+DestroySwapchainKHR:                             ProcDestroySwapchainKHR;
+GetSwapchainImagesKHR:                           ProcGetSwapchainImagesKHR;
+AcquireNextImageKHR:                             ProcAcquireNextImageKHR;
+QueuePresentKHR:                                 ProcQueuePresentKHR;
+GetDeviceGroupPresentCapabilitiesKHR:            ProcGetDeviceGroupPresentCapabilitiesKHR;
+GetDeviceGroupSurfacePresentModesKHR:            ProcGetDeviceGroupSurfacePresentModesKHR;
+AcquireNextImage2KHR:                            ProcAcquireNextImage2KHR;
+CreateSharedSwapchainsKHR:                       ProcCreateSharedSwapchainsKHR;
+GetDeviceGroupPeerMemoryFeaturesKHR:             ProcGetDeviceGroupPeerMemoryFeaturesKHR;
+CmdSetDeviceMaskKHR:                             ProcCmdSetDeviceMaskKHR;
+CmdDispatchBaseKHR:                              ProcCmdDispatchBaseKHR;
+TrimCommandPoolKHR:                              ProcTrimCommandPoolKHR;
+GetMemoryFdKHR:                                  ProcGetMemoryFdKHR;
+GetMemoryFdPropertiesKHR:                        ProcGetMemoryFdPropertiesKHR;
+ImportSemaphoreFdKHR:                            ProcImportSemaphoreFdKHR;
+GetSemaphoreFdKHR:                               ProcGetSemaphoreFdKHR;
+CmdPushDescriptorSetKHR:                         ProcCmdPushDescriptorSetKHR;
+CmdPushDescriptorSetWithTemplateKHR:             ProcCmdPushDescriptorSetWithTemplateKHR;
+CreateDescriptorUpdateTemplateKHR:               ProcCreateDescriptorUpdateTemplateKHR;
+DestroyDescriptorUpdateTemplateKHR:              ProcDestroyDescriptorUpdateTemplateKHR;
+UpdateDescriptorSetWithTemplateKHR:              ProcUpdateDescriptorSetWithTemplateKHR;
+CreateRenderPass2KHR:                            ProcCreateRenderPass2KHR;
+CmdBeginRenderPass2KHR:                          ProcCmdBeginRenderPass2KHR;
+CmdNextSubpass2KHR:                              ProcCmdNextSubpass2KHR;
+CmdEndRenderPass2KHR:                            ProcCmdEndRenderPass2KHR;
+GetSwapchainStatusKHR:                           ProcGetSwapchainStatusKHR;
+ImportFenceFdKHR:                                ProcImportFenceFdKHR;
+GetFenceFdKHR:                                   ProcGetFenceFdKHR;
+AcquireProfilingLockKHR:                         ProcAcquireProfilingLockKHR;
+ReleaseProfilingLockKHR:                         ProcReleaseProfilingLockKHR;
+GetImageMemoryRequirements2KHR:                  ProcGetImageMemoryRequirements2KHR;
+GetBufferMemoryRequirements2KHR:                 ProcGetBufferMemoryRequirements2KHR;
+GetImageSparseMemoryRequirements2KHR:            ProcGetImageSparseMemoryRequirements2KHR;
+CreateSamplerYcbcrConversionKHR:                 ProcCreateSamplerYcbcrConversionKHR;
+DestroySamplerYcbcrConversionKHR:                ProcDestroySamplerYcbcrConversionKHR;
+BindBufferMemory2KHR:                            ProcBindBufferMemory2KHR;
+BindImageMemory2KHR:                             ProcBindImageMemory2KHR;
+GetDescriptorSetLayoutSupportKHR:                ProcGetDescriptorSetLayoutSupportKHR;
+CmdDrawIndirectCountKHR:                         ProcCmdDrawIndirectCountKHR;
+CmdDrawIndexedIndirectCountKHR:                  ProcCmdDrawIndexedIndirectCountKHR;
+GetSemaphoreCounterValueKHR:                     ProcGetSemaphoreCounterValueKHR;
+WaitSemaphoresKHR:                               ProcWaitSemaphoresKHR;
+SignalSemaphoreKHR:                              ProcSignalSemaphoreKHR;
+CmdSetFragmentShadingRateKHR:                    ProcCmdSetFragmentShadingRateKHR;
+WaitForPresentKHR:                               ProcWaitForPresentKHR;
+GetBufferDeviceAddressKHR:                       ProcGetBufferDeviceAddressKHR;
+GetBufferOpaqueCaptureAddressKHR:                ProcGetBufferOpaqueCaptureAddressKHR;
+GetDeviceMemoryOpaqueCaptureAddressKHR:          ProcGetDeviceMemoryOpaqueCaptureAddressKHR;
+CreateDeferredOperationKHR:                      ProcCreateDeferredOperationKHR;
+DestroyDeferredOperationKHR:                     ProcDestroyDeferredOperationKHR;
+GetDeferredOperationMaxConcurrencyKHR:           ProcGetDeferredOperationMaxConcurrencyKHR;
+GetDeferredOperationResultKHR:                   ProcGetDeferredOperationResultKHR;
+DeferredOperationJoinKHR:                        ProcDeferredOperationJoinKHR;
+GetPipelineExecutablePropertiesKHR:              ProcGetPipelineExecutablePropertiesKHR;
+GetPipelineExecutableStatisticsKHR:              ProcGetPipelineExecutableStatisticsKHR;
+GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR;
+CmdSetEvent2KHR:                                 ProcCmdSetEvent2KHR;
+CmdResetEvent2KHR:                               ProcCmdResetEvent2KHR;
+CmdWaitEvents2KHR:                               ProcCmdWaitEvents2KHR;
+CmdPipelineBarrier2KHR:                          ProcCmdPipelineBarrier2KHR;
+CmdWriteTimestamp2KHR:                           ProcCmdWriteTimestamp2KHR;
+QueueSubmit2KHR:                                 ProcQueueSubmit2KHR;
+CmdWriteBufferMarker2AMD:                        ProcCmdWriteBufferMarker2AMD;
+GetQueueCheckpointData2NV:                       ProcGetQueueCheckpointData2NV;
+CmdCopyBuffer2KHR:                               ProcCmdCopyBuffer2KHR;
+CmdCopyImage2KHR:                                ProcCmdCopyImage2KHR;
+CmdCopyBufferToImage2KHR:                        ProcCmdCopyBufferToImage2KHR;
+CmdCopyImageToBuffer2KHR:                        ProcCmdCopyImageToBuffer2KHR;
+CmdBlitImage2KHR:                                ProcCmdBlitImage2KHR;
+CmdResolveImage2KHR:                             ProcCmdResolveImage2KHR;
+DebugMarkerSetObjectTagEXT:                      ProcDebugMarkerSetObjectTagEXT;
+DebugMarkerSetObjectNameEXT:                     ProcDebugMarkerSetObjectNameEXT;
+CmdDebugMarkerBeginEXT:                          ProcCmdDebugMarkerBeginEXT;
+CmdDebugMarkerEndEXT:                            ProcCmdDebugMarkerEndEXT;
+CmdDebugMarkerInsertEXT:                         ProcCmdDebugMarkerInsertEXT;
+CmdBindTransformFeedbackBuffersEXT:              ProcCmdBindTransformFeedbackBuffersEXT;
+CmdBeginTransformFeedbackEXT:                    ProcCmdBeginTransformFeedbackEXT;
+CmdEndTransformFeedbackEXT:                      ProcCmdEndTransformFeedbackEXT;
+CmdBeginQueryIndexedEXT:                         ProcCmdBeginQueryIndexedEXT;
+CmdEndQueryIndexedEXT:                           ProcCmdEndQueryIndexedEXT;
+CmdDrawIndirectByteCountEXT:                     ProcCmdDrawIndirectByteCountEXT;
+CreateCuModuleNVX:                               ProcCreateCuModuleNVX;
+CreateCuFunctionNVX:                             ProcCreateCuFunctionNVX;
+DestroyCuModuleNVX:                              ProcDestroyCuModuleNVX;
+DestroyCuFunctionNVX:                            ProcDestroyCuFunctionNVX;
+CmdCuLaunchKernelNVX:                            ProcCmdCuLaunchKernelNVX;
+GetImageViewHandleNVX:                           ProcGetImageViewHandleNVX;
+GetImageViewAddressNVX:                          ProcGetImageViewAddressNVX;
+CmdDrawIndirectCountAMD:                         ProcCmdDrawIndirectCountAMD;
+CmdDrawIndexedIndirectCountAMD:                  ProcCmdDrawIndexedIndirectCountAMD;
+GetShaderInfoAMD:                                ProcGetShaderInfoAMD;
+CmdBeginConditionalRenderingEXT:                 ProcCmdBeginConditionalRenderingEXT;
+CmdEndConditionalRenderingEXT:                   ProcCmdEndConditionalRenderingEXT;
+CmdSetViewportWScalingNV:                        ProcCmdSetViewportWScalingNV;
+DisplayPowerControlEXT:                          ProcDisplayPowerControlEXT;
+RegisterDeviceEventEXT:                          ProcRegisterDeviceEventEXT;
+RegisterDisplayEventEXT:                         ProcRegisterDisplayEventEXT;
+GetSwapchainCounterEXT:                          ProcGetSwapchainCounterEXT;
+GetRefreshCycleDurationGOOGLE:                   ProcGetRefreshCycleDurationGOOGLE;
+GetPastPresentationTimingGOOGLE:                 ProcGetPastPresentationTimingGOOGLE;
+CmdSetDiscardRectangleEXT:                       ProcCmdSetDiscardRectangleEXT;
+SetHdrMetadataEXT:                               ProcSetHdrMetadataEXT;
+SetDebugUtilsObjectNameEXT:                      ProcSetDebugUtilsObjectNameEXT;
+SetDebugUtilsObjectTagEXT:                       ProcSetDebugUtilsObjectTagEXT;
+QueueBeginDebugUtilsLabelEXT:                    ProcQueueBeginDebugUtilsLabelEXT;
+QueueEndDebugUtilsLabelEXT:                      ProcQueueEndDebugUtilsLabelEXT;
+QueueInsertDebugUtilsLabelEXT:                   ProcQueueInsertDebugUtilsLabelEXT;
+CmdBeginDebugUtilsLabelEXT:                      ProcCmdBeginDebugUtilsLabelEXT;
+CmdEndDebugUtilsLabelEXT:                        ProcCmdEndDebugUtilsLabelEXT;
+CmdInsertDebugUtilsLabelEXT:                     ProcCmdInsertDebugUtilsLabelEXT;
+CmdSetSampleLocationsEXT:                        ProcCmdSetSampleLocationsEXT;
+GetImageDrmFormatModifierPropertiesEXT:          ProcGetImageDrmFormatModifierPropertiesEXT;
+CreateValidationCacheEXT:                        ProcCreateValidationCacheEXT;
+DestroyValidationCacheEXT:                       ProcDestroyValidationCacheEXT;
+MergeValidationCachesEXT:                        ProcMergeValidationCachesEXT;
+GetValidationCacheDataEXT:                       ProcGetValidationCacheDataEXT;
+CmdBindShadingRateImageNV:                       ProcCmdBindShadingRateImageNV;
+CmdSetViewportShadingRatePaletteNV:              ProcCmdSetViewportShadingRatePaletteNV;
+CmdSetCoarseSampleOrderNV:                       ProcCmdSetCoarseSampleOrderNV;
+CreateAccelerationStructureNV:                   ProcCreateAccelerationStructureNV;
+DestroyAccelerationStructureNV:                  ProcDestroyAccelerationStructureNV;
+GetAccelerationStructureMemoryRequirementsNV:    ProcGetAccelerationStructureMemoryRequirementsNV;
+BindAccelerationStructureMemoryNV:               ProcBindAccelerationStructureMemoryNV;
+CmdBuildAccelerationStructureNV:                 ProcCmdBuildAccelerationStructureNV;
+CmdCopyAccelerationStructureNV:                  ProcCmdCopyAccelerationStructureNV;
+CmdTraceRaysNV:                                  ProcCmdTraceRaysNV;
+CreateRayTracingPipelinesNV:                     ProcCreateRayTracingPipelinesNV;
+GetRayTracingShaderGroupHandlesKHR:              ProcGetRayTracingShaderGroupHandlesKHR;
+GetRayTracingShaderGroupHandlesNV:               ProcGetRayTracingShaderGroupHandlesNV;
+GetAccelerationStructureHandleNV:                ProcGetAccelerationStructureHandleNV;
+CmdWriteAccelerationStructuresPropertiesNV:      ProcCmdWriteAccelerationStructuresPropertiesNV;
+CompileDeferredNV:                               ProcCompileDeferredNV;
+GetMemoryHostPointerPropertiesEXT:               ProcGetMemoryHostPointerPropertiesEXT;
+CmdWriteBufferMarkerAMD:                         ProcCmdWriteBufferMarkerAMD;
+GetCalibratedTimestampsEXT:                      ProcGetCalibratedTimestampsEXT;
+CmdDrawMeshTasksNV:                              ProcCmdDrawMeshTasksNV;
+CmdDrawMeshTasksIndirectNV:                      ProcCmdDrawMeshTasksIndirectNV;
+CmdDrawMeshTasksIndirectCountNV:                 ProcCmdDrawMeshTasksIndirectCountNV;
+CmdSetExclusiveScissorNV:                        ProcCmdSetExclusiveScissorNV;
+CmdSetCheckpointNV:                              ProcCmdSetCheckpointNV;
+GetQueueCheckpointDataNV:                        ProcGetQueueCheckpointDataNV;
+InitializePerformanceApiINTEL:                   ProcInitializePerformanceApiINTEL;
+UninitializePerformanceApiINTEL:                 ProcUninitializePerformanceApiINTEL;
+CmdSetPerformanceMarkerINTEL:                    ProcCmdSetPerformanceMarkerINTEL;
+CmdSetPerformanceStreamMarkerINTEL:              ProcCmdSetPerformanceStreamMarkerINTEL;
+CmdSetPerformanceOverrideINTEL:                  ProcCmdSetPerformanceOverrideINTEL;
+AcquirePerformanceConfigurationINTEL:            ProcAcquirePerformanceConfigurationINTEL;
+ReleasePerformanceConfigurationINTEL:            ProcReleasePerformanceConfigurationINTEL;
+QueueSetPerformanceConfigurationINTEL:           ProcQueueSetPerformanceConfigurationINTEL;
+GetPerformanceParameterINTEL:                    ProcGetPerformanceParameterINTEL;
+SetLocalDimmingAMD:                              ProcSetLocalDimmingAMD;
+GetBufferDeviceAddressEXT:                       ProcGetBufferDeviceAddressEXT;
+CmdSetLineStippleEXT:                            ProcCmdSetLineStippleEXT;
+ResetQueryPoolEXT:                               ProcResetQueryPoolEXT;
+CmdSetCullModeEXT:                               ProcCmdSetCullModeEXT;
+CmdSetFrontFaceEXT:                              ProcCmdSetFrontFaceEXT;
+CmdSetPrimitiveTopologyEXT:                      ProcCmdSetPrimitiveTopologyEXT;
+CmdSetViewportWithCountEXT:                      ProcCmdSetViewportWithCountEXT;
+CmdSetScissorWithCountEXT:                       ProcCmdSetScissorWithCountEXT;
+CmdBindVertexBuffers2EXT:                        ProcCmdBindVertexBuffers2EXT;
+CmdSetDepthTestEnableEXT:                        ProcCmdSetDepthTestEnableEXT;
+CmdSetDepthWriteEnableEXT:                       ProcCmdSetDepthWriteEnableEXT;
+CmdSetDepthCompareOpEXT:                         ProcCmdSetDepthCompareOpEXT;
+CmdSetDepthBoundsTestEnableEXT:                  ProcCmdSetDepthBoundsTestEnableEXT;
+CmdSetStencilTestEnableEXT:                      ProcCmdSetStencilTestEnableEXT;
+CmdSetStencilOpEXT:                              ProcCmdSetStencilOpEXT;
+GetGeneratedCommandsMemoryRequirementsNV:        ProcGetGeneratedCommandsMemoryRequirementsNV;
+CmdPreprocessGeneratedCommandsNV:                ProcCmdPreprocessGeneratedCommandsNV;
+CmdExecuteGeneratedCommandsNV:                   ProcCmdExecuteGeneratedCommandsNV;
+CmdBindPipelineShaderGroupNV:                    ProcCmdBindPipelineShaderGroupNV;
+CreateIndirectCommandsLayoutNV:                  ProcCreateIndirectCommandsLayoutNV;
+DestroyIndirectCommandsLayoutNV:                 ProcDestroyIndirectCommandsLayoutNV;
+CreatePrivateDataSlotEXT:                        ProcCreatePrivateDataSlotEXT;
+DestroyPrivateDataSlotEXT:                       ProcDestroyPrivateDataSlotEXT;
+SetPrivateDataEXT:                               ProcSetPrivateDataEXT;
+GetPrivateDataEXT:                               ProcGetPrivateDataEXT;
+CmdSetFragmentShadingRateEnumNV:                 ProcCmdSetFragmentShadingRateEnumNV;
+CmdSetVertexInputEXT:                            ProcCmdSetVertexInputEXT;
+GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:   ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI;
+CmdSubpassShadingHUAWEI:                         ProcCmdSubpassShadingHUAWEI;
+CmdBindInvocationMaskHUAWEI:                     ProcCmdBindInvocationMaskHUAWEI;
+GetMemoryRemoteAddressNV:                        ProcGetMemoryRemoteAddressNV;
+CmdSetPatchControlPointsEXT:                     ProcCmdSetPatchControlPointsEXT;
+CmdSetRasterizerDiscardEnableEXT:                ProcCmdSetRasterizerDiscardEnableEXT;
+CmdSetDepthBiasEnableEXT:                        ProcCmdSetDepthBiasEnableEXT;
+CmdSetLogicOpEXT:                                ProcCmdSetLogicOpEXT;
+CmdSetPrimitiveRestartEnableEXT:                 ProcCmdSetPrimitiveRestartEnableEXT;
+CmdDrawMultiEXT:                                 ProcCmdDrawMultiEXT;
+CmdDrawMultiIndexedEXT:                          ProcCmdDrawMultiIndexedEXT;
+CreateAccelerationStructureKHR:                  ProcCreateAccelerationStructureKHR;
+DestroyAccelerationStructureKHR:                 ProcDestroyAccelerationStructureKHR;
+CmdBuildAccelerationStructuresKHR:               ProcCmdBuildAccelerationStructuresKHR;
+CmdBuildAccelerationStructuresIndirectKHR:       ProcCmdBuildAccelerationStructuresIndirectKHR;
+BuildAccelerationStructuresKHR:                  ProcBuildAccelerationStructuresKHR;
+CopyAccelerationStructureKHR:                    ProcCopyAccelerationStructureKHR;
+CopyAccelerationStructureToMemoryKHR:            ProcCopyAccelerationStructureToMemoryKHR;
+CopyMemoryToAccelerationStructureKHR:            ProcCopyMemoryToAccelerationStructureKHR;
+WriteAccelerationStructuresPropertiesKHR:        ProcWriteAccelerationStructuresPropertiesKHR;
+CmdCopyAccelerationStructureKHR:                 ProcCmdCopyAccelerationStructureKHR;
+CmdCopyAccelerationStructureToMemoryKHR:         ProcCmdCopyAccelerationStructureToMemoryKHR;
+CmdCopyMemoryToAccelerationStructureKHR:         ProcCmdCopyMemoryToAccelerationStructureKHR;
+GetAccelerationStructureDeviceAddressKHR:        ProcGetAccelerationStructureDeviceAddressKHR;
+CmdWriteAccelerationStructuresPropertiesKHR:     ProcCmdWriteAccelerationStructuresPropertiesKHR;
+GetDeviceAccelerationStructureCompatibilityKHR:  ProcGetDeviceAccelerationStructureCompatibilityKHR;
+GetAccelerationStructureBuildSizesKHR:           ProcGetAccelerationStructureBuildSizesKHR;
+CmdTraceRaysKHR:                                 ProcCmdTraceRaysKHR;
+CreateRayTracingPipelinesKHR:                    ProcCreateRayTracingPipelinesKHR;
+GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR;
+CmdTraceRaysIndirectKHR:                         ProcCmdTraceRaysIndirectKHR;
+GetRayTracingShaderGroupStackSizeKHR:            ProcGetRayTracingShaderGroupStackSizeKHR;
+CmdSetRayTracingPipelineStackSizeKHR:            ProcCmdSetRayTracingPipelineStackSizeKHR;
+SetDeviceLoaderData:                             ProcSetDeviceLoaderData;
+LayerDestroyDevice:                              ProcLayerDestroyDevice;
+GetMemoryWin32HandleKHR:                         ProcGetMemoryWin32HandleKHR;
+GetMemoryWin32HandlePropertiesKHR:               ProcGetMemoryWin32HandlePropertiesKHR;
+ImportSemaphoreWin32HandleKHR:                   ProcImportSemaphoreWin32HandleKHR;
+GetSemaphoreWin32HandleKHR:                      ProcGetSemaphoreWin32HandleKHR;
+ImportFenceWin32HandleKHR:                       ProcImportFenceWin32HandleKHR;
+GetFenceWin32HandleKHR:                          ProcGetFenceWin32HandleKHR;
+GetMemoryWin32HandleNV:                          ProcGetMemoryWin32HandleNV;
+AcquireFullScreenExclusiveModeEXT:               ProcAcquireFullScreenExclusiveModeEXT;
+ReleaseFullScreenExclusiveModeEXT:               ProcReleaseFullScreenExclusiveModeEXT;
+GetDeviceGroupSurfacePresentModes2EXT:           ProcGetDeviceGroupSurfacePresentModes2EXT;
+
+// Loader Procedures
+CreateInstance:                        ProcCreateInstance;
+EnumerateInstanceExtensionProperties:  ProcEnumerateInstanceExtensionProperties;
+EnumerateInstanceLayerProperties:      ProcEnumerateInstanceLayerProperties;
+EnumerateInstanceVersion:              ProcEnumerateInstanceVersion;
+DebugUtilsMessengerCallbackEXT:        ProcDebugUtilsMessengerCallbackEXT;
+DeviceMemoryReportCallbackEXT:         ProcDeviceMemoryReportCallbackEXT;
+NegotiateLoaderLayerInterfaceVersion:  ProcNegotiateLoaderLayerInterfaceVersion;
+icdNegotiateLoaderICDInterfaceVersion: ProcicdNegotiateLoaderICDInterfaceVersion;
+
+load_proc_addresses :: proc(set_proc_address: SetProcAddressType) {
+	// Instance Procedures
+	set_proc_address(&DestroyInstance,                                                 "vkDestroyInstance");
+	set_proc_address(&EnumeratePhysicalDevices,                                        "vkEnumeratePhysicalDevices");
+	set_proc_address(&GetPhysicalDeviceFeatures,                                       "vkGetPhysicalDeviceFeatures");
+	set_proc_address(&GetPhysicalDeviceFormatProperties,                               "vkGetPhysicalDeviceFormatProperties");
+	set_proc_address(&GetPhysicalDeviceImageFormatProperties,                          "vkGetPhysicalDeviceImageFormatProperties");
+	set_proc_address(&GetPhysicalDeviceProperties,                                     "vkGetPhysicalDeviceProperties");
+	set_proc_address(&GetPhysicalDeviceQueueFamilyProperties,                          "vkGetPhysicalDeviceQueueFamilyProperties");
+	set_proc_address(&GetPhysicalDeviceMemoryProperties,                               "vkGetPhysicalDeviceMemoryProperties");
+	set_proc_address(&GetInstanceProcAddr,                                             "vkGetInstanceProcAddr");
+	set_proc_address(&CreateDevice,                                                    "vkCreateDevice");
+	set_proc_address(&EnumerateDeviceExtensionProperties,                              "vkEnumerateDeviceExtensionProperties");
+	set_proc_address(&EnumerateDeviceLayerProperties,                                  "vkEnumerateDeviceLayerProperties");
+	set_proc_address(&GetPhysicalDeviceSparseImageFormatProperties,                    "vkGetPhysicalDeviceSparseImageFormatProperties");
+	set_proc_address(&EnumeratePhysicalDeviceGroups,                                   "vkEnumeratePhysicalDeviceGroups");
+	set_proc_address(&GetPhysicalDeviceFeatures2,                                      "vkGetPhysicalDeviceFeatures2");
+	set_proc_address(&GetPhysicalDeviceProperties2,                                    "vkGetPhysicalDeviceProperties2");
+	set_proc_address(&GetPhysicalDeviceFormatProperties2,                              "vkGetPhysicalDeviceFormatProperties2");
+	set_proc_address(&GetPhysicalDeviceImageFormatProperties2,                         "vkGetPhysicalDeviceImageFormatProperties2");
+	set_proc_address(&GetPhysicalDeviceQueueFamilyProperties2,                         "vkGetPhysicalDeviceQueueFamilyProperties2");
+	set_proc_address(&GetPhysicalDeviceMemoryProperties2,                              "vkGetPhysicalDeviceMemoryProperties2");
+	set_proc_address(&GetPhysicalDeviceSparseImageFormatProperties2,                   "vkGetPhysicalDeviceSparseImageFormatProperties2");
+	set_proc_address(&GetPhysicalDeviceExternalBufferProperties,                       "vkGetPhysicalDeviceExternalBufferProperties");
+	set_proc_address(&GetPhysicalDeviceExternalFenceProperties,                        "vkGetPhysicalDeviceExternalFenceProperties");
+	set_proc_address(&GetPhysicalDeviceExternalSemaphoreProperties,                    "vkGetPhysicalDeviceExternalSemaphoreProperties");
+	set_proc_address(&DestroySurfaceKHR,                                               "vkDestroySurfaceKHR");
+	set_proc_address(&GetPhysicalDeviceSurfaceSupportKHR,                              "vkGetPhysicalDeviceSurfaceSupportKHR");
+	set_proc_address(&GetPhysicalDeviceSurfaceCapabilitiesKHR,                         "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+	set_proc_address(&GetPhysicalDeviceSurfaceFormatsKHR,                              "vkGetPhysicalDeviceSurfaceFormatsKHR");
+	set_proc_address(&GetPhysicalDeviceSurfacePresentModesKHR,                         "vkGetPhysicalDeviceSurfacePresentModesKHR");
+	set_proc_address(&GetPhysicalDevicePresentRectanglesKHR,                           "vkGetPhysicalDevicePresentRectanglesKHR");
+	set_proc_address(&GetPhysicalDeviceDisplayPropertiesKHR,                           "vkGetPhysicalDeviceDisplayPropertiesKHR");
+	set_proc_address(&GetPhysicalDeviceDisplayPlanePropertiesKHR,                      "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
+	set_proc_address(&GetDisplayPlaneSupportedDisplaysKHR,                             "vkGetDisplayPlaneSupportedDisplaysKHR");
+	set_proc_address(&GetDisplayModePropertiesKHR,                                     "vkGetDisplayModePropertiesKHR");
+	set_proc_address(&CreateDisplayModeKHR,                                            "vkCreateDisplayModeKHR");
+	set_proc_address(&GetDisplayPlaneCapabilitiesKHR,                                  "vkGetDisplayPlaneCapabilitiesKHR");
+	set_proc_address(&CreateDisplayPlaneSurfaceKHR,                                    "vkCreateDisplayPlaneSurfaceKHR");
+	set_proc_address(&GetPhysicalDeviceFeatures2KHR,                                   "vkGetPhysicalDeviceFeatures2KHR");
+	set_proc_address(&GetPhysicalDeviceProperties2KHR,                                 "vkGetPhysicalDeviceProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceFormatProperties2KHR,                           "vkGetPhysicalDeviceFormatProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceImageFormatProperties2KHR,                      "vkGetPhysicalDeviceImageFormatProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceQueueFamilyProperties2KHR,                      "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceMemoryProperties2KHR,                           "vkGetPhysicalDeviceMemoryProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceSparseImageFormatProperties2KHR,                "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+	set_proc_address(&EnumeratePhysicalDeviceGroupsKHR,                                "vkEnumeratePhysicalDeviceGroupsKHR");
+	set_proc_address(&GetPhysicalDeviceExternalBufferPropertiesKHR,                    "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
+	set_proc_address(&GetPhysicalDeviceExternalSemaphorePropertiesKHR,                 "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
+	set_proc_address(&GetPhysicalDeviceExternalFencePropertiesKHR,                     "vkGetPhysicalDeviceExternalFencePropertiesKHR");
+	set_proc_address(&EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,   "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
+	set_proc_address(&GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,           "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
+	set_proc_address(&GetPhysicalDeviceSurfaceCapabilities2KHR,                        "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+	set_proc_address(&GetPhysicalDeviceSurfaceFormats2KHR,                             "vkGetPhysicalDeviceSurfaceFormats2KHR");
+	set_proc_address(&GetPhysicalDeviceDisplayProperties2KHR,                          "vkGetPhysicalDeviceDisplayProperties2KHR");
+	set_proc_address(&GetPhysicalDeviceDisplayPlaneProperties2KHR,                     "vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
+	set_proc_address(&GetDisplayModeProperties2KHR,                                    "vkGetDisplayModeProperties2KHR");
+	set_proc_address(&GetDisplayPlaneCapabilities2KHR,                                 "vkGetDisplayPlaneCapabilities2KHR");
+	set_proc_address(&GetPhysicalDeviceFragmentShadingRatesKHR,                        "vkGetPhysicalDeviceFragmentShadingRatesKHR");
+	set_proc_address(&CreateDebugReportCallbackEXT,                                    "vkCreateDebugReportCallbackEXT");
+	set_proc_address(&DestroyDebugReportCallbackEXT,                                   "vkDestroyDebugReportCallbackEXT");
+	set_proc_address(&DebugReportMessageEXT,                                           "vkDebugReportMessageEXT");
+	set_proc_address(&GetPhysicalDeviceExternalImageFormatPropertiesNV,                "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+	set_proc_address(&ReleaseDisplayEXT,                                               "vkReleaseDisplayEXT");
+	set_proc_address(&GetPhysicalDeviceSurfaceCapabilities2EXT,                        "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
+	set_proc_address(&CreateDebugUtilsMessengerEXT,                                    "vkCreateDebugUtilsMessengerEXT");
+	set_proc_address(&DestroyDebugUtilsMessengerEXT,                                   "vkDestroyDebugUtilsMessengerEXT");
+	set_proc_address(&SubmitDebugUtilsMessageEXT,                                      "vkSubmitDebugUtilsMessageEXT");
+	set_proc_address(&GetPhysicalDeviceMultisamplePropertiesEXT,                       "vkGetPhysicalDeviceMultisamplePropertiesEXT");
+	set_proc_address(&GetPhysicalDeviceCalibrateableTimeDomainsEXT,                    "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
+	set_proc_address(&GetPhysicalDeviceToolPropertiesEXT,                              "vkGetPhysicalDeviceToolPropertiesEXT");
+	set_proc_address(&GetPhysicalDeviceCooperativeMatrixPropertiesNV,                  "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
+	set_proc_address(&GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
+	set_proc_address(&CreateHeadlessSurfaceEXT,                                        "vkCreateHeadlessSurfaceEXT");
+	set_proc_address(&AcquireDrmDisplayEXT,                                            "vkAcquireDrmDisplayEXT");
+	set_proc_address(&GetDrmDisplayEXT,                                                "vkGetDrmDisplayEXT");
+	set_proc_address(&AcquireWinrtDisplayNV,                                           "vkAcquireWinrtDisplayNV");
+	set_proc_address(&GetWinrtDisplayNV,                                               "vkGetWinrtDisplayNV");
+	set_proc_address(&GetPhysicalDeviceProcAddr,                                       "vkGetPhysicalDeviceProcAddr");
+	set_proc_address(&SetInstanceLoaderData,                                           "vkSetInstanceLoaderData");
+	set_proc_address(&LayerCreateDevice,                                               "vkLayerCreateDevice");
+	set_proc_address(&icdGetInstanceProcAddr,                                          "vkicdGetInstanceProcAddr");
+	set_proc_address(&icdGetPhysicalDeviceProcAddr,                                    "vkicdGetPhysicalDeviceProcAddr");
+	set_proc_address(&icdEnumerateAdapterPhysicalDevices,                              "vkicdEnumerateAdapterPhysicalDevices");
+	set_proc_address(&CreateWin32SurfaceKHR,                                           "vkCreateWin32SurfaceKHR");
+	set_proc_address(&GetPhysicalDeviceWin32PresentationSupportKHR,                    "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+	set_proc_address(&GetPhysicalDeviceSurfacePresentModes2EXT,                        "vkGetPhysicalDeviceSurfacePresentModes2EXT");
+	set_proc_address(&CreateMetalSurfaceEXT,                                           "vkCreateMetalSurfaceEXT");
+	set_proc_address(&CreateMacOSSurfaceMVK,                                           "vkCreateMacOSSurfaceMVK");
+	set_proc_address(&CreateIOSSurfaceMVK,                                             "vkCreateIOSSurfaceMVK");
+
+	// Device Procedures
+	set_proc_address(&GetDeviceProcAddr,                               "vkGetDeviceProcAddr");
+	set_proc_address(&DestroyDevice,                                   "vkDestroyDevice");
+	set_proc_address(&GetDeviceQueue,                                  "vkGetDeviceQueue");
+	set_proc_address(&QueueSubmit,                                     "vkQueueSubmit");
+	set_proc_address(&QueueWaitIdle,                                   "vkQueueWaitIdle");
+	set_proc_address(&DeviceWaitIdle,                                  "vkDeviceWaitIdle");
+	set_proc_address(&AllocateMemory,                                  "vkAllocateMemory");
+	set_proc_address(&FreeMemory,                                      "vkFreeMemory");
+	set_proc_address(&MapMemory,                                       "vkMapMemory");
+	set_proc_address(&UnmapMemory,                                     "vkUnmapMemory");
+	set_proc_address(&FlushMappedMemoryRanges,                         "vkFlushMappedMemoryRanges");
+	set_proc_address(&InvalidateMappedMemoryRanges,                    "vkInvalidateMappedMemoryRanges");
+	set_proc_address(&GetDeviceMemoryCommitment,                       "vkGetDeviceMemoryCommitment");
+	set_proc_address(&BindBufferMemory,                                "vkBindBufferMemory");
+	set_proc_address(&BindImageMemory,                                 "vkBindImageMemory");
+	set_proc_address(&GetBufferMemoryRequirements,                     "vkGetBufferMemoryRequirements");
+	set_proc_address(&GetImageMemoryRequirements,                      "vkGetImageMemoryRequirements");
+	set_proc_address(&GetImageSparseMemoryRequirements,                "vkGetImageSparseMemoryRequirements");
+	set_proc_address(&QueueBindSparse,                                 "vkQueueBindSparse");
+	set_proc_address(&CreateFence,                                     "vkCreateFence");
+	set_proc_address(&DestroyFence,                                    "vkDestroyFence");
+	set_proc_address(&ResetFences,                                     "vkResetFences");
+	set_proc_address(&GetFenceStatus,                                  "vkGetFenceStatus");
+	set_proc_address(&WaitForFences,                                   "vkWaitForFences");
+	set_proc_address(&CreateSemaphore,                                 "vkCreateSemaphore");
+	set_proc_address(&DestroySemaphore,                                "vkDestroySemaphore");
+	set_proc_address(&CreateEvent,                                     "vkCreateEvent");
+	set_proc_address(&DestroyEvent,                                    "vkDestroyEvent");
+	set_proc_address(&GetEventStatus,                                  "vkGetEventStatus");
+	set_proc_address(&SetEvent,                                        "vkSetEvent");
+	set_proc_address(&ResetEvent,                                      "vkResetEvent");
+	set_proc_address(&CreateQueryPool,                                 "vkCreateQueryPool");
+	set_proc_address(&DestroyQueryPool,                                "vkDestroyQueryPool");
+	set_proc_address(&GetQueryPoolResults,                             "vkGetQueryPoolResults");
+	set_proc_address(&CreateBuffer,                                    "vkCreateBuffer");
+	set_proc_address(&DestroyBuffer,                                   "vkDestroyBuffer");
+	set_proc_address(&CreateBufferView,                                "vkCreateBufferView");
+	set_proc_address(&DestroyBufferView,                               "vkDestroyBufferView");
+	set_proc_address(&CreateImage,                                     "vkCreateImage");
+	set_proc_address(&DestroyImage,                                    "vkDestroyImage");
+	set_proc_address(&GetImageSubresourceLayout,                       "vkGetImageSubresourceLayout");
+	set_proc_address(&CreateImageView,                                 "vkCreateImageView");
+	set_proc_address(&DestroyImageView,                                "vkDestroyImageView");
+	set_proc_address(&CreateShaderModule,                              "vkCreateShaderModule");
+	set_proc_address(&DestroyShaderModule,                             "vkDestroyShaderModule");
+	set_proc_address(&CreatePipelineCache,                             "vkCreatePipelineCache");
+	set_proc_address(&DestroyPipelineCache,                            "vkDestroyPipelineCache");
+	set_proc_address(&GetPipelineCacheData,                            "vkGetPipelineCacheData");
+	set_proc_address(&MergePipelineCaches,                             "vkMergePipelineCaches");
+	set_proc_address(&CreateGraphicsPipelines,                         "vkCreateGraphicsPipelines");
+	set_proc_address(&CreateComputePipelines,                          "vkCreateComputePipelines");
+	set_proc_address(&DestroyPipeline,                                 "vkDestroyPipeline");
+	set_proc_address(&CreatePipelineLayout,                            "vkCreatePipelineLayout");
+	set_proc_address(&DestroyPipelineLayout,                           "vkDestroyPipelineLayout");
+	set_proc_address(&CreateSampler,                                   "vkCreateSampler");
+	set_proc_address(&DestroySampler,                                  "vkDestroySampler");
+	set_proc_address(&CreateDescriptorSetLayout,                       "vkCreateDescriptorSetLayout");
+	set_proc_address(&DestroyDescriptorSetLayout,                      "vkDestroyDescriptorSetLayout");
+	set_proc_address(&CreateDescriptorPool,                            "vkCreateDescriptorPool");
+	set_proc_address(&DestroyDescriptorPool,                           "vkDestroyDescriptorPool");
+	set_proc_address(&ResetDescriptorPool,                             "vkResetDescriptorPool");
+	set_proc_address(&AllocateDescriptorSets,                          "vkAllocateDescriptorSets");
+	set_proc_address(&FreeDescriptorSets,                              "vkFreeDescriptorSets");
+	set_proc_address(&UpdateDescriptorSets,                            "vkUpdateDescriptorSets");
+	set_proc_address(&CreateFramebuffer,                               "vkCreateFramebuffer");
+	set_proc_address(&DestroyFramebuffer,                              "vkDestroyFramebuffer");
+	set_proc_address(&CreateRenderPass,                                "vkCreateRenderPass");
+	set_proc_address(&DestroyRenderPass,                               "vkDestroyRenderPass");
+	set_proc_address(&GetRenderAreaGranularity,                        "vkGetRenderAreaGranularity");
+	set_proc_address(&CreateCommandPool,                               "vkCreateCommandPool");
+	set_proc_address(&DestroyCommandPool,                              "vkDestroyCommandPool");
+	set_proc_address(&ResetCommandPool,                                "vkResetCommandPool");
+	set_proc_address(&AllocateCommandBuffers,                          "vkAllocateCommandBuffers");
+	set_proc_address(&FreeCommandBuffers,                              "vkFreeCommandBuffers");
+	set_proc_address(&BeginCommandBuffer,                              "vkBeginCommandBuffer");
+	set_proc_address(&EndCommandBuffer,                                "vkEndCommandBuffer");
+	set_proc_address(&ResetCommandBuffer,                              "vkResetCommandBuffer");
+	set_proc_address(&CmdBindPipeline,                                 "vkCmdBindPipeline");
+	set_proc_address(&CmdSetViewport,                                  "vkCmdSetViewport");
+	set_proc_address(&CmdSetScissor,                                   "vkCmdSetScissor");
+	set_proc_address(&CmdSetLineWidth,                                 "vkCmdSetLineWidth");
+	set_proc_address(&CmdSetDepthBias,                                 "vkCmdSetDepthBias");
+	set_proc_address(&CmdSetBlendConstants,                            "vkCmdSetBlendConstants");
+	set_proc_address(&CmdSetDepthBounds,                               "vkCmdSetDepthBounds");
+	set_proc_address(&CmdSetStencilCompareMask,                        "vkCmdSetStencilCompareMask");
+	set_proc_address(&CmdSetStencilWriteMask,                          "vkCmdSetStencilWriteMask");
+	set_proc_address(&CmdSetStencilReference,                          "vkCmdSetStencilReference");
+	set_proc_address(&CmdBindDescriptorSets,                           "vkCmdBindDescriptorSets");
+	set_proc_address(&CmdBindIndexBuffer,                              "vkCmdBindIndexBuffer");
+	set_proc_address(&CmdBindVertexBuffers,                            "vkCmdBindVertexBuffers");
+	set_proc_address(&CmdDraw,                                         "vkCmdDraw");
+	set_proc_address(&CmdDrawIndexed,                                  "vkCmdDrawIndexed");
+	set_proc_address(&CmdDrawIndirect,                                 "vkCmdDrawIndirect");
+	set_proc_address(&CmdDrawIndexedIndirect,                          "vkCmdDrawIndexedIndirect");
+	set_proc_address(&CmdDispatch,                                     "vkCmdDispatch");
+	set_proc_address(&CmdDispatchIndirect,                             "vkCmdDispatchIndirect");
+	set_proc_address(&CmdCopyBuffer,                                   "vkCmdCopyBuffer");
+	set_proc_address(&CmdCopyImage,                                    "vkCmdCopyImage");
+	set_proc_address(&CmdBlitImage,                                    "vkCmdBlitImage");
+	set_proc_address(&CmdCopyBufferToImage,                            "vkCmdCopyBufferToImage");
+	set_proc_address(&CmdCopyImageToBuffer,                            "vkCmdCopyImageToBuffer");
+	set_proc_address(&CmdUpdateBuffer,                                 "vkCmdUpdateBuffer");
+	set_proc_address(&CmdFillBuffer,                                   "vkCmdFillBuffer");
+	set_proc_address(&CmdClearColorImage,                              "vkCmdClearColorImage");
+	set_proc_address(&CmdClearDepthStencilImage,                       "vkCmdClearDepthStencilImage");
+	set_proc_address(&CmdClearAttachments,                             "vkCmdClearAttachments");
+	set_proc_address(&CmdResolveImage,                                 "vkCmdResolveImage");
+	set_proc_address(&CmdSetEvent,                                     "vkCmdSetEvent");
+	set_proc_address(&CmdResetEvent,                                   "vkCmdResetEvent");
+	set_proc_address(&CmdWaitEvents,                                   "vkCmdWaitEvents");
+	set_proc_address(&CmdPipelineBarrier,                              "vkCmdPipelineBarrier");
+	set_proc_address(&CmdBeginQuery,                                   "vkCmdBeginQuery");
+	set_proc_address(&CmdEndQuery,                                     "vkCmdEndQuery");
+	set_proc_address(&CmdResetQueryPool,                               "vkCmdResetQueryPool");
+	set_proc_address(&CmdWriteTimestamp,                               "vkCmdWriteTimestamp");
+	set_proc_address(&CmdCopyQueryPoolResults,                         "vkCmdCopyQueryPoolResults");
+	set_proc_address(&CmdPushConstants,                                "vkCmdPushConstants");
+	set_proc_address(&CmdBeginRenderPass,                              "vkCmdBeginRenderPass");
+	set_proc_address(&CmdNextSubpass,                                  "vkCmdNextSubpass");
+	set_proc_address(&CmdEndRenderPass,                                "vkCmdEndRenderPass");
+	set_proc_address(&CmdExecuteCommands,                              "vkCmdExecuteCommands");
+	set_proc_address(&BindBufferMemory2,                               "vkBindBufferMemory2");
+	set_proc_address(&BindImageMemory2,                                "vkBindImageMemory2");
+	set_proc_address(&GetDeviceGroupPeerMemoryFeatures,                "vkGetDeviceGroupPeerMemoryFeatures");
+	set_proc_address(&CmdSetDeviceMask,                                "vkCmdSetDeviceMask");
+	set_proc_address(&CmdDispatchBase,                                 "vkCmdDispatchBase");
+	set_proc_address(&GetImageMemoryRequirements2,                     "vkGetImageMemoryRequirements2");
+	set_proc_address(&GetBufferMemoryRequirements2,                    "vkGetBufferMemoryRequirements2");
+	set_proc_address(&GetImageSparseMemoryRequirements2,               "vkGetImageSparseMemoryRequirements2");
+	set_proc_address(&TrimCommandPool,                                 "vkTrimCommandPool");
+	set_proc_address(&GetDeviceQueue2,                                 "vkGetDeviceQueue2");
+	set_proc_address(&CreateSamplerYcbcrConversion,                    "vkCreateSamplerYcbcrConversion");
+	set_proc_address(&DestroySamplerYcbcrConversion,                   "vkDestroySamplerYcbcrConversion");
+	set_proc_address(&CreateDescriptorUpdateTemplate,                  "vkCreateDescriptorUpdateTemplate");
+	set_proc_address(&DestroyDescriptorUpdateTemplate,                 "vkDestroyDescriptorUpdateTemplate");
+	set_proc_address(&UpdateDescriptorSetWithTemplate,                 "vkUpdateDescriptorSetWithTemplate");
+	set_proc_address(&GetDescriptorSetLayoutSupport,                   "vkGetDescriptorSetLayoutSupport");
+	set_proc_address(&CmdDrawIndirectCount,                            "vkCmdDrawIndirectCount");
+	set_proc_address(&CmdDrawIndexedIndirectCount,                     "vkCmdDrawIndexedIndirectCount");
+	set_proc_address(&CreateRenderPass2,                               "vkCreateRenderPass2");
+	set_proc_address(&CmdBeginRenderPass2,                             "vkCmdBeginRenderPass2");
+	set_proc_address(&CmdNextSubpass2,                                 "vkCmdNextSubpass2");
+	set_proc_address(&CmdEndRenderPass2,                               "vkCmdEndRenderPass2");
+	set_proc_address(&ResetQueryPool,                                  "vkResetQueryPool");
+	set_proc_address(&GetSemaphoreCounterValue,                        "vkGetSemaphoreCounterValue");
+	set_proc_address(&WaitSemaphores,                                  "vkWaitSemaphores");
+	set_proc_address(&SignalSemaphore,                                 "vkSignalSemaphore");
+	set_proc_address(&GetBufferDeviceAddress,                          "vkGetBufferDeviceAddress");
+	set_proc_address(&GetBufferOpaqueCaptureAddress,                   "vkGetBufferOpaqueCaptureAddress");
+	set_proc_address(&GetDeviceMemoryOpaqueCaptureAddress,             "vkGetDeviceMemoryOpaqueCaptureAddress");
+	set_proc_address(&CreateSwapchainKHR,                              "vkCreateSwapchainKHR");
+	set_proc_address(&DestroySwapchainKHR,                             "vkDestroySwapchainKHR");
+	set_proc_address(&GetSwapchainImagesKHR,                           "vkGetSwapchainImagesKHR");
+	set_proc_address(&AcquireNextImageKHR,                             "vkAcquireNextImageKHR");
+	set_proc_address(&QueuePresentKHR,                                 "vkQueuePresentKHR");
+	set_proc_address(&GetDeviceGroupPresentCapabilitiesKHR,            "vkGetDeviceGroupPresentCapabilitiesKHR");
+	set_proc_address(&GetDeviceGroupSurfacePresentModesKHR,            "vkGetDeviceGroupSurfacePresentModesKHR");
+	set_proc_address(&AcquireNextImage2KHR,                            "vkAcquireNextImage2KHR");
+	set_proc_address(&CreateSharedSwapchainsKHR,                       "vkCreateSharedSwapchainsKHR");
+	set_proc_address(&GetDeviceGroupPeerMemoryFeaturesKHR,             "vkGetDeviceGroupPeerMemoryFeaturesKHR");
+	set_proc_address(&CmdSetDeviceMaskKHR,                             "vkCmdSetDeviceMaskKHR");
+	set_proc_address(&CmdDispatchBaseKHR,                              "vkCmdDispatchBaseKHR");
+	set_proc_address(&TrimCommandPoolKHR,                              "vkTrimCommandPoolKHR");
+	set_proc_address(&GetMemoryFdKHR,                                  "vkGetMemoryFdKHR");
+	set_proc_address(&GetMemoryFdPropertiesKHR,                        "vkGetMemoryFdPropertiesKHR");
+	set_proc_address(&ImportSemaphoreFdKHR,                            "vkImportSemaphoreFdKHR");
+	set_proc_address(&GetSemaphoreFdKHR,                               "vkGetSemaphoreFdKHR");
+	set_proc_address(&CmdPushDescriptorSetKHR,                         "vkCmdPushDescriptorSetKHR");
+	set_proc_address(&CmdPushDescriptorSetWithTemplateKHR,             "vkCmdPushDescriptorSetWithTemplateKHR");
+	set_proc_address(&CreateDescriptorUpdateTemplateKHR,               "vkCreateDescriptorUpdateTemplateKHR");
+	set_proc_address(&DestroyDescriptorUpdateTemplateKHR,              "vkDestroyDescriptorUpdateTemplateKHR");
+	set_proc_address(&UpdateDescriptorSetWithTemplateKHR,              "vkUpdateDescriptorSetWithTemplateKHR");
+	set_proc_address(&CreateRenderPass2KHR,                            "vkCreateRenderPass2KHR");
+	set_proc_address(&CmdBeginRenderPass2KHR,                          "vkCmdBeginRenderPass2KHR");
+	set_proc_address(&CmdNextSubpass2KHR,                              "vkCmdNextSubpass2KHR");
+	set_proc_address(&CmdEndRenderPass2KHR,                            "vkCmdEndRenderPass2KHR");
+	set_proc_address(&GetSwapchainStatusKHR,                           "vkGetSwapchainStatusKHR");
+	set_proc_address(&ImportFenceFdKHR,                                "vkImportFenceFdKHR");
+	set_proc_address(&GetFenceFdKHR,                                   "vkGetFenceFdKHR");
+	set_proc_address(&AcquireProfilingLockKHR,                         "vkAcquireProfilingLockKHR");
+	set_proc_address(&ReleaseProfilingLockKHR,                         "vkReleaseProfilingLockKHR");
+	set_proc_address(&GetImageMemoryRequirements2KHR,                  "vkGetImageMemoryRequirements2KHR");
+	set_proc_address(&GetBufferMemoryRequirements2KHR,                 "vkGetBufferMemoryRequirements2KHR");
+	set_proc_address(&GetImageSparseMemoryRequirements2KHR,            "vkGetImageSparseMemoryRequirements2KHR");
+	set_proc_address(&CreateSamplerYcbcrConversionKHR,                 "vkCreateSamplerYcbcrConversionKHR");
+	set_proc_address(&DestroySamplerYcbcrConversionKHR,                "vkDestroySamplerYcbcrConversionKHR");
+	set_proc_address(&BindBufferMemory2KHR,                            "vkBindBufferMemory2KHR");
+	set_proc_address(&BindImageMemory2KHR,                             "vkBindImageMemory2KHR");
+	set_proc_address(&GetDescriptorSetLayoutSupportKHR,                "vkGetDescriptorSetLayoutSupportKHR");
+	set_proc_address(&CmdDrawIndirectCountKHR,                         "vkCmdDrawIndirectCountKHR");
+	set_proc_address(&CmdDrawIndexedIndirectCountKHR,                  "vkCmdDrawIndexedIndirectCountKHR");
+	set_proc_address(&GetSemaphoreCounterValueKHR,                     "vkGetSemaphoreCounterValueKHR");
+	set_proc_address(&WaitSemaphoresKHR,                               "vkWaitSemaphoresKHR");
+	set_proc_address(&SignalSemaphoreKHR,                              "vkSignalSemaphoreKHR");
+	set_proc_address(&CmdSetFragmentShadingRateKHR,                    "vkCmdSetFragmentShadingRateKHR");
+	set_proc_address(&WaitForPresentKHR,                               "vkWaitForPresentKHR");
+	set_proc_address(&GetBufferDeviceAddressKHR,                       "vkGetBufferDeviceAddressKHR");
+	set_proc_address(&GetBufferOpaqueCaptureAddressKHR,                "vkGetBufferOpaqueCaptureAddressKHR");
+	set_proc_address(&GetDeviceMemoryOpaqueCaptureAddressKHR,          "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
+	set_proc_address(&CreateDeferredOperationKHR,                      "vkCreateDeferredOperationKHR");
+	set_proc_address(&DestroyDeferredOperationKHR,                     "vkDestroyDeferredOperationKHR");
+	set_proc_address(&GetDeferredOperationMaxConcurrencyKHR,           "vkGetDeferredOperationMaxConcurrencyKHR");
+	set_proc_address(&GetDeferredOperationResultKHR,                   "vkGetDeferredOperationResultKHR");
+	set_proc_address(&DeferredOperationJoinKHR,                        "vkDeferredOperationJoinKHR");
+	set_proc_address(&GetPipelineExecutablePropertiesKHR,              "vkGetPipelineExecutablePropertiesKHR");
+	set_proc_address(&GetPipelineExecutableStatisticsKHR,              "vkGetPipelineExecutableStatisticsKHR");
+	set_proc_address(&GetPipelineExecutableInternalRepresentationsKHR, "vkGetPipelineExecutableInternalRepresentationsKHR");
+	set_proc_address(&CmdSetEvent2KHR,                                 "vkCmdSetEvent2KHR");
+	set_proc_address(&CmdResetEvent2KHR,                               "vkCmdResetEvent2KHR");
+	set_proc_address(&CmdWaitEvents2KHR,                               "vkCmdWaitEvents2KHR");
+	set_proc_address(&CmdPipelineBarrier2KHR,                          "vkCmdPipelineBarrier2KHR");
+	set_proc_address(&CmdWriteTimestamp2KHR,                           "vkCmdWriteTimestamp2KHR");
+	set_proc_address(&QueueSubmit2KHR,                                 "vkQueueSubmit2KHR");
+	set_proc_address(&CmdWriteBufferMarker2AMD,                        "vkCmdWriteBufferMarker2AMD");
+	set_proc_address(&GetQueueCheckpointData2NV,                       "vkGetQueueCheckpointData2NV");
+	set_proc_address(&CmdCopyBuffer2KHR,                               "vkCmdCopyBuffer2KHR");
+	set_proc_address(&CmdCopyImage2KHR,                                "vkCmdCopyImage2KHR");
+	set_proc_address(&CmdCopyBufferToImage2KHR,                        "vkCmdCopyBufferToImage2KHR");
+	set_proc_address(&CmdCopyImageToBuffer2KHR,                        "vkCmdCopyImageToBuffer2KHR");
+	set_proc_address(&CmdBlitImage2KHR,                                "vkCmdBlitImage2KHR");
+	set_proc_address(&CmdResolveImage2KHR,                             "vkCmdResolveImage2KHR");
+	set_proc_address(&DebugMarkerSetObjectTagEXT,                      "vkDebugMarkerSetObjectTagEXT");
+	set_proc_address(&DebugMarkerSetObjectNameEXT,                     "vkDebugMarkerSetObjectNameEXT");
+	set_proc_address(&CmdDebugMarkerBeginEXT,                          "vkCmdDebugMarkerBeginEXT");
+	set_proc_address(&CmdDebugMarkerEndEXT,                            "vkCmdDebugMarkerEndEXT");
+	set_proc_address(&CmdDebugMarkerInsertEXT,                         "vkCmdDebugMarkerInsertEXT");
+	set_proc_address(&CmdBindTransformFeedbackBuffersEXT,              "vkCmdBindTransformFeedbackBuffersEXT");
+	set_proc_address(&CmdBeginTransformFeedbackEXT,                    "vkCmdBeginTransformFeedbackEXT");
+	set_proc_address(&CmdEndTransformFeedbackEXT,                      "vkCmdEndTransformFeedbackEXT");
+	set_proc_address(&CmdBeginQueryIndexedEXT,                         "vkCmdBeginQueryIndexedEXT");
+	set_proc_address(&CmdEndQueryIndexedEXT,                           "vkCmdEndQueryIndexedEXT");
+	set_proc_address(&CmdDrawIndirectByteCountEXT,                     "vkCmdDrawIndirectByteCountEXT");
+	set_proc_address(&CreateCuModuleNVX,                               "vkCreateCuModuleNVX");
+	set_proc_address(&CreateCuFunctionNVX,                             "vkCreateCuFunctionNVX");
+	set_proc_address(&DestroyCuModuleNVX,                              "vkDestroyCuModuleNVX");
+	set_proc_address(&DestroyCuFunctionNVX,                            "vkDestroyCuFunctionNVX");
+	set_proc_address(&CmdCuLaunchKernelNVX,                            "vkCmdCuLaunchKernelNVX");
+	set_proc_address(&GetImageViewHandleNVX,                           "vkGetImageViewHandleNVX");
+	set_proc_address(&GetImageViewAddressNVX,                          "vkGetImageViewAddressNVX");
+	set_proc_address(&CmdDrawIndirectCountAMD,                         "vkCmdDrawIndirectCountAMD");
+	set_proc_address(&CmdDrawIndexedIndirectCountAMD,                  "vkCmdDrawIndexedIndirectCountAMD");
+	set_proc_address(&GetShaderInfoAMD,                                "vkGetShaderInfoAMD");
+	set_proc_address(&CmdBeginConditionalRenderingEXT,                 "vkCmdBeginConditionalRenderingEXT");
+	set_proc_address(&CmdEndConditionalRenderingEXT,                   "vkCmdEndConditionalRenderingEXT");
+	set_proc_address(&CmdSetViewportWScalingNV,                        "vkCmdSetViewportWScalingNV");
+	set_proc_address(&DisplayPowerControlEXT,                          "vkDisplayPowerControlEXT");
+	set_proc_address(&RegisterDeviceEventEXT,                          "vkRegisterDeviceEventEXT");
+	set_proc_address(&RegisterDisplayEventEXT,                         "vkRegisterDisplayEventEXT");
+	set_proc_address(&GetSwapchainCounterEXT,                          "vkGetSwapchainCounterEXT");
+	set_proc_address(&GetRefreshCycleDurationGOOGLE,                   "vkGetRefreshCycleDurationGOOGLE");
+	set_proc_address(&GetPastPresentationTimingGOOGLE,                 "vkGetPastPresentationTimingGOOGLE");
+	set_proc_address(&CmdSetDiscardRectangleEXT,                       "vkCmdSetDiscardRectangleEXT");
+	set_proc_address(&SetHdrMetadataEXT,                               "vkSetHdrMetadataEXT");
+	set_proc_address(&SetDebugUtilsObjectNameEXT,                      "vkSetDebugUtilsObjectNameEXT");
+	set_proc_address(&SetDebugUtilsObjectTagEXT,                       "vkSetDebugUtilsObjectTagEXT");
+	set_proc_address(&QueueBeginDebugUtilsLabelEXT,                    "vkQueueBeginDebugUtilsLabelEXT");
+	set_proc_address(&QueueEndDebugUtilsLabelEXT,                      "vkQueueEndDebugUtilsLabelEXT");
+	set_proc_address(&QueueInsertDebugUtilsLabelEXT,                   "vkQueueInsertDebugUtilsLabelEXT");
+	set_proc_address(&CmdBeginDebugUtilsLabelEXT,                      "vkCmdBeginDebugUtilsLabelEXT");
+	set_proc_address(&CmdEndDebugUtilsLabelEXT,                        "vkCmdEndDebugUtilsLabelEXT");
+	set_proc_address(&CmdInsertDebugUtilsLabelEXT,                     "vkCmdInsertDebugUtilsLabelEXT");
+	set_proc_address(&CmdSetSampleLocationsEXT,                        "vkCmdSetSampleLocationsEXT");
+	set_proc_address(&GetImageDrmFormatModifierPropertiesEXT,          "vkGetImageDrmFormatModifierPropertiesEXT");
+	set_proc_address(&CreateValidationCacheEXT,                        "vkCreateValidationCacheEXT");
+	set_proc_address(&DestroyValidationCacheEXT,                       "vkDestroyValidationCacheEXT");
+	set_proc_address(&MergeValidationCachesEXT,                        "vkMergeValidationCachesEXT");
+	set_proc_address(&GetValidationCacheDataEXT,                       "vkGetValidationCacheDataEXT");
+	set_proc_address(&CmdBindShadingRateImageNV,                       "vkCmdBindShadingRateImageNV");
+	set_proc_address(&CmdSetViewportShadingRatePaletteNV,              "vkCmdSetViewportShadingRatePaletteNV");
+	set_proc_address(&CmdSetCoarseSampleOrderNV,                       "vkCmdSetCoarseSampleOrderNV");
+	set_proc_address(&CreateAccelerationStructureNV,                   "vkCreateAccelerationStructureNV");
+	set_proc_address(&DestroyAccelerationStructureNV,                  "vkDestroyAccelerationStructureNV");
+	set_proc_address(&GetAccelerationStructureMemoryRequirementsNV,    "vkGetAccelerationStructureMemoryRequirementsNV");
+	set_proc_address(&BindAccelerationStructureMemoryNV,               "vkBindAccelerationStructureMemoryNV");
+	set_proc_address(&CmdBuildAccelerationStructureNV,                 "vkCmdBuildAccelerationStructureNV");
+	set_proc_address(&CmdCopyAccelerationStructureNV,                  "vkCmdCopyAccelerationStructureNV");
+	set_proc_address(&CmdTraceRaysNV,                                  "vkCmdTraceRaysNV");
+	set_proc_address(&CreateRayTracingPipelinesNV,                     "vkCreateRayTracingPipelinesNV");
+	set_proc_address(&GetRayTracingShaderGroupHandlesKHR,              "vkGetRayTracingShaderGroupHandlesKHR");
+	set_proc_address(&GetRayTracingShaderGroupHandlesNV,               "vkGetRayTracingShaderGroupHandlesNV");
+	set_proc_address(&GetAccelerationStructureHandleNV,                "vkGetAccelerationStructureHandleNV");
+	set_proc_address(&CmdWriteAccelerationStructuresPropertiesNV,      "vkCmdWriteAccelerationStructuresPropertiesNV");
+	set_proc_address(&CompileDeferredNV,                               "vkCompileDeferredNV");
+	set_proc_address(&GetMemoryHostPointerPropertiesEXT,               "vkGetMemoryHostPointerPropertiesEXT");
+	set_proc_address(&CmdWriteBufferMarkerAMD,                         "vkCmdWriteBufferMarkerAMD");
+	set_proc_address(&GetCalibratedTimestampsEXT,                      "vkGetCalibratedTimestampsEXT");
+	set_proc_address(&CmdDrawMeshTasksNV,                              "vkCmdDrawMeshTasksNV");
+	set_proc_address(&CmdDrawMeshTasksIndirectNV,                      "vkCmdDrawMeshTasksIndirectNV");
+	set_proc_address(&CmdDrawMeshTasksIndirectCountNV,                 "vkCmdDrawMeshTasksIndirectCountNV");
+	set_proc_address(&CmdSetExclusiveScissorNV,                        "vkCmdSetExclusiveScissorNV");
+	set_proc_address(&CmdSetCheckpointNV,                              "vkCmdSetCheckpointNV");
+	set_proc_address(&GetQueueCheckpointDataNV,                        "vkGetQueueCheckpointDataNV");
+	set_proc_address(&InitializePerformanceApiINTEL,                   "vkInitializePerformanceApiINTEL");
+	set_proc_address(&UninitializePerformanceApiINTEL,                 "vkUninitializePerformanceApiINTEL");
+	set_proc_address(&CmdSetPerformanceMarkerINTEL,                    "vkCmdSetPerformanceMarkerINTEL");
+	set_proc_address(&CmdSetPerformanceStreamMarkerINTEL,              "vkCmdSetPerformanceStreamMarkerINTEL");
+	set_proc_address(&CmdSetPerformanceOverrideINTEL,                  "vkCmdSetPerformanceOverrideINTEL");
+	set_proc_address(&AcquirePerformanceConfigurationINTEL,            "vkAcquirePerformanceConfigurationINTEL");
+	set_proc_address(&ReleasePerformanceConfigurationINTEL,            "vkReleasePerformanceConfigurationINTEL");
+	set_proc_address(&QueueSetPerformanceConfigurationINTEL,           "vkQueueSetPerformanceConfigurationINTEL");
+	set_proc_address(&GetPerformanceParameterINTEL,                    "vkGetPerformanceParameterINTEL");
+	set_proc_address(&SetLocalDimmingAMD,                              "vkSetLocalDimmingAMD");
+	set_proc_address(&GetBufferDeviceAddressEXT,                       "vkGetBufferDeviceAddressEXT");
+	set_proc_address(&CmdSetLineStippleEXT,                            "vkCmdSetLineStippleEXT");
+	set_proc_address(&ResetQueryPoolEXT,                               "vkResetQueryPoolEXT");
+	set_proc_address(&CmdSetCullModeEXT,                               "vkCmdSetCullModeEXT");
+	set_proc_address(&CmdSetFrontFaceEXT,                              "vkCmdSetFrontFaceEXT");
+	set_proc_address(&CmdSetPrimitiveTopologyEXT,                      "vkCmdSetPrimitiveTopologyEXT");
+	set_proc_address(&CmdSetViewportWithCountEXT,                      "vkCmdSetViewportWithCountEXT");
+	set_proc_address(&CmdSetScissorWithCountEXT,                       "vkCmdSetScissorWithCountEXT");
+	set_proc_address(&CmdBindVertexBuffers2EXT,                        "vkCmdBindVertexBuffers2EXT");
+	set_proc_address(&CmdSetDepthTestEnableEXT,                        "vkCmdSetDepthTestEnableEXT");
+	set_proc_address(&CmdSetDepthWriteEnableEXT,                       "vkCmdSetDepthWriteEnableEXT");
+	set_proc_address(&CmdSetDepthCompareOpEXT,                         "vkCmdSetDepthCompareOpEXT");
+	set_proc_address(&CmdSetDepthBoundsTestEnableEXT,                  "vkCmdSetDepthBoundsTestEnableEXT");
+	set_proc_address(&CmdSetStencilTestEnableEXT,                      "vkCmdSetStencilTestEnableEXT");
+	set_proc_address(&CmdSetStencilOpEXT,                              "vkCmdSetStencilOpEXT");
+	set_proc_address(&GetGeneratedCommandsMemoryRequirementsNV,        "vkGetGeneratedCommandsMemoryRequirementsNV");
+	set_proc_address(&CmdPreprocessGeneratedCommandsNV,                "vkCmdPreprocessGeneratedCommandsNV");
+	set_proc_address(&CmdExecuteGeneratedCommandsNV,                   "vkCmdExecuteGeneratedCommandsNV");
+	set_proc_address(&CmdBindPipelineShaderGroupNV,                    "vkCmdBindPipelineShaderGroupNV");
+	set_proc_address(&CreateIndirectCommandsLayoutNV,                  "vkCreateIndirectCommandsLayoutNV");
+	set_proc_address(&DestroyIndirectCommandsLayoutNV,                 "vkDestroyIndirectCommandsLayoutNV");
+	set_proc_address(&CreatePrivateDataSlotEXT,                        "vkCreatePrivateDataSlotEXT");
+	set_proc_address(&DestroyPrivateDataSlotEXT,                       "vkDestroyPrivateDataSlotEXT");
+	set_proc_address(&SetPrivateDataEXT,                               "vkSetPrivateDataEXT");
+	set_proc_address(&GetPrivateDataEXT,                               "vkGetPrivateDataEXT");
+	set_proc_address(&CmdSetFragmentShadingRateEnumNV,                 "vkCmdSetFragmentShadingRateEnumNV");
+	set_proc_address(&CmdSetVertexInputEXT,                            "vkCmdSetVertexInputEXT");
+	set_proc_address(&GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,   "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
+	set_proc_address(&CmdSubpassShadingHUAWEI,                         "vkCmdSubpassShadingHUAWEI");
+	set_proc_address(&CmdBindInvocationMaskHUAWEI,                     "vkCmdBindInvocationMaskHUAWEI");
+	set_proc_address(&GetMemoryRemoteAddressNV,                        "vkGetMemoryRemoteAddressNV");
+	set_proc_address(&CmdSetPatchControlPointsEXT,                     "vkCmdSetPatchControlPointsEXT");
+	set_proc_address(&CmdSetRasterizerDiscardEnableEXT,                "vkCmdSetRasterizerDiscardEnableEXT");
+	set_proc_address(&CmdSetDepthBiasEnableEXT,                        "vkCmdSetDepthBiasEnableEXT");
+	set_proc_address(&CmdSetLogicOpEXT,                                "vkCmdSetLogicOpEXT");
+	set_proc_address(&CmdSetPrimitiveRestartEnableEXT,                 "vkCmdSetPrimitiveRestartEnableEXT");
+	set_proc_address(&CmdDrawMultiEXT,                                 "vkCmdDrawMultiEXT");
+	set_proc_address(&CmdDrawMultiIndexedEXT,                          "vkCmdDrawMultiIndexedEXT");
+	set_proc_address(&CreateAccelerationStructureKHR,                  "vkCreateAccelerationStructureKHR");
+	set_proc_address(&DestroyAccelerationStructureKHR,                 "vkDestroyAccelerationStructureKHR");
+	set_proc_address(&CmdBuildAccelerationStructuresKHR,               "vkCmdBuildAccelerationStructuresKHR");
+	set_proc_address(&CmdBuildAccelerationStructuresIndirectKHR,       "vkCmdBuildAccelerationStructuresIndirectKHR");
+	set_proc_address(&BuildAccelerationStructuresKHR,                  "vkBuildAccelerationStructuresKHR");
+	set_proc_address(&CopyAccelerationStructureKHR,                    "vkCopyAccelerationStructureKHR");
+	set_proc_address(&CopyAccelerationStructureToMemoryKHR,            "vkCopyAccelerationStructureToMemoryKHR");
+	set_proc_address(&CopyMemoryToAccelerationStructureKHR,            "vkCopyMemoryToAccelerationStructureKHR");
+	set_proc_address(&WriteAccelerationStructuresPropertiesKHR,        "vkWriteAccelerationStructuresPropertiesKHR");
+	set_proc_address(&CmdCopyAccelerationStructureKHR,                 "vkCmdCopyAccelerationStructureKHR");
+	set_proc_address(&CmdCopyAccelerationStructureToMemoryKHR,         "vkCmdCopyAccelerationStructureToMemoryKHR");
+	set_proc_address(&CmdCopyMemoryToAccelerationStructureKHR,         "vkCmdCopyMemoryToAccelerationStructureKHR");
+	set_proc_address(&GetAccelerationStructureDeviceAddressKHR,        "vkGetAccelerationStructureDeviceAddressKHR");
+	set_proc_address(&CmdWriteAccelerationStructuresPropertiesKHR,     "vkCmdWriteAccelerationStructuresPropertiesKHR");
+	set_proc_address(&GetDeviceAccelerationStructureCompatibilityKHR,  "vkGetDeviceAccelerationStructureCompatibilityKHR");
+	set_proc_address(&GetAccelerationStructureBuildSizesKHR,           "vkGetAccelerationStructureBuildSizesKHR");
+	set_proc_address(&CmdTraceRaysKHR,                                 "vkCmdTraceRaysKHR");
+	set_proc_address(&CreateRayTracingPipelinesKHR,                    "vkCreateRayTracingPipelinesKHR");
+	set_proc_address(&GetRayTracingCaptureReplayShaderGroupHandlesKHR, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
+	set_proc_address(&CmdTraceRaysIndirectKHR,                         "vkCmdTraceRaysIndirectKHR");
+	set_proc_address(&GetRayTracingShaderGroupStackSizeKHR,            "vkGetRayTracingShaderGroupStackSizeKHR");
+	set_proc_address(&CmdSetRayTracingPipelineStackSizeKHR,            "vkCmdSetRayTracingPipelineStackSizeKHR");
+	set_proc_address(&SetDeviceLoaderData,                             "vkSetDeviceLoaderData");
+	set_proc_address(&LayerDestroyDevice,                              "vkLayerDestroyDevice");
+	set_proc_address(&GetMemoryWin32HandleKHR,                         "vkGetMemoryWin32HandleKHR");
+	set_proc_address(&GetMemoryWin32HandlePropertiesKHR,               "vkGetMemoryWin32HandlePropertiesKHR");
+	set_proc_address(&ImportSemaphoreWin32HandleKHR,                   "vkImportSemaphoreWin32HandleKHR");
+	set_proc_address(&GetSemaphoreWin32HandleKHR,                      "vkGetSemaphoreWin32HandleKHR");
+	set_proc_address(&ImportFenceWin32HandleKHR,                       "vkImportFenceWin32HandleKHR");
+	set_proc_address(&GetFenceWin32HandleKHR,                          "vkGetFenceWin32HandleKHR");
+	set_proc_address(&GetMemoryWin32HandleNV,                          "vkGetMemoryWin32HandleNV");
+	set_proc_address(&AcquireFullScreenExclusiveModeEXT,               "vkAcquireFullScreenExclusiveModeEXT");
+	set_proc_address(&ReleaseFullScreenExclusiveModeEXT,               "vkReleaseFullScreenExclusiveModeEXT");
+	set_proc_address(&GetDeviceGroupSurfacePresentModes2EXT,           "vkGetDeviceGroupSurfacePresentModes2EXT");
+
+	// Loader Procedures
+	set_proc_address(&CreateInstance,                        "vkCreateInstance");
+	set_proc_address(&EnumerateInstanceExtensionProperties,  "vkEnumerateInstanceExtensionProperties");
+	set_proc_address(&EnumerateInstanceLayerProperties,      "vkEnumerateInstanceLayerProperties");
+	set_proc_address(&EnumerateInstanceVersion,              "vkEnumerateInstanceVersion");
+	set_proc_address(&DebugUtilsMessengerCallbackEXT,        "vkDebugUtilsMessengerCallbackEXT");
+	set_proc_address(&DeviceMemoryReportCallbackEXT,         "vkDeviceMemoryReportCallbackEXT");
+	set_proc_address(&NegotiateLoaderLayerInterfaceVersion,  "vkNegotiateLoaderLayerInterfaceVersion");
+	set_proc_address(&icdNegotiateLoaderICDInterfaceVersion, "vkicdNegotiateLoaderICDInterfaceVersion");
+
+}
+
+

vendor/vulkan/structs.odin

@@ -0,0 +1,5446 @@
+//
+// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
+//
+package vulkan
+
+import "core:c"
+
+when ODIN_OS == "windows" {
+	import win32 "core:sys/windows"
+
+	HINSTANCE           :: win32.HINSTANCE;
+	HWND                :: win32.HWND;
+	HMONITOR            :: win32.HMONITOR;
+	HANDLE              :: win32.HANDLE;
+	LPCWSTR             :: win32.LPCWSTR;
+	SECURITY_ATTRIBUTES :: win32.SECURITY_ATTRIBUTES;
+	DWORD               :: win32.DWORD;
+	LONG                :: win32.LONG;
+	LUID                :: win32.LUID;
+} else {
+	HINSTANCE           :: distinct rawptr;
+	HWND                :: distinct rawptr;
+	HMONITOR            :: distinct rawptr;
+	HANDLE              :: distinct rawptr;
+	LPCWSTR             :: ^u16;
+	SECURITY_ATTRIBUTES :: struct {};
+	DWORD               :: u32;
+	LONG                :: c.long;
+	LUID :: struct {
+		LowPart:  DWORD,
+		HighPart: LONG,
+	}
+}
+
+CAMetalLayer :: struct {};
+
+/********************************/
+
+Extent2D :: struct {
+	width:  u32,
+	height: u32,
+}
+
+Extent3D :: struct {
+	width:  u32,
+	height: u32,
+	depth:  u32,
+}
+
+Offset2D :: struct {
+	x: i32,
+	y: i32,
+}
+
+Offset3D :: struct {
+	x: i32,
+	y: i32,
+	z: i32,
+}
+
+Rect2D :: struct {
+	offset: Offset2D,
+	extent: Extent2D,
+}
+
+BaseInStructure :: struct {
+	sType: StructureType,
+	pNext: ^BaseInStructure,
+}
+
+BaseOutStructure :: struct {
+	sType: StructureType,
+	pNext: ^BaseOutStructure,
+}
+
+BufferMemoryBarrier :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	srcAccessMask:       AccessFlags,
+	dstAccessMask:       AccessFlags,
+	srcQueueFamilyIndex: u32,
+	dstQueueFamilyIndex: u32,
+	buffer:              Buffer,
+	offset:              DeviceSize,
+	size:                DeviceSize,
+}
+
+DispatchIndirectCommand :: struct {
+	x: u32,
+	y: u32,
+	z: u32,
+}
+
+DrawIndexedIndirectCommand :: struct {
+	indexCount:    u32,
+	instanceCount: u32,
+	firstIndex:    u32,
+	vertexOffset:  i32,
+	firstInstance: u32,
+}
+
+DrawIndirectCommand :: struct {
+	vertexCount:   u32,
+	instanceCount: u32,
+	firstVertex:   u32,
+	firstInstance: u32,
+}
+
+ImageSubresourceRange :: struct {
+	aspectMask:     ImageAspectFlags,
+	baseMipLevel:   u32,
+	levelCount:     u32,
+	baseArrayLayer: u32,
+	layerCount:     u32,
+}
+
+ImageMemoryBarrier :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	srcAccessMask:       AccessFlags,
+	dstAccessMask:       AccessFlags,
+	oldLayout:           ImageLayout,
+	newLayout:           ImageLayout,
+	srcQueueFamilyIndex: u32,
+	dstQueueFamilyIndex: u32,
+	image:               Image,
+	subresourceRange:    ImageSubresourceRange,
+}
+
+MemoryBarrier :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	srcAccessMask: AccessFlags,
+	dstAccessMask: AccessFlags,
+}
+
+PipelineCacheHeaderVersionOne :: struct {
+	headerSize:        u32,
+	headerVersion:     PipelineCacheHeaderVersion,
+	vendorID:          u32,
+	deviceID:          u32,
+	pipelineCacheUUID: [UUID_SIZE]u8,
+}
+
+AllocationCallbacks :: struct {
+	pUserData:             rawptr,
+	pfnAllocation:         ProcAllocationFunction,
+	pfnReallocation:       ProcReallocationFunction,
+	pfnFree:               ProcFreeFunction,
+	pfnInternalAllocation: ProcInternalAllocationNotification,
+	pfnInternalFree:       ProcInternalFreeNotification,
+}
+
+ApplicationInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	pApplicationName:   cstring,
+	applicationVersion: u32,
+	pEngineName:        cstring,
+	engineVersion:      u32,
+	apiVersion:         u32,
+}
+
+FormatProperties :: struct {
+	linearTilingFeatures:  FormatFeatureFlags,
+	optimalTilingFeatures: FormatFeatureFlags,
+	bufferFeatures:        FormatFeatureFlags,
+}
+
+ImageFormatProperties :: struct {
+	maxExtent:       Extent3D,
+	maxMipLevels:    u32,
+	maxArrayLayers:  u32,
+	sampleCounts:    SampleCountFlags,
+	maxResourceSize: DeviceSize,
+}
+
+InstanceCreateInfo :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   InstanceCreateFlags,
+	pApplicationInfo:        ^ApplicationInfo,
+	enabledLayerCount:       u32,
+	ppEnabledLayerNames:     cstring_array,
+	enabledExtensionCount:   u32,
+	ppEnabledExtensionNames: cstring_array,
+}
+
+MemoryHeap :: struct {
+	size:  DeviceSize,
+	flags: MemoryHeapFlags,
+}
+
+MemoryType :: struct {
+	propertyFlags: MemoryPropertyFlags,
+	heapIndex:     u32,
+}
+
+PhysicalDeviceFeatures :: struct {
+	robustBufferAccess:                      b32,
+	fullDrawIndexUint32:                     b32,
+	imageCubeArray:                          b32,
+	independentBlend:                        b32,
+	geometryShader:                          b32,
+	tessellationShader:                      b32,
+	sampleRateShading:                       b32,
+	dualSrcBlend:                            b32,
+	logicOp:                                 b32,
+	multiDrawIndirect:                       b32,
+	drawIndirectFirstInstance:               b32,
+	depthClamp:                              b32,
+	depthBiasClamp:                          b32,
+	fillModeNonSolid:                        b32,
+	depthBounds:                             b32,
+	wideLines:                               b32,
+	largePoints:                             b32,
+	alphaToOne:                              b32,
+	multiViewport:                           b32,
+	samplerAnisotropy:                       b32,
+	textureCompressionETC2:                  b32,
+	textureCompressionASTC_LDR:              b32,
+	textureCompressionBC:                    b32,
+	occlusionQueryPrecise:                   b32,
+	pipelineStatisticsQuery:                 b32,
+	vertexPipelineStoresAndAtomics:          b32,
+	fragmentStoresAndAtomics:                b32,
+	shaderTessellationAndGeometryPointSize:  b32,
+	shaderImageGatherExtended:               b32,
+	shaderStorageImageExtendedFormats:       b32,
+	shaderStorageImageMultisample:           b32,
+	shaderStorageImageReadWithoutFormat:     b32,
+	shaderStorageImageWriteWithoutFormat:    b32,
+	shaderUniformBufferArrayDynamicIndexing: b32,
+	shaderSampledImageArrayDynamicIndexing:  b32,
+	shaderStorageBufferArrayDynamicIndexing: b32,
+	shaderStorageImageArrayDynamicIndexing:  b32,
+	shaderClipDistance:                      b32,
+	shaderCullDistance:                      b32,
+	shaderFloat64:                           b32,
+	shaderInt64:                             b32,
+	shaderInt16:                             b32,
+	shaderResourceResidency:                 b32,
+	shaderResourceMinLod:                    b32,
+	sparseBinding:                           b32,
+	sparseResidencyBuffer:                   b32,
+	sparseResidencyImage2D:                  b32,
+	sparseResidencyImage3D:                  b32,
+	sparseResidency2Samples:                 b32,
+	sparseResidency4Samples:                 b32,
+	sparseResidency8Samples:                 b32,
+	sparseResidency16Samples:                b32,
+	sparseResidencyAliased:                  b32,
+	variableMultisampleRate:                 b32,
+	inheritedQueries:                        b32,
+}
+
+PhysicalDeviceLimits :: struct {
+	maxImageDimension1D:                             u32,
+	maxImageDimension2D:                             u32,
+	maxImageDimension3D:                             u32,
+	maxImageDimensionCube:                           u32,
+	maxImageArrayLayers:                             u32,
+	maxTexelBufferElements:                          u32,
+	maxUniformBufferRange:                           u32,
+	maxStorageBufferRange:                           u32,
+	maxPushConstantsSize:                            u32,
+	maxMemoryAllocationCount:                        u32,
+	maxSamplerAllocationCount:                       u32,
+	bufferImageGranularity:                          DeviceSize,
+	sparseAddressSpaceSize:                          DeviceSize,
+	maxBoundDescriptorSets:                          u32,
+	maxPerStageDescriptorSamplers:                   u32,
+	maxPerStageDescriptorUniformBuffers:             u32,
+	maxPerStageDescriptorStorageBuffers:             u32,
+	maxPerStageDescriptorSampledImages:              u32,
+	maxPerStageDescriptorStorageImages:              u32,
+	maxPerStageDescriptorInputAttachments:           u32,
+	maxPerStageResources:                            u32,
+	maxDescriptorSetSamplers:                        u32,
+	maxDescriptorSetUniformBuffers:                  u32,
+	maxDescriptorSetUniformBuffersDynamic:           u32,
+	maxDescriptorSetStorageBuffers:                  u32,
+	maxDescriptorSetStorageBuffersDynamic:           u32,
+	maxDescriptorSetSampledImages:                   u32,
+	maxDescriptorSetStorageImages:                   u32,
+	maxDescriptorSetInputAttachments:                u32,
+	maxVertexInputAttributes:                        u32,
+	maxVertexInputBindings:                          u32,
+	maxVertexInputAttributeOffset:                   u32,
+	maxVertexInputBindingStride:                     u32,
+	maxVertexOutputComponents:                       u32,
+	maxTessellationGenerationLevel:                  u32,
+	maxTessellationPatchSize:                        u32,
+	maxTessellationControlPerVertexInputComponents:  u32,
+	maxTessellationControlPerVertexOutputComponents: u32,
+	maxTessellationControlPerPatchOutputComponents:  u32,
+	maxTessellationControlTotalOutputComponents:     u32,
+	maxTessellationEvaluationInputComponents:        u32,
+	maxTessellationEvaluationOutputComponents:       u32,
+	maxGeometryShaderInvocations:                    u32,
+	maxGeometryInputComponents:                      u32,
+	maxGeometryOutputComponents:                     u32,
+	maxGeometryOutputVertices:                       u32,
+	maxGeometryTotalOutputComponents:                u32,
+	maxFragmentInputComponents:                      u32,
+	maxFragmentOutputAttachments:                    u32,
+	maxFragmentDualSrcAttachments:                   u32,
+	maxFragmentCombinedOutputResources:              u32,
+	maxComputeSharedMemorySize:                      u32,
+	maxComputeWorkGroupCount:                        [3]u32,
+	maxComputeWorkGroupInvocations:                  u32,
+	maxComputeWorkGroupSize:                         [3]u32,
+	subPixelPrecisionBits:                           u32,
+	subTexelPrecisionBits:                           u32,
+	mipmapPrecisionBits:                             u32,
+	maxDrawIndexedIndexValue:                        u32,
+	maxDrawIndirectCount:                            u32,
+	maxSamplerLodBias:                               f32,
+	maxSamplerAnisotropy:                            f32,
+	maxViewports:                                    u32,
+	maxViewportDimensions:                           [2]u32,
+	viewportBoundsRange:                             [2]f32,
+	viewportSubPixelBits:                            u32,
+	minMemoryMapAlignment:                           int,
+	minTexelBufferOffsetAlignment:                   DeviceSize,
+	minUniformBufferOffsetAlignment:                 DeviceSize,
+	minStorageBufferOffsetAlignment:                 DeviceSize,
+	minTexelOffset:                                  i32,
+	maxTexelOffset:                                  u32,
+	minTexelGatherOffset:                            i32,
+	maxTexelGatherOffset:                            u32,
+	minInterpolationOffset:                          f32,
+	maxInterpolationOffset:                          f32,
+	subPixelInterpolationOffsetBits:                 u32,
+	maxFramebufferWidth:                             u32,
+	maxFramebufferHeight:                            u32,
+	maxFramebufferLayers:                            u32,
+	framebufferColorSampleCounts:                    SampleCountFlags,
+	framebufferDepthSampleCounts:                    SampleCountFlags,
+	framebufferStencilSampleCounts:                  SampleCountFlags,
+	framebufferNoAttachmentsSampleCounts:            SampleCountFlags,
+	maxColorAttachments:                             u32,
+	sampledImageColorSampleCounts:                   SampleCountFlags,
+	sampledImageIntegerSampleCounts:                 SampleCountFlags,
+	sampledImageDepthSampleCounts:                   SampleCountFlags,
+	sampledImageStencilSampleCounts:                 SampleCountFlags,
+	storageImageSampleCounts:                        SampleCountFlags,
+	maxSampleMaskWords:                              u32,
+	timestampComputeAndGraphics:                     b32,
+	timestampPeriod:                                 f32,
+	maxClipDistances:                                u32,
+	maxCullDistances:                                u32,
+	maxCombinedClipAndCullDistances:                 u32,
+	discreteQueuePriorities:                         u32,
+	pointSizeRange:                                  [2]f32,
+	lineWidthRange:                                  [2]f32,
+	pointSizeGranularity:                            f32,
+	lineWidthGranularity:                            f32,
+	strictLines:                                     b32,
+	standardSampleLocations:                         b32,
+	optimalBufferCopyOffsetAlignment:                DeviceSize,
+	optimalBufferCopyRowPitchAlignment:              DeviceSize,
+	nonCoherentAtomSize:                             DeviceSize,
+}
+
+PhysicalDeviceMemoryProperties :: struct {
+	memoryTypeCount: u32,
+	memoryTypes:     [MAX_MEMORY_TYPES]MemoryType,
+	memoryHeapCount: u32,
+	memoryHeaps:     [MAX_MEMORY_HEAPS]MemoryHeap,
+}
+
+PhysicalDeviceSparseProperties :: struct {
+	residencyStandard2DBlockShape:            b32,
+	residencyStandard2DMultisampleBlockShape: b32,
+	residencyStandard3DBlockShape:            b32,
+	residencyAlignedMipSize:                  b32,
+	residencyNonResidentStrict:               b32,
+}
+
+PhysicalDeviceProperties :: struct {
+	apiVersion:        u32,
+	driverVersion:     u32,
+	vendorID:          u32,
+	deviceID:          u32,
+	deviceType:        PhysicalDeviceType,
+	deviceName:        [MAX_PHYSICAL_DEVICE_NAME_SIZE]byte,
+	pipelineCacheUUID: [UUID_SIZE]u8,
+	limits:            PhysicalDeviceLimits,
+	sparseProperties:  PhysicalDeviceSparseProperties,
+}
+
+QueueFamilyProperties :: struct {
+	queueFlags:                  QueueFlags,
+	queueCount:                  u32,
+	timestampValidBits:          u32,
+	minImageTransferGranularity: Extent3D,
+}
+
+DeviceQueueCreateInfo :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            DeviceQueueCreateFlags,
+	queueFamilyIndex: u32,
+	queueCount:       u32,
+	pQueuePriorities: ^f32,
+}
+
+DeviceCreateInfo :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   DeviceCreateFlags,
+	queueCreateInfoCount:    u32,
+	pQueueCreateInfos:       ^DeviceQueueCreateInfo,
+	enabledLayerCount:       u32,
+	ppEnabledLayerNames:     cstring_array,
+	enabledExtensionCount:   u32,
+	ppEnabledExtensionNames: cstring_array,
+	pEnabledFeatures:        ^PhysicalDeviceFeatures,
+}
+
+ExtensionProperties :: struct {
+	extensionName: [MAX_EXTENSION_NAME_SIZE]byte,
+	specVersion:   u32,
+}
+
+LayerProperties :: struct {
+	layerName:             [MAX_EXTENSION_NAME_SIZE]byte,
+	specVersion:           u32,
+	implementationVersion: u32,
+	description:           [MAX_DESCRIPTION_SIZE]byte,
+}
+
+SubmitInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	waitSemaphoreCount:   u32,
+	pWaitSemaphores:      ^Semaphore,
+	pWaitDstStageMask:    ^PipelineStageFlags,
+	commandBufferCount:   u32,
+	pCommandBuffers:      ^CommandBuffer,
+	signalSemaphoreCount: u32,
+	pSignalSemaphores:    ^Semaphore,
+}
+
+MappedMemoryRange :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	memory: DeviceMemory,
+	offset: DeviceSize,
+	size:   DeviceSize,
+}
+
+MemoryAllocateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	allocationSize:  DeviceSize,
+	memoryTypeIndex: u32,
+}
+
+MemoryRequirements :: struct {
+	size:           DeviceSize,
+	alignment:      DeviceSize,
+	memoryTypeBits: u32,
+}
+
+SparseMemoryBind :: struct {
+	resourceOffset: DeviceSize,
+	size:           DeviceSize,
+	memory:         DeviceMemory,
+	memoryOffset:   DeviceSize,
+	flags:          SparseMemoryBindFlags,
+}
+
+SparseBufferMemoryBindInfo :: struct {
+	buffer:    Buffer,
+	bindCount: u32,
+	pBinds:    ^SparseMemoryBind,
+}
+
+SparseImageOpaqueMemoryBindInfo :: struct {
+	image:     Image,
+	bindCount: u32,
+	pBinds:    ^SparseMemoryBind,
+}
+
+ImageSubresource :: struct {
+	aspectMask: ImageAspectFlags,
+	mipLevel:   u32,
+	arrayLayer: u32,
+}
+
+SparseImageMemoryBind :: struct {
+	subresource:  ImageSubresource,
+	offset:       Offset3D,
+	extent:       Extent3D,
+	memory:       DeviceMemory,
+	memoryOffset: DeviceSize,
+	flags:        SparseMemoryBindFlags,
+}
+
+SparseImageMemoryBindInfo :: struct {
+	image:     Image,
+	bindCount: u32,
+	pBinds:    ^SparseImageMemoryBind,
+}
+
+BindSparseInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	waitSemaphoreCount:   u32,
+	pWaitSemaphores:      ^Semaphore,
+	bufferBindCount:      u32,
+	pBufferBinds:         ^SparseBufferMemoryBindInfo,
+	imageOpaqueBindCount: u32,
+	pImageOpaqueBinds:    ^SparseImageOpaqueMemoryBindInfo,
+	imageBindCount:       u32,
+	pImageBinds:          ^SparseImageMemoryBindInfo,
+	signalSemaphoreCount: u32,
+	pSignalSemaphores:    ^Semaphore,
+}
+
+SparseImageFormatProperties :: struct {
+	aspectMask:       ImageAspectFlags,
+	imageGranularity: Extent3D,
+	flags:            SparseImageFormatFlags,
+}
+
+SparseImageMemoryRequirements :: struct {
+	formatProperties:     SparseImageFormatProperties,
+	imageMipTailFirstLod: u32,
+	imageMipTailSize:     DeviceSize,
+	imageMipTailOffset:   DeviceSize,
+	imageMipTailStride:   DeviceSize,
+}
+
+FenceCreateInfo :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: FenceCreateFlags,
+}
+
+SemaphoreCreateInfo :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: SemaphoreCreateFlags,
+}
+
+EventCreateInfo :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: EventCreateFlags,
+}
+
+QueryPoolCreateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	flags:              QueryPoolCreateFlags,
+	queryType:          QueryType,
+	queryCount:         u32,
+	pipelineStatistics: QueryPipelineStatisticFlags,
+}
+
+BufferCreateInfo :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 BufferCreateFlags,
+	size:                  DeviceSize,
+	usage:                 BufferUsageFlags,
+	sharingMode:           SharingMode,
+	queueFamilyIndexCount: u32,
+	pQueueFamilyIndices:   ^u32,
+}
+
+BufferViewCreateInfo :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	flags:  BufferViewCreateFlags,
+	buffer: Buffer,
+	format: Format,
+	offset: DeviceSize,
+	range:  DeviceSize,
+}
+
+ImageCreateInfo :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 ImageCreateFlags,
+	imageType:             ImageType,
+	format:                Format,
+	extent:                Extent3D,
+	mipLevels:             u32,
+	arrayLayers:           u32,
+	samples:               SampleCountFlags,
+	tiling:                ImageTiling,
+	usage:                 ImageUsageFlags,
+	sharingMode:           SharingMode,
+	queueFamilyIndexCount: u32,
+	pQueueFamilyIndices:   ^u32,
+	initialLayout:         ImageLayout,
+}
+
+SubresourceLayout :: struct {
+	offset:     DeviceSize,
+	size:       DeviceSize,
+	rowPitch:   DeviceSize,
+	arrayPitch: DeviceSize,
+	depthPitch: DeviceSize,
+}
+
+ComponentMapping :: struct {
+	r: ComponentSwizzle,
+	g: ComponentSwizzle,
+	b: ComponentSwizzle,
+	a: ComponentSwizzle,
+}
+
+ImageViewCreateInfo :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            ImageViewCreateFlags,
+	image:            Image,
+	viewType:         ImageViewType,
+	format:           Format,
+	components:       ComponentMapping,
+	subresourceRange: ImageSubresourceRange,
+}
+
+ShaderModuleCreateInfo :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	flags:    ShaderModuleCreateFlags,
+	codeSize: int,
+	pCode:    ^u32,
+}
+
+PipelineCacheCreateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           PipelineCacheCreateFlags,
+	initialDataSize: int,
+	pInitialData:    rawptr,
+}
+
+SpecializationMapEntry :: struct {
+	constantID: u32,
+	offset:     u32,
+	size:       int,
+}
+
+SpecializationInfo :: struct {
+	mapEntryCount: u32,
+	pMapEntries:   ^SpecializationMapEntry,
+	dataSize:      int,
+	pData:         rawptr,
+}
+
+PipelineShaderStageCreateInfo :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	flags:               PipelineShaderStageCreateFlags,
+	stage:               ShaderStageFlags,
+	module:              ShaderModule,
+	pName:               cstring,
+	pSpecializationInfo: ^SpecializationInfo,
+}
+
+ComputePipelineCreateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	flags:              PipelineCreateFlags,
+	stage:              PipelineShaderStageCreateInfo,
+	layout:             PipelineLayout,
+	basePipelineHandle: Pipeline,
+	basePipelineIndex:  i32,
+}
+
+VertexInputBindingDescription :: struct {
+	binding:   u32,
+	stride:    u32,
+	inputRate: VertexInputRate,
+}
+
+VertexInputAttributeDescription :: struct {
+	location: u32,
+	binding:  u32,
+	format:   Format,
+	offset:   u32,
+}
+
+PipelineVertexInputStateCreateInfo :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	flags:                           PipelineVertexInputStateCreateFlags,
+	vertexBindingDescriptionCount:   u32,
+	pVertexBindingDescriptions:      ^VertexInputBindingDescription,
+	vertexAttributeDescriptionCount: u32,
+	pVertexAttributeDescriptions:    ^VertexInputAttributeDescription,
+}
+
+PipelineInputAssemblyStateCreateInfo :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	flags:                  PipelineInputAssemblyStateCreateFlags,
+	topology:               PrimitiveTopology,
+	primitiveRestartEnable: b32,
+}
+
+PipelineTessellationStateCreateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	flags:              PipelineTessellationStateCreateFlags,
+	patchControlPoints: u32,
+}
+
+Viewport :: struct {
+	x:        f32,
+	y:        f32,
+	width:    f32,
+	height:   f32,
+	minDepth: f32,
+	maxDepth: f32,
+}
+
+PipelineViewportStateCreateInfo :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	flags:         PipelineViewportStateCreateFlags,
+	viewportCount: u32,
+	pViewports:    ^Viewport,
+	scissorCount:  u32,
+	pScissors:     ^Rect2D,
+}
+
+PipelineRasterizationStateCreateInfo :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   PipelineRasterizationStateCreateFlags,
+	depthClampEnable:        b32,
+	rasterizerDiscardEnable: b32,
+	polygonMode:             PolygonMode,
+	cullMode:                CullModeFlags,
+	frontFace:               FrontFace,
+	depthBiasEnable:         b32,
+	depthBiasConstantFactor: f32,
+	depthBiasClamp:          f32,
+	depthBiasSlopeFactor:    f32,
+	lineWidth:               f32,
+}
+
+PipelineMultisampleStateCreateInfo :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 PipelineMultisampleStateCreateFlags,
+	rasterizationSamples:  SampleCountFlags,
+	sampleShadingEnable:   b32,
+	minSampleShading:      f32,
+	pSampleMask:           ^SampleMask,
+	alphaToCoverageEnable: b32,
+	alphaToOneEnable:      b32,
+}
+
+StencilOpState :: struct {
+	failOp:      StencilOp,
+	passOp:      StencilOp,
+	depthFailOp: StencilOp,
+	compareOp:   CompareOp,
+	compareMask: u32,
+	writeMask:   u32,
+	reference:   u32,
+}
+
+PipelineDepthStencilStateCreateInfo :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 PipelineDepthStencilStateCreateFlags,
+	depthTestEnable:       b32,
+	depthWriteEnable:      b32,
+	depthCompareOp:        CompareOp,
+	depthBoundsTestEnable: b32,
+	stencilTestEnable:     b32,
+	front:                 StencilOpState,
+	back:                  StencilOpState,
+	minDepthBounds:        f32,
+	maxDepthBounds:        f32,
+}
+
+PipelineColorBlendAttachmentState :: struct {
+	blendEnable:         b32,
+	srcColorBlendFactor: BlendFactor,
+	dstColorBlendFactor: BlendFactor,
+	colorBlendOp:        BlendOp,
+	srcAlphaBlendFactor: BlendFactor,
+	dstAlphaBlendFactor: BlendFactor,
+	alphaBlendOp:        BlendOp,
+	colorWriteMask:      ColorComponentFlags,
+}
+
+PipelineColorBlendStateCreateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           PipelineColorBlendStateCreateFlags,
+	logicOpEnable:   b32,
+	logicOp:         LogicOp,
+	attachmentCount: u32,
+	pAttachments:    ^PipelineColorBlendAttachmentState,
+	blendConstants:  [4]f32,
+}
+
+PipelineDynamicStateCreateInfo :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	flags:             PipelineDynamicStateCreateFlags,
+	dynamicStateCount: u32,
+	pDynamicStates:    ^DynamicState,
+}
+
+GraphicsPipelineCreateInfo :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	flags:               PipelineCreateFlags,
+	stageCount:          u32,
+	pStages:             ^PipelineShaderStageCreateInfo,
+	pVertexInputState:   ^PipelineVertexInputStateCreateInfo,
+	pInputAssemblyState: ^PipelineInputAssemblyStateCreateInfo,
+	pTessellationState:  ^PipelineTessellationStateCreateInfo,
+	pViewportState:      ^PipelineViewportStateCreateInfo,
+	pRasterizationState: ^PipelineRasterizationStateCreateInfo,
+	pMultisampleState:   ^PipelineMultisampleStateCreateInfo,
+	pDepthStencilState:  ^PipelineDepthStencilStateCreateInfo,
+	pColorBlendState:    ^PipelineColorBlendStateCreateInfo,
+	pDynamicState:       ^PipelineDynamicStateCreateInfo,
+	layout:              PipelineLayout,
+	renderPass:          RenderPass,
+	subpass:             u32,
+	basePipelineHandle:  Pipeline,
+	basePipelineIndex:   i32,
+}
+
+PushConstantRange :: struct {
+	stageFlags: ShaderStageFlags,
+	offset:     u32,
+	size:       u32,
+}
+
+PipelineLayoutCreateInfo :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	flags:                  PipelineLayoutCreateFlags,
+	setLayoutCount:         u32,
+	pSetLayouts:            ^DescriptorSetLayout,
+	pushConstantRangeCount: u32,
+	pPushConstantRanges:    ^PushConstantRange,
+}
+
+SamplerCreateInfo :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   SamplerCreateFlags,
+	magFilter:               Filter,
+	minFilter:               Filter,
+	mipmapMode:              SamplerMipmapMode,
+	addressModeU:            SamplerAddressMode,
+	addressModeV:            SamplerAddressMode,
+	addressModeW:            SamplerAddressMode,
+	mipLodBias:              f32,
+	anisotropyEnable:        b32,
+	maxAnisotropy:           f32,
+	compareEnable:           b32,
+	compareOp:               CompareOp,
+	minLod:                  f32,
+	maxLod:                  f32,
+	borderColor:             BorderColor,
+	unnormalizedCoordinates: b32,
+}
+
+CopyDescriptorSet :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	srcSet:          DescriptorSet,
+	srcBinding:      u32,
+	srcArrayElement: u32,
+	dstSet:          DescriptorSet,
+	dstBinding:      u32,
+	dstArrayElement: u32,
+	descriptorCount: u32,
+}
+
+DescriptorBufferInfo :: struct {
+	buffer: Buffer,
+	offset: DeviceSize,
+	range:  DeviceSize,
+}
+
+DescriptorImageInfo :: struct {
+	sampler:     Sampler,
+	imageView:   ImageView,
+	imageLayout: ImageLayout,
+}
+
+DescriptorPoolSize :: struct {
+	type:            DescriptorType,
+	descriptorCount: u32,
+}
+
+DescriptorPoolCreateInfo :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	flags:         DescriptorPoolCreateFlags,
+	maxSets:       u32,
+	poolSizeCount: u32,
+	pPoolSizes:    ^DescriptorPoolSize,
+}
+
+DescriptorSetAllocateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	descriptorPool:     DescriptorPool,
+	descriptorSetCount: u32,
+	pSetLayouts:        ^DescriptorSetLayout,
+}
+
+DescriptorSetLayoutBinding :: struct {
+	binding:            u32,
+	descriptorType:     DescriptorType,
+	descriptorCount:    u32,
+	stageFlags:         ShaderStageFlags,
+	pImmutableSamplers: ^Sampler,
+}
+
+DescriptorSetLayoutCreateInfo :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	flags:        DescriptorSetLayoutCreateFlags,
+	bindingCount: u32,
+	pBindings:    ^DescriptorSetLayoutBinding,
+}
+
+WriteDescriptorSet :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	dstSet:           DescriptorSet,
+	dstBinding:       u32,
+	dstArrayElement:  u32,
+	descriptorCount:  u32,
+	descriptorType:   DescriptorType,
+	pImageInfo:       ^DescriptorImageInfo,
+	pBufferInfo:      ^DescriptorBufferInfo,
+	pTexelBufferView: ^BufferView,
+}
+
+AttachmentDescription :: struct {
+	flags:          AttachmentDescriptionFlags,
+	format:         Format,
+	samples:        SampleCountFlags,
+	loadOp:         AttachmentLoadOp,
+	storeOp:        AttachmentStoreOp,
+	stencilLoadOp:  AttachmentLoadOp,
+	stencilStoreOp: AttachmentStoreOp,
+	initialLayout:  ImageLayout,
+	finalLayout:    ImageLayout,
+}
+
+AttachmentReference :: struct {
+	attachment: u32,
+	layout:     ImageLayout,
+}
+
+FramebufferCreateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           FramebufferCreateFlags,
+	renderPass:      RenderPass,
+	attachmentCount: u32,
+	pAttachments:    ^ImageView,
+	width:           u32,
+	height:          u32,
+	layers:          u32,
+}
+
+SubpassDescription :: struct {
+	flags:                   SubpassDescriptionFlags,
+	pipelineBindPoint:       PipelineBindPoint,
+	inputAttachmentCount:    u32,
+	pInputAttachments:       ^AttachmentReference,
+	colorAttachmentCount:    u32,
+	pColorAttachments:       ^AttachmentReference,
+	pResolveAttachments:     ^AttachmentReference,
+	pDepthStencilAttachment: ^AttachmentReference,
+	preserveAttachmentCount: u32,
+	pPreserveAttachments:    ^u32,
+}
+
+SubpassDependency :: struct {
+	srcSubpass:      u32,
+	dstSubpass:      u32,
+	srcStageMask:    PipelineStageFlags,
+	dstStageMask:    PipelineStageFlags,
+	srcAccessMask:   AccessFlags,
+	dstAccessMask:   AccessFlags,
+	dependencyFlags: DependencyFlags,
+}
+
+RenderPassCreateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           RenderPassCreateFlags,
+	attachmentCount: u32,
+	pAttachments:    ^AttachmentDescription,
+	subpassCount:    u32,
+	pSubpasses:      ^SubpassDescription,
+	dependencyCount: u32,
+	pDependencies:   ^SubpassDependency,
+}
+
+CommandPoolCreateInfo :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            CommandPoolCreateFlags,
+	queueFamilyIndex: u32,
+}
+
+CommandBufferAllocateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	commandPool:        CommandPool,
+	level:              CommandBufferLevel,
+	commandBufferCount: u32,
+}
+
+CommandBufferInheritanceInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	renderPass:           RenderPass,
+	subpass:              u32,
+	framebuffer:          Framebuffer,
+	occlusionQueryEnable: b32,
+	queryFlags:           QueryControlFlags,
+	pipelineStatistics:   QueryPipelineStatisticFlags,
+}
+
+CommandBufferBeginInfo :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            CommandBufferUsageFlags,
+	pInheritanceInfo: ^CommandBufferInheritanceInfo,
+}
+
+BufferCopy :: struct {
+	srcOffset: DeviceSize,
+	dstOffset: DeviceSize,
+	size:      DeviceSize,
+}
+
+ImageSubresourceLayers :: struct {
+	aspectMask:     ImageAspectFlags,
+	mipLevel:       u32,
+	baseArrayLayer: u32,
+	layerCount:     u32,
+}
+
+BufferImageCopy :: struct {
+	bufferOffset:      DeviceSize,
+	bufferRowLength:   u32,
+	bufferImageHeight: u32,
+	imageSubresource:  ImageSubresourceLayers,
+	imageOffset:       Offset3D,
+	imageExtent:       Extent3D,
+}
+
+ClearColorValue :: struct #raw_union {
+	float32: [4]f32,
+	int32:   [4]i32,
+	uint32:  [4]u32,
+}
+
+ClearDepthStencilValue :: struct {
+	depth:   f32,
+	stencil: u32,
+}
+
+ClearValue :: struct #raw_union {
+	color:        ClearColorValue,
+	depthStencil: ClearDepthStencilValue,
+}
+
+ClearAttachment :: struct {
+	aspectMask:      ImageAspectFlags,
+	colorAttachment: u32,
+	clearValue:      ClearValue,
+}
+
+ClearRect :: struct {
+	rect:           Rect2D,
+	baseArrayLayer: u32,
+	layerCount:     u32,
+}
+
+ImageBlit :: struct {
+	srcSubresource: ImageSubresourceLayers,
+	srcOffsets:     [2]Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffsets:     [2]Offset3D,
+}
+
+ImageCopy :: struct {
+	srcSubresource: ImageSubresourceLayers,
+	srcOffset:      Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffset:      Offset3D,
+	extent:         Extent3D,
+}
+
+ImageResolve :: struct {
+	srcSubresource: ImageSubresourceLayers,
+	srcOffset:      Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffset:      Offset3D,
+	extent:         Extent3D,
+}
+
+RenderPassBeginInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	renderPass:      RenderPass,
+	framebuffer:     Framebuffer,
+	renderArea:      Rect2D,
+	clearValueCount: u32,
+	pClearValues:    ^ClearValue,
+}
+
+PhysicalDeviceSubgroupProperties :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	subgroupSize:              u32,
+	supportedStages:           ShaderStageFlags,
+	supportedOperations:       SubgroupFeatureFlags,
+	quadOperationsInAllStages: b32,
+}
+
+BindBufferMemoryInfo :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	buffer:       Buffer,
+	memory:       DeviceMemory,
+	memoryOffset: DeviceSize,
+}
+
+BindImageMemoryInfo :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	image:        Image,
+	memory:       DeviceMemory,
+	memoryOffset: DeviceSize,
+}
+
+PhysicalDevice16BitStorageFeatures :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	storageBuffer16BitAccess:           b32,
+	uniformAndStorageBuffer16BitAccess: b32,
+	storagePushConstant16:              b32,
+	storageInputOutput16:               b32,
+}
+
+MemoryDedicatedRequirements :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	prefersDedicatedAllocation:  b32,
+	requiresDedicatedAllocation: b32,
+}
+
+MemoryDedicatedAllocateInfo :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	image:  Image,
+	buffer: Buffer,
+}
+
+MemoryAllocateFlagsInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	flags:      MemoryAllocateFlags,
+	deviceMask: u32,
+}
+
+DeviceGroupRenderPassBeginInfo :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	deviceMask:            u32,
+	deviceRenderAreaCount: u32,
+	pDeviceRenderAreas:    ^Rect2D,
+}
+
+DeviceGroupCommandBufferBeginInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	deviceMask: u32,
+}
+
+DeviceGroupSubmitInfo :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	waitSemaphoreCount:            u32,
+	pWaitSemaphoreDeviceIndices:   ^u32,
+	commandBufferCount:            u32,
+	pCommandBufferDeviceMasks:     ^u32,
+	signalSemaphoreCount:          u32,
+	pSignalSemaphoreDeviceIndices: ^u32,
+}
+
+DeviceGroupBindSparseInfo :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	resourceDeviceIndex: u32,
+	memoryDeviceIndex:   u32,
+}
+
+BindBufferMemoryDeviceGroupInfo :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	deviceIndexCount: u32,
+	pDeviceIndices:   ^u32,
+}
+
+BindImageMemoryDeviceGroupInfo :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	deviceIndexCount:             u32,
+	pDeviceIndices:               ^u32,
+	splitInstanceBindRegionCount: u32,
+	pSplitInstanceBindRegions:    ^Rect2D,
+}
+
+PhysicalDeviceGroupProperties :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	physicalDeviceCount: u32,
+	physicalDevices:     [MAX_DEVICE_GROUP_SIZE]PhysicalDevice,
+	subsetAllocation:    b32,
+}
+
+DeviceGroupDeviceCreateInfo :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	physicalDeviceCount: u32,
+	pPhysicalDevices:    ^PhysicalDevice,
+}
+
+BufferMemoryRequirementsInfo2 :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	buffer: Buffer,
+}
+
+ImageMemoryRequirementsInfo2 :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	image: Image,
+}
+
+ImageSparseMemoryRequirementsInfo2 :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	image: Image,
+}
+
+MemoryRequirements2 :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	memoryRequirements: MemoryRequirements,
+}
+
+SparseImageMemoryRequirements2 :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	memoryRequirements: SparseImageMemoryRequirements,
+}
+
+PhysicalDeviceFeatures2 :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	features: PhysicalDeviceFeatures,
+}
+
+PhysicalDeviceProperties2 :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	properties: PhysicalDeviceProperties,
+}
+
+FormatProperties2 :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	formatProperties: FormatProperties,
+}
+
+ImageFormatProperties2 :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	imageFormatProperties: ImageFormatProperties,
+}
+
+PhysicalDeviceImageFormatInfo2 :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	format: Format,
+	type:   ImageType,
+	tiling: ImageTiling,
+	usage:  ImageUsageFlags,
+	flags:  ImageCreateFlags,
+}
+
+QueueFamilyProperties2 :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	queueFamilyProperties: QueueFamilyProperties,
+}
+
+PhysicalDeviceMemoryProperties2 :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	memoryProperties: PhysicalDeviceMemoryProperties,
+}
+
+SparseImageFormatProperties2 :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	properties: SparseImageFormatProperties,
+}
+
+PhysicalDeviceSparseImageFormatInfo2 :: struct {
+	sType:   StructureType,
+	pNext:   rawptr,
+	format:  Format,
+	type:    ImageType,
+	samples: SampleCountFlags,
+	usage:   ImageUsageFlags,
+	tiling:  ImageTiling,
+}
+
+PhysicalDevicePointClippingProperties :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	pointClippingBehavior: PointClippingBehavior,
+}
+
+InputAttachmentAspectReference :: struct {
+	subpass:              u32,
+	inputAttachmentIndex: u32,
+	aspectMask:           ImageAspectFlags,
+}
+
+RenderPassInputAttachmentAspectCreateInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	aspectReferenceCount: u32,
+	pAspectReferences:    ^InputAttachmentAspectReference,
+}
+
+ImageViewUsageCreateInfo :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	usage: ImageUsageFlags,
+}
+
+PipelineTessellationDomainOriginStateCreateInfo :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	domainOrigin: TessellationDomainOrigin,
+}
+
+RenderPassMultiviewCreateInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	subpassCount:         u32,
+	pViewMasks:           ^u32,
+	dependencyCount:      u32,
+	pViewOffsets:         ^i32,
+	correlationMaskCount: u32,
+	pCorrelationMasks:    ^u32,
+}
+
+PhysicalDeviceMultiviewFeatures :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	multiview:                   b32,
+	multiviewGeometryShader:     b32,
+	multiviewTessellationShader: b32,
+}
+
+PhysicalDeviceMultiviewProperties :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	maxMultiviewViewCount:     u32,
+	maxMultiviewInstanceIndex: u32,
+}
+
+PhysicalDeviceVariablePointersFeatures :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	variablePointersStorageBuffer: b32,
+	variablePointers:              b32,
+}
+
+PhysicalDeviceProtectedMemoryFeatures :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	protectedMemory: b32,
+}
+
+PhysicalDeviceProtectedMemoryProperties :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	protectedNoFault: b32,
+}
+
+DeviceQueueInfo2 :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            DeviceQueueCreateFlags,
+	queueFamilyIndex: u32,
+	queueIndex:       u32,
+}
+
+ProtectedSubmitInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	protectedSubmit: b32,
+}
+
+SamplerYcbcrConversionCreateInfo :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	format:                      Format,
+	ycbcrModel:                  SamplerYcbcrModelConversion,
+	ycbcrRange:                  SamplerYcbcrRange,
+	components:                  ComponentMapping,
+	xChromaOffset:               ChromaLocation,
+	yChromaOffset:               ChromaLocation,
+	chromaFilter:                Filter,
+	forceExplicitReconstruction: b32,
+}
+
+SamplerYcbcrConversionInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	conversion: SamplerYcbcrConversion,
+}
+
+BindImagePlaneMemoryInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	planeAspect: ImageAspectFlags,
+}
+
+ImagePlaneMemoryRequirementsInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	planeAspect: ImageAspectFlags,
+}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	samplerYcbcrConversion: b32,
+}
+
+SamplerYcbcrConversionImageFormatProperties :: struct {
+	sType:                               StructureType,
+	pNext:                               rawptr,
+	combinedImageSamplerDescriptorCount: u32,
+}
+
+DescriptorUpdateTemplateEntry :: struct {
+	dstBinding:      u32,
+	dstArrayElement: u32,
+	descriptorCount: u32,
+	descriptorType:  DescriptorType,
+	offset:          int,
+	stride:          int,
+}
+
+DescriptorUpdateTemplateCreateInfo :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	flags:                      DescriptorUpdateTemplateCreateFlags,
+	descriptorUpdateEntryCount: u32,
+	pDescriptorUpdateEntries:   ^DescriptorUpdateTemplateEntry,
+	templateType:               DescriptorUpdateTemplateType,
+	descriptorSetLayout:        DescriptorSetLayout,
+	pipelineBindPoint:          PipelineBindPoint,
+	pipelineLayout:             PipelineLayout,
+	set:                        u32,
+}
+
+ExternalMemoryProperties :: struct {
+	externalMemoryFeatures:        ExternalMemoryFeatureFlags,
+	exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlags,
+	compatibleHandleTypes:         ExternalMemoryHandleTypeFlags,
+}
+
+PhysicalDeviceExternalImageFormatInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalMemoryHandleTypeFlags,
+}
+
+ExternalImageFormatProperties :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	externalMemoryProperties: ExternalMemoryProperties,
+}
+
+PhysicalDeviceExternalBufferInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	flags:      BufferCreateFlags,
+	usage:      BufferUsageFlags,
+	handleType: ExternalMemoryHandleTypeFlags,
+}
+
+ExternalBufferProperties :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	externalMemoryProperties: ExternalMemoryProperties,
+}
+
+PhysicalDeviceIDProperties :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	deviceUUID:      [UUID_SIZE]u8,
+	driverUUID:      [UUID_SIZE]u8,
+	deviceLUID:      [LUID_SIZE]u8,
+	deviceNodeMask:  u32,
+	deviceLUIDValid: b32,
+}
+
+ExternalMemoryImageCreateInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalMemoryHandleTypeFlags,
+}
+
+ExternalMemoryBufferCreateInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalMemoryHandleTypeFlags,
+}
+
+ExportMemoryAllocateInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalMemoryHandleTypeFlags,
+}
+
+PhysicalDeviceExternalFenceInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalFenceHandleTypeFlags,
+}
+
+ExternalFenceProperties :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	exportFromImportedHandleTypes: ExternalFenceHandleTypeFlags,
+	compatibleHandleTypes:         ExternalFenceHandleTypeFlags,
+	externalFenceFeatures:         ExternalFenceFeatureFlags,
+}
+
+ExportFenceCreateInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalFenceHandleTypeFlags,
+}
+
+ExportSemaphoreCreateInfo :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalSemaphoreHandleTypeFlags,
+}
+
+PhysicalDeviceExternalSemaphoreInfo :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalSemaphoreHandleTypeFlags,
+}
+
+ExternalSemaphoreProperties :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	exportFromImportedHandleTypes: ExternalSemaphoreHandleTypeFlags,
+	compatibleHandleTypes:         ExternalSemaphoreHandleTypeFlags,
+	externalSemaphoreFeatures:     ExternalSemaphoreFeatureFlags,
+}
+
+PhysicalDeviceMaintenance3Properties :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	maxPerSetDescriptors:    u32,
+	maxMemoryAllocationSize: DeviceSize,
+}
+
+DescriptorSetLayoutSupport :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	supported: b32,
+}
+
+PhysicalDeviceShaderDrawParametersFeatures :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	shaderDrawParameters: b32,
+}
+
+PhysicalDeviceVulkan11Features :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	storageBuffer16BitAccess:           b32,
+	uniformAndStorageBuffer16BitAccess: b32,
+	storagePushConstant16:              b32,
+	storageInputOutput16:               b32,
+	multiview:                          b32,
+	multiviewGeometryShader:            b32,
+	multiviewTessellationShader:        b32,
+	variablePointersStorageBuffer:      b32,
+	variablePointers:                   b32,
+	protectedMemory:                    b32,
+	samplerYcbcrConversion:             b32,
+	shaderDrawParameters:               b32,
+}
+
+PhysicalDeviceVulkan11Properties :: struct {
+	sType:                             StructureType,
+	pNext:                             rawptr,
+	deviceUUID:                        [UUID_SIZE]u8,
+	driverUUID:                        [UUID_SIZE]u8,
+	deviceLUID:                        [LUID_SIZE]u8,
+	deviceNodeMask:                    u32,
+	deviceLUIDValid:                   b32,
+	subgroupSize:                      u32,
+	subgroupSupportedStages:           ShaderStageFlags,
+	subgroupSupportedOperations:       SubgroupFeatureFlags,
+	subgroupQuadOperationsInAllStages: b32,
+	pointClippingBehavior:             PointClippingBehavior,
+	maxMultiviewViewCount:             u32,
+	maxMultiviewInstanceIndex:         u32,
+	protectedNoFault:                  b32,
+	maxPerSetDescriptors:              u32,
+	maxMemoryAllocationSize:           DeviceSize,
+}
+
+PhysicalDeviceVulkan12Features :: struct {
+	sType:                                              StructureType,
+	pNext:                                              rawptr,
+	samplerMirrorClampToEdge:                           b32,
+	drawIndirectCount:                                  b32,
+	storageBuffer8BitAccess:                            b32,
+	uniformAndStorageBuffer8BitAccess:                  b32,
+	storagePushConstant8:                               b32,
+	shaderBufferInt64Atomics:                           b32,
+	shaderSharedInt64Atomics:                           b32,
+	shaderFloat16:                                      b32,
+	shaderInt8:                                         b32,
+	descriptorIndexing:                                 b32,
+	shaderInputAttachmentArrayDynamicIndexing:          b32,
+	shaderUniformTexelBufferArrayDynamicIndexing:       b32,
+	shaderStorageTexelBufferArrayDynamicIndexing:       b32,
+	shaderUniformBufferArrayNonUniformIndexing:         b32,
+	shaderSampledImageArrayNonUniformIndexing:          b32,
+	shaderStorageBufferArrayNonUniformIndexing:         b32,
+	shaderStorageImageArrayNonUniformIndexing:          b32,
+	shaderInputAttachmentArrayNonUniformIndexing:       b32,
+	shaderUniformTexelBufferArrayNonUniformIndexing:    b32,
+	shaderStorageTexelBufferArrayNonUniformIndexing:    b32,
+	descriptorBindingUniformBufferUpdateAfterBind:      b32,
+	descriptorBindingSampledImageUpdateAfterBind:       b32,
+	descriptorBindingStorageImageUpdateAfterBind:       b32,
+	descriptorBindingStorageBufferUpdateAfterBind:      b32,
+	descriptorBindingUniformTexelBufferUpdateAfterBind: b32,
+	descriptorBindingStorageTexelBufferUpdateAfterBind: b32,
+	descriptorBindingUpdateUnusedWhilePending:          b32,
+	descriptorBindingPartiallyBound:                    b32,
+	descriptorBindingVariableDescriptorCount:           b32,
+	runtimeDescriptorArray:                             b32,
+	samplerFilterMinmax:                                b32,
+	scalarBlockLayout:                                  b32,
+	imagelessFramebuffer:                               b32,
+	uniformBufferStandardLayout:                        b32,
+	shaderSubgroupExtendedTypes:                        b32,
+	separateDepthStencilLayouts:                        b32,
+	hostQueryReset:                                     b32,
+	timelineSemaphore:                                  b32,
+	bufferDeviceAddress:                                b32,
+	bufferDeviceAddressCaptureReplay:                   b32,
+	bufferDeviceAddressMultiDevice:                     b32,
+	vulkanMemoryModel:                                  b32,
+	vulkanMemoryModelDeviceScope:                       b32,
+	vulkanMemoryModelAvailabilityVisibilityChains:      b32,
+	shaderOutputViewportIndex:                          b32,
+	shaderOutputLayer:                                  b32,
+	subgroupBroadcastDynamicId:                         b32,
+}
+
+ConformanceVersion :: struct {
+	major:    u8,
+	minor:    u8,
+	subminor: u8,
+	patch:    u8,
+}
+
+PhysicalDeviceVulkan12Properties :: struct {
+	sType:                                                StructureType,
+	pNext:                                                rawptr,
+	driverID:                                             DriverId,
+	driverName:                                           [MAX_DRIVER_NAME_SIZE]byte,
+	driverInfo:                                           [MAX_DRIVER_INFO_SIZE]byte,
+	conformanceVersion:                                   ConformanceVersion,
+	denormBehaviorIndependence:                           ShaderFloatControlsIndependence,
+	roundingModeIndependence:                             ShaderFloatControlsIndependence,
+	shaderSignedZeroInfNanPreserveFloat16:                b32,
+	shaderSignedZeroInfNanPreserveFloat32:                b32,
+	shaderSignedZeroInfNanPreserveFloat64:                b32,
+	shaderDenormPreserveFloat16:                          b32,
+	shaderDenormPreserveFloat32:                          b32,
+	shaderDenormPreserveFloat64:                          b32,
+	shaderDenormFlushToZeroFloat16:                       b32,
+	shaderDenormFlushToZeroFloat32:                       b32,
+	shaderDenormFlushToZeroFloat64:                       b32,
+	shaderRoundingModeRTEFloat16:                         b32,
+	shaderRoundingModeRTEFloat32:                         b32,
+	shaderRoundingModeRTEFloat64:                         b32,
+	shaderRoundingModeRTZFloat16:                         b32,
+	shaderRoundingModeRTZFloat32:                         b32,
+	shaderRoundingModeRTZFloat64:                         b32,
+	maxUpdateAfterBindDescriptorsInAllPools:              u32,
+	shaderUniformBufferArrayNonUniformIndexingNative:     b32,
+	shaderSampledImageArrayNonUniformIndexingNative:      b32,
+	shaderStorageBufferArrayNonUniformIndexingNative:     b32,
+	shaderStorageImageArrayNonUniformIndexingNative:      b32,
+	shaderInputAttachmentArrayNonUniformIndexingNative:   b32,
+	robustBufferAccessUpdateAfterBind:                    b32,
+	quadDivergentImplicitLod:                             b32,
+	maxPerStageDescriptorUpdateAfterBindSamplers:         u32,
+	maxPerStageDescriptorUpdateAfterBindUniformBuffers:   u32,
+	maxPerStageDescriptorUpdateAfterBindStorageBuffers:   u32,
+	maxPerStageDescriptorUpdateAfterBindSampledImages:    u32,
+	maxPerStageDescriptorUpdateAfterBindStorageImages:    u32,
+	maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
+	maxPerStageUpdateAfterBindResources:                  u32,
+	maxDescriptorSetUpdateAfterBindSamplers:              u32,
+	maxDescriptorSetUpdateAfterBindUniformBuffers:        u32,
+	maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
+	maxDescriptorSetUpdateAfterBindStorageBuffers:        u32,
+	maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
+	maxDescriptorSetUpdateAfterBindSampledImages:         u32,
+	maxDescriptorSetUpdateAfterBindStorageImages:         u32,
+	maxDescriptorSetUpdateAfterBindInputAttachments:      u32,
+	supportedDepthResolveModes:                           ResolveModeFlags,
+	supportedStencilResolveModes:                         ResolveModeFlags,
+	independentResolveNone:                               b32,
+	independentResolve:                                   b32,
+	filterMinmaxSingleComponentFormats:                   b32,
+	filterMinmaxImageComponentMapping:                    b32,
+	maxTimelineSemaphoreValueDifference:                  u64,
+	framebufferIntegerColorSampleCounts:                  SampleCountFlags,
+}
+
+ImageFormatListCreateInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	viewFormatCount: u32,
+	pViewFormats:    ^Format,
+}
+
+AttachmentDescription2 :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	flags:          AttachmentDescriptionFlags,
+	format:         Format,
+	samples:        SampleCountFlags,
+	loadOp:         AttachmentLoadOp,
+	storeOp:        AttachmentStoreOp,
+	stencilLoadOp:  AttachmentLoadOp,
+	stencilStoreOp: AttachmentStoreOp,
+	initialLayout:  ImageLayout,
+	finalLayout:    ImageLayout,
+}
+
+AttachmentReference2 :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	attachment: u32,
+	layout:     ImageLayout,
+	aspectMask: ImageAspectFlags,
+}
+
+SubpassDescription2 :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   SubpassDescriptionFlags,
+	pipelineBindPoint:       PipelineBindPoint,
+	viewMask:                u32,
+	inputAttachmentCount:    u32,
+	pInputAttachments:       ^AttachmentReference2,
+	colorAttachmentCount:    u32,
+	pColorAttachments:       ^AttachmentReference2,
+	pResolveAttachments:     ^AttachmentReference2,
+	pDepthStencilAttachment: ^AttachmentReference2,
+	preserveAttachmentCount: u32,
+	pPreserveAttachments:    ^u32,
+}
+
+SubpassDependency2 :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	srcSubpass:      u32,
+	dstSubpass:      u32,
+	srcStageMask:    PipelineStageFlags,
+	dstStageMask:    PipelineStageFlags,
+	srcAccessMask:   AccessFlags,
+	dstAccessMask:   AccessFlags,
+	dependencyFlags: DependencyFlags,
+	viewOffset:      i32,
+}
+
+RenderPassCreateInfo2 :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   RenderPassCreateFlags,
+	attachmentCount:         u32,
+	pAttachments:            ^AttachmentDescription2,
+	subpassCount:            u32,
+	pSubpasses:              ^SubpassDescription2,
+	dependencyCount:         u32,
+	pDependencies:           ^SubpassDependency2,
+	correlatedViewMaskCount: u32,
+	pCorrelatedViewMasks:    ^u32,
+}
+
+SubpassBeginInfo :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	contents: SubpassContents,
+}
+
+SubpassEndInfo :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+}
+
+PhysicalDevice8BitStorageFeatures :: struct {
+	sType:                             StructureType,
+	pNext:                             rawptr,
+	storageBuffer8BitAccess:           b32,
+	uniformAndStorageBuffer8BitAccess: b32,
+	storagePushConstant8:              b32,
+}
+
+PhysicalDeviceDriverProperties :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	driverID:           DriverId,
+	driverName:         [MAX_DRIVER_NAME_SIZE]byte,
+	driverInfo:         [MAX_DRIVER_INFO_SIZE]byte,
+	conformanceVersion: ConformanceVersion,
+}
+
+PhysicalDeviceShaderAtomicInt64Features :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	shaderBufferInt64Atomics: b32,
+	shaderSharedInt64Atomics: b32,
+}
+
+PhysicalDeviceShaderFloat16Int8Features :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	shaderFloat16: b32,
+	shaderInt8:    b32,
+}
+
+PhysicalDeviceFloatControlsProperties :: struct {
+	sType:                                 StructureType,
+	pNext:                                 rawptr,
+	denormBehaviorIndependence:            ShaderFloatControlsIndependence,
+	roundingModeIndependence:              ShaderFloatControlsIndependence,
+	shaderSignedZeroInfNanPreserveFloat16: b32,
+	shaderSignedZeroInfNanPreserveFloat32: b32,
+	shaderSignedZeroInfNanPreserveFloat64: b32,
+	shaderDenormPreserveFloat16:           b32,
+	shaderDenormPreserveFloat32:           b32,
+	shaderDenormPreserveFloat64:           b32,
+	shaderDenormFlushToZeroFloat16:        b32,
+	shaderDenormFlushToZeroFloat32:        b32,
+	shaderDenormFlushToZeroFloat64:        b32,
+	shaderRoundingModeRTEFloat16:          b32,
+	shaderRoundingModeRTEFloat32:          b32,
+	shaderRoundingModeRTEFloat64:          b32,
+	shaderRoundingModeRTZFloat16:          b32,
+	shaderRoundingModeRTZFloat32:          b32,
+	shaderRoundingModeRTZFloat64:          b32,
+}
+
+DescriptorSetLayoutBindingFlagsCreateInfo :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	bindingCount:  u32,
+	pBindingFlags: ^DescriptorBindingFlags,
+}
+
+PhysicalDeviceDescriptorIndexingFeatures :: struct {
+	sType:                                              StructureType,
+	pNext:                                              rawptr,
+	shaderInputAttachmentArrayDynamicIndexing:          b32,
+	shaderUniformTexelBufferArrayDynamicIndexing:       b32,
+	shaderStorageTexelBufferArrayDynamicIndexing:       b32,
+	shaderUniformBufferArrayNonUniformIndexing:         b32,
+	shaderSampledImageArrayNonUniformIndexing:          b32,
+	shaderStorageBufferArrayNonUniformIndexing:         b32,
+	shaderStorageImageArrayNonUniformIndexing:          b32,
+	shaderInputAttachmentArrayNonUniformIndexing:       b32,
+	shaderUniformTexelBufferArrayNonUniformIndexing:    b32,
+	shaderStorageTexelBufferArrayNonUniformIndexing:    b32,
+	descriptorBindingUniformBufferUpdateAfterBind:      b32,
+	descriptorBindingSampledImageUpdateAfterBind:       b32,
+	descriptorBindingStorageImageUpdateAfterBind:       b32,
+	descriptorBindingStorageBufferUpdateAfterBind:      b32,
+	descriptorBindingUniformTexelBufferUpdateAfterBind: b32,
+	descriptorBindingStorageTexelBufferUpdateAfterBind: b32,
+	descriptorBindingUpdateUnusedWhilePending:          b32,
+	descriptorBindingPartiallyBound:                    b32,
+	descriptorBindingVariableDescriptorCount:           b32,
+	runtimeDescriptorArray:                             b32,
+}
+
+PhysicalDeviceDescriptorIndexingProperties :: struct {
+	sType:                                                StructureType,
+	pNext:                                                rawptr,
+	maxUpdateAfterBindDescriptorsInAllPools:              u32,
+	shaderUniformBufferArrayNonUniformIndexingNative:     b32,
+	shaderSampledImageArrayNonUniformIndexingNative:      b32,
+	shaderStorageBufferArrayNonUniformIndexingNative:     b32,
+	shaderStorageImageArrayNonUniformIndexingNative:      b32,
+	shaderInputAttachmentArrayNonUniformIndexingNative:   b32,
+	robustBufferAccessUpdateAfterBind:                    b32,
+	quadDivergentImplicitLod:                             b32,
+	maxPerStageDescriptorUpdateAfterBindSamplers:         u32,
+	maxPerStageDescriptorUpdateAfterBindUniformBuffers:   u32,
+	maxPerStageDescriptorUpdateAfterBindStorageBuffers:   u32,
+	maxPerStageDescriptorUpdateAfterBindSampledImages:    u32,
+	maxPerStageDescriptorUpdateAfterBindStorageImages:    u32,
+	maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
+	maxPerStageUpdateAfterBindResources:                  u32,
+	maxDescriptorSetUpdateAfterBindSamplers:              u32,
+	maxDescriptorSetUpdateAfterBindUniformBuffers:        u32,
+	maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
+	maxDescriptorSetUpdateAfterBindStorageBuffers:        u32,
+	maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
+	maxDescriptorSetUpdateAfterBindSampledImages:         u32,
+	maxDescriptorSetUpdateAfterBindStorageImages:         u32,
+	maxDescriptorSetUpdateAfterBindInputAttachments:      u32,
+}
+
+DescriptorSetVariableDescriptorCountAllocateInfo :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	descriptorSetCount: u32,
+	pDescriptorCounts:  ^u32,
+}
+
+DescriptorSetVariableDescriptorCountLayoutSupport :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	maxVariableDescriptorCount: u32,
+}
+
+SubpassDescriptionDepthStencilResolve :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	depthResolveMode:               ResolveModeFlags,
+	stencilResolveMode:             ResolveModeFlags,
+	pDepthStencilResolveAttachment: ^AttachmentReference2,
+}
+
+PhysicalDeviceDepthStencilResolveProperties :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	supportedDepthResolveModes:   ResolveModeFlags,
+	supportedStencilResolveModes: ResolveModeFlags,
+	independentResolveNone:       b32,
+	independentResolve:           b32,
+}
+
+PhysicalDeviceScalarBlockLayoutFeatures :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	scalarBlockLayout: b32,
+}
+
+ImageStencilUsageCreateInfo :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	stencilUsage: ImageUsageFlags,
+}
+
+SamplerReductionModeCreateInfo :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	reductionMode: SamplerReductionMode,
+}
+
+PhysicalDeviceSamplerFilterMinmaxProperties :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	filterMinmaxSingleComponentFormats: b32,
+	filterMinmaxImageComponentMapping:  b32,
+}
+
+PhysicalDeviceVulkanMemoryModelFeatures :: struct {
+	sType:                                         StructureType,
+	pNext:                                         rawptr,
+	vulkanMemoryModel:                             b32,
+	vulkanMemoryModelDeviceScope:                  b32,
+	vulkanMemoryModelAvailabilityVisibilityChains: b32,
+}
+
+PhysicalDeviceImagelessFramebufferFeatures :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	imagelessFramebuffer: b32,
+}
+
+FramebufferAttachmentImageInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           ImageCreateFlags,
+	usage:           ImageUsageFlags,
+	width:           u32,
+	height:          u32,
+	layerCount:      u32,
+	viewFormatCount: u32,
+	pViewFormats:    ^Format,
+}
+
+FramebufferAttachmentsCreateInfo :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	attachmentImageInfoCount: u32,
+	pAttachmentImageInfos:    ^FramebufferAttachmentImageInfo,
+}
+
+RenderPassAttachmentBeginInfo :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	attachmentCount: u32,
+	pAttachments:    ^ImageView,
+}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	uniformBufferStandardLayout: b32,
+}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	shaderSubgroupExtendedTypes: b32,
+}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	separateDepthStencilLayouts: b32,
+}
+
+AttachmentReferenceStencilLayout :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	stencilLayout: ImageLayout,
+}
+
+AttachmentDescriptionStencilLayout :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	stencilInitialLayout: ImageLayout,
+	stencilFinalLayout:   ImageLayout,
+}
+
+PhysicalDeviceHostQueryResetFeatures :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	hostQueryReset: b32,
+}
+
+PhysicalDeviceTimelineSemaphoreFeatures :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	timelineSemaphore: b32,
+}
+
+PhysicalDeviceTimelineSemaphoreProperties :: struct {
+	sType:                               StructureType,
+	pNext:                               rawptr,
+	maxTimelineSemaphoreValueDifference: u64,
+}
+
+SemaphoreTypeCreateInfo :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	semaphoreType: SemaphoreType,
+	initialValue:  u64,
+}
+
+TimelineSemaphoreSubmitInfo :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	waitSemaphoreValueCount:   u32,
+	pWaitSemaphoreValues:      ^u64,
+	signalSemaphoreValueCount: u32,
+	pSignalSemaphoreValues:    ^u64,
+}
+
+SemaphoreWaitInfo :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	flags:          SemaphoreWaitFlags,
+	semaphoreCount: u32,
+	pSemaphores:    ^Semaphore,
+	pValues:        ^u64,
+}
+
+SemaphoreSignalInfo :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	semaphore: Semaphore,
+	value:     u64,
+}
+
+PhysicalDeviceBufferDeviceAddressFeatures :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	bufferDeviceAddress:              b32,
+	bufferDeviceAddressCaptureReplay: b32,
+	bufferDeviceAddressMultiDevice:   b32,
+}
+
+BufferDeviceAddressInfo :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	buffer: Buffer,
+}
+
+BufferOpaqueCaptureAddressCreateInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	opaqueCaptureAddress: u64,
+}
+
+MemoryOpaqueCaptureAddressAllocateInfo :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	opaqueCaptureAddress: u64,
+}
+
+DeviceMemoryOpaqueCaptureAddressInfo :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	memory: DeviceMemory,
+}
+
+SurfaceCapabilitiesKHR :: struct {
+	minImageCount:           u32,
+	maxImageCount:           u32,
+	currentExtent:           Extent2D,
+	minImageExtent:          Extent2D,
+	maxImageExtent:          Extent2D,
+	maxImageArrayLayers:     u32,
+	supportedTransforms:     SurfaceTransformFlagsKHR,
+	currentTransform:        SurfaceTransformFlagsKHR,
+	supportedCompositeAlpha: CompositeAlphaFlagsKHR,
+	supportedUsageFlags:     ImageUsageFlags,
+}
+
+SurfaceFormatKHR :: struct {
+	format:     Format,
+	colorSpace: ColorSpaceKHR,
+}
+
+SwapchainCreateInfoKHR :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 SwapchainCreateFlagsKHR,
+	surface:               SurfaceKHR,
+	minImageCount:         u32,
+	imageFormat:           Format,
+	imageColorSpace:       ColorSpaceKHR,
+	imageExtent:           Extent2D,
+	imageArrayLayers:      u32,
+	imageUsage:            ImageUsageFlags,
+	imageSharingMode:      SharingMode,
+	queueFamilyIndexCount: u32,
+	pQueueFamilyIndices:   ^u32,
+	preTransform:          SurfaceTransformFlagsKHR,
+	compositeAlpha:        CompositeAlphaFlagsKHR,
+	presentMode:           PresentModeKHR,
+	clipped:               b32,
+	oldSwapchain:          SwapchainKHR,
+}
+
+PresentInfoKHR :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	waitSemaphoreCount: u32,
+	pWaitSemaphores:    ^Semaphore,
+	swapchainCount:     u32,
+	pSwapchains:        ^SwapchainKHR,
+	pImageIndices:      ^u32,
+	pResults:           ^Result,
+}
+
+ImageSwapchainCreateInfoKHR :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	swapchain: SwapchainKHR,
+}
+
+BindImageMemorySwapchainInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	swapchain:  SwapchainKHR,
+	imageIndex: u32,
+}
+
+AcquireNextImageInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	swapchain:  SwapchainKHR,
+	timeout:    u64,
+	semaphore:  Semaphore,
+	fence:      Fence,
+	deviceMask: u32,
+}
+
+DeviceGroupPresentCapabilitiesKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	presentMask: [MAX_DEVICE_GROUP_SIZE]u32,
+	modes:       DeviceGroupPresentModeFlagsKHR,
+}
+
+DeviceGroupPresentInfoKHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	swapchainCount: u32,
+	pDeviceMasks:   ^u32,
+	mode:           DeviceGroupPresentModeFlagsKHR,
+}
+
+DeviceGroupSwapchainCreateInfoKHR :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	modes: DeviceGroupPresentModeFlagsKHR,
+}
+
+DisplayModeParametersKHR :: struct {
+	visibleRegion: Extent2D,
+	refreshRate:   u32,
+}
+
+DisplayModeCreateInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	flags:      DisplayModeCreateFlagsKHR,
+	parameters: DisplayModeParametersKHR,
+}
+
+DisplayModePropertiesKHR :: struct {
+	displayMode: DisplayModeKHR,
+	parameters:  DisplayModeParametersKHR,
+}
+
+DisplayPlaneCapabilitiesKHR :: struct {
+	supportedAlpha: DisplayPlaneAlphaFlagsKHR,
+	minSrcPosition: Offset2D,
+	maxSrcPosition: Offset2D,
+	minSrcExtent:   Extent2D,
+	maxSrcExtent:   Extent2D,
+	minDstPosition: Offset2D,
+	maxDstPosition: Offset2D,
+	minDstExtent:   Extent2D,
+	maxDstExtent:   Extent2D,
+}
+
+DisplayPlanePropertiesKHR :: struct {
+	currentDisplay:    DisplayKHR,
+	currentStackIndex: u32,
+}
+
+DisplayPropertiesKHR :: struct {
+	display:              DisplayKHR,
+	displayName:          cstring,
+	physicalDimensions:   Extent2D,
+	physicalResolution:   Extent2D,
+	supportedTransforms:  SurfaceTransformFlagsKHR,
+	planeReorderPossible: b32,
+	persistentContent:    b32,
+}
+
+DisplaySurfaceCreateInfoKHR :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           DisplaySurfaceCreateFlagsKHR,
+	displayMode:     DisplayModeKHR,
+	planeIndex:      u32,
+	planeStackIndex: u32,
+	transform:       SurfaceTransformFlagsKHR,
+	globalAlpha:     f32,
+	alphaMode:       DisplayPlaneAlphaFlagsKHR,
+	imageExtent:     Extent2D,
+}
+
+DisplayPresentInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	srcRect:    Rect2D,
+	dstRect:    Rect2D,
+	persistent: b32,
+}
+
+ImportMemoryFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalMemoryHandleTypeFlags,
+	fd:         c.int,
+}
+
+MemoryFdPropertiesKHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	memoryTypeBits: u32,
+}
+
+MemoryGetFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	memory:     DeviceMemory,
+	handleType: ExternalMemoryHandleTypeFlags,
+}
+
+ImportSemaphoreFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	semaphore:  Semaphore,
+	flags:      SemaphoreImportFlags,
+	handleType: ExternalSemaphoreHandleTypeFlags,
+	fd:         c.int,
+}
+
+SemaphoreGetFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	semaphore:  Semaphore,
+	handleType: ExternalSemaphoreHandleTypeFlags,
+}
+
+PhysicalDevicePushDescriptorPropertiesKHR :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	maxPushDescriptors: u32,
+}
+
+RectLayerKHR :: struct {
+	offset: Offset2D,
+	extent: Extent2D,
+	layer:  u32,
+}
+
+PresentRegionKHR :: struct {
+	rectangleCount: u32,
+	pRectangles:    ^RectLayerKHR,
+}
+
+PresentRegionsKHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	swapchainCount: u32,
+	pRegions:       ^PresentRegionKHR,
+}
+
+SharedPresentSurfaceCapabilitiesKHR :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	sharedPresentSupportedUsageFlags: ImageUsageFlags,
+}
+
+ImportFenceFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	fence:      Fence,
+	flags:      FenceImportFlags,
+	handleType: ExternalFenceHandleTypeFlags,
+	fd:         c.int,
+}
+
+FenceGetFdInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	fence:      Fence,
+	handleType: ExternalFenceHandleTypeFlags,
+}
+
+PhysicalDevicePerformanceQueryFeaturesKHR :: struct {
+	sType:                                StructureType,
+	pNext:                                rawptr,
+	performanceCounterQueryPools:         b32,
+	performanceCounterMultipleQueryPools: b32,
+}
+
+PhysicalDevicePerformanceQueryPropertiesKHR :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	allowCommandBufferQueryCopies: b32,
+}
+
+PerformanceCounterKHR :: struct {
+	sType:   StructureType,
+	pNext:   rawptr,
+	unit:    PerformanceCounterUnitKHR,
+	scope:   PerformanceCounterScopeKHR,
+	storage: PerformanceCounterStorageKHR,
+	uuid:    [UUID_SIZE]u8,
+}
+
+PerformanceCounterDescriptionKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	flags:       PerformanceCounterDescriptionFlagsKHR,
+	name:        [MAX_DESCRIPTION_SIZE]byte,
+	category:    [MAX_DESCRIPTION_SIZE]byte,
+	description: [MAX_DESCRIPTION_SIZE]byte,
+}
+
+QueryPoolPerformanceCreateInfoKHR :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	queueFamilyIndex:  u32,
+	counterIndexCount: u32,
+	pCounterIndices:   ^u32,
+}
+
+PerformanceCounterResultKHR :: struct #raw_union {
+	int32:   i32,
+	int64:   i64,
+	uint32:  u32,
+	uint64:  u64,
+	float32: f32,
+	float64: f64,
+}
+
+AcquireProfilingLockInfoKHR :: struct {
+	sType:   StructureType,
+	pNext:   rawptr,
+	flags:   AcquireProfilingLockFlagsKHR,
+	timeout: u64,
+}
+
+PerformanceQuerySubmitInfoKHR :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	counterPassIndex: u32,
+}
+
+PhysicalDeviceSurfaceInfo2KHR :: struct {
+	sType:   StructureType,
+	pNext:   rawptr,
+	surface: SurfaceKHR,
+}
+
+SurfaceCapabilities2KHR :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	surfaceCapabilities: SurfaceCapabilitiesKHR,
+}
+
+SurfaceFormat2KHR :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	surfaceFormat: SurfaceFormatKHR,
+}
+
+DisplayProperties2KHR :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	displayProperties: DisplayPropertiesKHR,
+}
+
+DisplayPlaneProperties2KHR :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	displayPlaneProperties: DisplayPlanePropertiesKHR,
+}
+
+DisplayModeProperties2KHR :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	displayModeProperties: DisplayModePropertiesKHR,
+}
+
+DisplayPlaneInfo2KHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	mode:       DisplayModeKHR,
+	planeIndex: u32,
+}
+
+DisplayPlaneCapabilities2KHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	capabilities: DisplayPlaneCapabilitiesKHR,
+}
+
+PhysicalDeviceShaderClockFeaturesKHR :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	shaderSubgroupClock: b32,
+	shaderDeviceClock:   b32,
+}
+
+PhysicalDeviceShaderTerminateInvocationFeaturesKHR :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	shaderTerminateInvocation: b32,
+}
+
+FragmentShadingRateAttachmentInfoKHR :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	pFragmentShadingRateAttachment: ^AttachmentReference2,
+	shadingRateAttachmentTexelSize: Extent2D,
+}
+
+PipelineFragmentShadingRateStateCreateInfoKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	fragmentSize: Extent2D,
+	combinerOps:  [2]FragmentShadingRateCombinerOpKHR,
+}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	pipelineFragmentShadingRate:   b32,
+	primitiveFragmentShadingRate:  b32,
+	attachmentFragmentShadingRate: b32,
+}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR :: struct {
+	sType:                                                StructureType,
+	pNext:                                                rawptr,
+	minFragmentShadingRateAttachmentTexelSize:            Extent2D,
+	maxFragmentShadingRateAttachmentTexelSize:            Extent2D,
+	maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
+	primitiveFragmentShadingRateWithMultipleViewports:    b32,
+	layeredShadingRateAttachments:                        b32,
+	fragmentShadingRateNonTrivialCombinerOps:             b32,
+	maxFragmentSize:                                      Extent2D,
+	maxFragmentSizeAspectRatio:                           u32,
+	maxFragmentShadingRateCoverageSamples:                u32,
+	maxFragmentShadingRateRasterizationSamples:           SampleCountFlags,
+	fragmentShadingRateWithShaderDepthStencilWrites:      b32,
+	fragmentShadingRateWithSampleMask:                    b32,
+	fragmentShadingRateWithShaderSampleMask:              b32,
+	fragmentShadingRateWithConservativeRasterization:     b32,
+	fragmentShadingRateWithFragmentShaderInterlock:       b32,
+	fragmentShadingRateWithCustomSampleLocations:         b32,
+	fragmentShadingRateStrictMultiplyCombiner:            b32,
+}
+
+PhysicalDeviceFragmentShadingRateKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	sampleCounts: SampleCountFlags,
+	fragmentSize: Extent2D,
+}
+
+SurfaceProtectedCapabilitiesKHR :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	supportsProtected: b32,
+}
+
+PhysicalDevicePresentWaitFeaturesKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	presentWait: b32,
+}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	pipelineExecutableInfo: b32,
+}
+
+PipelineInfoKHR :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	pipeline: Pipeline,
+}
+
+PipelineExecutablePropertiesKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	stages:       ShaderStageFlags,
+	name:         [MAX_DESCRIPTION_SIZE]byte,
+	description:  [MAX_DESCRIPTION_SIZE]byte,
+	subgroupSize: u32,
+}
+
+PipelineExecutableInfoKHR :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	pipeline:        Pipeline,
+	executableIndex: u32,
+}
+
+PipelineExecutableStatisticValueKHR :: struct #raw_union {
+	b32: b32,
+	i64: i64,
+	u64: u64,
+	f64: f64,
+}
+
+PipelineExecutableStatisticKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	name:        [MAX_DESCRIPTION_SIZE]byte,
+	description: [MAX_DESCRIPTION_SIZE]byte,
+	format:      PipelineExecutableStatisticFormatKHR,
+	value:       PipelineExecutableStatisticValueKHR,
+}
+
+PipelineExecutableInternalRepresentationKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	name:        [MAX_DESCRIPTION_SIZE]byte,
+	description: [MAX_DESCRIPTION_SIZE]byte,
+	isText:      b32,
+	dataSize:    int,
+	pData:       rawptr,
+}
+
+PipelineLibraryCreateInfoKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	libraryCount: u32,
+	pLibraries:   ^Pipeline,
+}
+
+PresentIdKHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	swapchainCount: u32,
+	pPresentIds:    ^u64,
+}
+
+PhysicalDevicePresentIdFeaturesKHR :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	presentId: b32,
+}
+
+MemoryBarrier2KHR :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	srcStageMask:  PipelineStageFlags2KHR,
+	srcAccessMask: AccessFlags2KHR,
+	dstStageMask:  PipelineStageFlags2KHR,
+	dstAccessMask: AccessFlags2KHR,
+}
+
+BufferMemoryBarrier2KHR :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	srcStageMask:        PipelineStageFlags2KHR,
+	srcAccessMask:       AccessFlags2KHR,
+	dstStageMask:        PipelineStageFlags2KHR,
+	dstAccessMask:       AccessFlags2KHR,
+	srcQueueFamilyIndex: u32,
+	dstQueueFamilyIndex: u32,
+	buffer:              Buffer,
+	offset:              DeviceSize,
+	size:                DeviceSize,
+}
+
+ImageMemoryBarrier2KHR :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	srcStageMask:        PipelineStageFlags2KHR,
+	srcAccessMask:       AccessFlags2KHR,
+	dstStageMask:        PipelineStageFlags2KHR,
+	dstAccessMask:       AccessFlags2KHR,
+	oldLayout:           ImageLayout,
+	newLayout:           ImageLayout,
+	srcQueueFamilyIndex: u32,
+	dstQueueFamilyIndex: u32,
+	image:               Image,
+	subresourceRange:    ImageSubresourceRange,
+}
+
+DependencyInfoKHR :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	dependencyFlags:          DependencyFlags,
+	memoryBarrierCount:       u32,
+	pMemoryBarriers:          ^MemoryBarrier2KHR,
+	bufferMemoryBarrierCount: u32,
+	pBufferMemoryBarriers:    ^BufferMemoryBarrier2KHR,
+	imageMemoryBarrierCount:  u32,
+	pImageMemoryBarriers:     ^ImageMemoryBarrier2KHR,
+}
+
+SemaphoreSubmitInfoKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	semaphore:   Semaphore,
+	value:       u64,
+	stageMask:   PipelineStageFlags2KHR,
+	deviceIndex: u32,
+}
+
+CommandBufferSubmitInfoKHR :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	commandBuffer: CommandBuffer,
+	deviceMask:    u32,
+}
+
+SubmitInfo2KHR :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	flags:                    SubmitFlagsKHR,
+	waitSemaphoreInfoCount:   u32,
+	pWaitSemaphoreInfos:      ^SemaphoreSubmitInfoKHR,
+	commandBufferInfoCount:   u32,
+	pCommandBufferInfos:      ^CommandBufferSubmitInfoKHR,
+	signalSemaphoreInfoCount: u32,
+	pSignalSemaphoreInfos:    ^SemaphoreSubmitInfoKHR,
+}
+
+PhysicalDeviceSynchronization2FeaturesKHR :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	synchronization2: b32,
+}
+
+QueueFamilyCheckpointProperties2NV :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	checkpointExecutionStageMask: PipelineStageFlags2KHR,
+}
+
+CheckpointData2NV :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	stage:             PipelineStageFlags2KHR,
+	pCheckpointMarker: rawptr,
+}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	shaderSubgroupUniformControlFlow: b32,
+}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR :: struct {
+	sType:                               StructureType,
+	pNext:                               rawptr,
+	shaderZeroInitializeWorkgroupMemory: b32,
+}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR :: struct {
+	sType:                                          StructureType,
+	pNext:                                          rawptr,
+	workgroupMemoryExplicitLayout:                  b32,
+	workgroupMemoryExplicitLayoutScalarBlockLayout: b32,
+	workgroupMemoryExplicitLayout8BitAccess:        b32,
+	workgroupMemoryExplicitLayout16BitAccess:       b32,
+}
+
+BufferCopy2KHR :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	srcOffset: DeviceSize,
+	dstOffset: DeviceSize,
+	size:      DeviceSize,
+}
+
+CopyBufferInfo2KHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	srcBuffer:   Buffer,
+	dstBuffer:   Buffer,
+	regionCount: u32,
+	pRegions:    ^BufferCopy2KHR,
+}
+
+ImageCopy2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcSubresource: ImageSubresourceLayers,
+	srcOffset:      Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffset:      Offset3D,
+	extent:         Extent3D,
+}
+
+CopyImageInfo2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcImage:       Image,
+	srcImageLayout: ImageLayout,
+	dstImage:       Image,
+	dstImageLayout: ImageLayout,
+	regionCount:    u32,
+	pRegions:       ^ImageCopy2KHR,
+}
+
+BufferImageCopy2KHR :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	bufferOffset:      DeviceSize,
+	bufferRowLength:   u32,
+	bufferImageHeight: u32,
+	imageSubresource:  ImageSubresourceLayers,
+	imageOffset:       Offset3D,
+	imageExtent:       Extent3D,
+}
+
+CopyBufferToImageInfo2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcBuffer:      Buffer,
+	dstImage:       Image,
+	dstImageLayout: ImageLayout,
+	regionCount:    u32,
+	pRegions:       ^BufferImageCopy2KHR,
+}
+
+CopyImageToBufferInfo2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcImage:       Image,
+	srcImageLayout: ImageLayout,
+	dstBuffer:      Buffer,
+	regionCount:    u32,
+	pRegions:       ^BufferImageCopy2KHR,
+}
+
+ImageBlit2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcSubresource: ImageSubresourceLayers,
+	srcOffsets:     [2]Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffsets:     [2]Offset3D,
+}
+
+BlitImageInfo2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcImage:       Image,
+	srcImageLayout: ImageLayout,
+	dstImage:       Image,
+	dstImageLayout: ImageLayout,
+	regionCount:    u32,
+	pRegions:       ^ImageBlit2KHR,
+	filter:         Filter,
+}
+
+ImageResolve2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcSubresource: ImageSubresourceLayers,
+	srcOffset:      Offset3D,
+	dstSubresource: ImageSubresourceLayers,
+	dstOffset:      Offset3D,
+	extent:         Extent3D,
+}
+
+ResolveImageInfo2KHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	srcImage:       Image,
+	srcImageLayout: ImageLayout,
+	dstImage:       Image,
+	dstImageLayout: ImageLayout,
+	regionCount:    u32,
+	pRegions:       ^ImageResolve2KHR,
+}
+
+DebugReportCallbackCreateInfoEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	flags:       DebugReportFlagsEXT,
+	pfnCallback: ProcDebugReportCallbackEXT,
+	pUserData:   rawptr,
+}
+
+PipelineRasterizationStateRasterizationOrderAMD :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	rasterizationOrder: RasterizationOrderAMD,
+}
+
+DebugMarkerObjectNameInfoEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	objectType:  DebugReportObjectTypeEXT,
+	object:      u64,
+	pObjectName: cstring,
+}
+
+DebugMarkerObjectTagInfoEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	objectType: DebugReportObjectTypeEXT,
+	object:     u64,
+	tagName:    u64,
+	tagSize:    int,
+	pTag:       rawptr,
+}
+
+DebugMarkerMarkerInfoEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pMarkerName: cstring,
+	color:       [4]f32,
+}
+
+DedicatedAllocationImageCreateInfoNV :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	dedicatedAllocation: b32,
+}
+
+DedicatedAllocationBufferCreateInfoNV :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	dedicatedAllocation: b32,
+}
+
+DedicatedAllocationMemoryAllocateInfoNV :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	image:  Image,
+	buffer: Buffer,
+}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	transformFeedback: b32,
+	geometryStreams:   b32,
+}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT :: struct {
+	sType:                                      StructureType,
+	pNext:                                      rawptr,
+	maxTransformFeedbackStreams:                u32,
+	maxTransformFeedbackBuffers:                u32,
+	maxTransformFeedbackBufferSize:             DeviceSize,
+	maxTransformFeedbackStreamDataSize:         u32,
+	maxTransformFeedbackBufferDataSize:         u32,
+	maxTransformFeedbackBufferDataStride:       u32,
+	transformFeedbackQueries:                   b32,
+	transformFeedbackStreamsLinesTriangles:     b32,
+	transformFeedbackRasterizationStreamSelect: b32,
+	transformFeedbackDraw:                      b32,
+}
+
+PipelineRasterizationStateStreamCreateInfoEXT :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	flags:               PipelineRasterizationStateStreamCreateFlagsEXT,
+	rasterizationStream: u32,
+}
+
+CuModuleCreateInfoNVX :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	dataSize: int,
+	pData:    rawptr,
+}
+
+CuFunctionCreateInfoNVX :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	module: CuModuleNVX,
+	pName:  cstring,
+}
+
+CuLaunchInfoNVX :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	function:       CuFunctionNVX,
+	gridDimX:       u32,
+	gridDimY:       u32,
+	gridDimZ:       u32,
+	blockDimX:      u32,
+	blockDimY:      u32,
+	blockDimZ:      u32,
+	sharedMemBytes: u32,
+	paramCount:     int,
+	pParams:        ^rawptr,
+	extraCount:     int,
+	pExtras:        ^rawptr,
+}
+
+ImageViewHandleInfoNVX :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	imageView:      ImageView,
+	descriptorType: DescriptorType,
+	sampler:        Sampler,
+}
+
+ImageViewAddressPropertiesNVX :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	deviceAddress: DeviceAddress,
+	size:          DeviceSize,
+}
+
+TextureLODGatherFormatPropertiesAMD :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	supportsTextureGatherLODBiasAMD: b32,
+}
+
+ShaderResourceUsageAMD :: struct {
+	numUsedVgprs:             u32,
+	numUsedSgprs:             u32,
+	ldsSizePerLocalWorkGroup: u32,
+	ldsUsageSizeInBytes:      int,
+	scratchMemUsageInBytes:   int,
+}
+
+ShaderStatisticsInfoAMD :: struct {
+	shaderStageMask:      ShaderStageFlags,
+	resourceUsage:        ShaderResourceUsageAMD,
+	numPhysicalVgprs:     u32,
+	numPhysicalSgprs:     u32,
+	numAvailableVgprs:    u32,
+	numAvailableSgprs:    u32,
+	computeWorkGroupSize: [3]u32,
+}
+
+PhysicalDeviceCornerSampledImageFeaturesNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	cornerSampledImage: b32,
+}
+
+ExternalImageFormatPropertiesNV :: struct {
+	imageFormatProperties:         ImageFormatProperties,
+	externalMemoryFeatures:        ExternalMemoryFeatureFlagsNV,
+	exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlagsNV,
+	compatibleHandleTypes:         ExternalMemoryHandleTypeFlagsNV,
+}
+
+ExternalMemoryImageCreateInfoNV :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalMemoryHandleTypeFlagsNV,
+}
+
+ExportMemoryAllocateInfoNV :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	handleTypes: ExternalMemoryHandleTypeFlagsNV,
+}
+
+ValidationFlagsEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	disabledValidationCheckCount: u32,
+	pDisabledValidationChecks:    ^ValidationCheckEXT,
+}
+
+PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	textureCompressionASTC_HDR: b32,
+}
+
+ImageViewASTCDecodeModeEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	decodeMode: Format,
+}
+
+PhysicalDeviceASTCDecodeFeaturesEXT :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	decodeModeSharedExponent: b32,
+}
+
+ConditionalRenderingBeginInfoEXT :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	buffer: Buffer,
+	offset: DeviceSize,
+	flags:  ConditionalRenderingFlagsEXT,
+}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	conditionalRendering:          b32,
+	inheritedConditionalRendering: b32,
+}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	conditionalRenderingEnable: b32,
+}
+
+ViewportWScalingNV :: struct {
+	xcoeff: f32,
+	ycoeff: f32,
+}
+
+PipelineViewportWScalingStateCreateInfoNV :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	viewportWScalingEnable: b32,
+	viewportCount:          u32,
+	pViewportWScalings:     ^ViewportWScalingNV,
+}
+
+SurfaceCapabilities2EXT :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	minImageCount:            u32,
+	maxImageCount:            u32,
+	currentExtent:            Extent2D,
+	minImageExtent:           Extent2D,
+	maxImageExtent:           Extent2D,
+	maxImageArrayLayers:      u32,
+	supportedTransforms:      SurfaceTransformFlagsKHR,
+	currentTransform:         SurfaceTransformFlagsKHR,
+	supportedCompositeAlpha:  CompositeAlphaFlagsKHR,
+	supportedUsageFlags:      ImageUsageFlags,
+	supportedSurfaceCounters: SurfaceCounterFlagsEXT,
+}
+
+DisplayPowerInfoEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	powerState: DisplayPowerStateEXT,
+}
+
+DeviceEventInfoEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	deviceEvent: DeviceEventTypeEXT,
+}
+
+DisplayEventInfoEXT :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	displayEvent: DisplayEventTypeEXT,
+}
+
+SwapchainCounterCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	surfaceCounters: SurfaceCounterFlagsEXT,
+}
+
+RefreshCycleDurationGOOGLE :: struct {
+	refreshDuration: u64,
+}
+
+PastPresentationTimingGOOGLE :: struct {
+	presentID:           u32,
+	desiredPresentTime:  u64,
+	actualPresentTime:   u64,
+	earliestPresentTime: u64,
+	presentMargin:       u64,
+}
+
+PresentTimeGOOGLE :: struct {
+	presentID:          u32,
+	desiredPresentTime: u64,
+}
+
+PresentTimesInfoGOOGLE :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	swapchainCount: u32,
+	pTimes:         ^PresentTimeGOOGLE,
+}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	perViewPositionAllComponents: b32,
+}
+
+ViewportSwizzleNV :: struct {
+	x: ViewportCoordinateSwizzleNV,
+	y: ViewportCoordinateSwizzleNV,
+	z: ViewportCoordinateSwizzleNV,
+	w: ViewportCoordinateSwizzleNV,
+}
+
+PipelineViewportSwizzleStateCreateInfoNV :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	flags:             PipelineViewportSwizzleStateCreateFlagsNV,
+	viewportCount:     u32,
+	pViewportSwizzles: ^ViewportSwizzleNV,
+}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	maxDiscardRectangles: u32,
+}
+
+PipelineDiscardRectangleStateCreateInfoEXT :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 PipelineDiscardRectangleStateCreateFlagsEXT,
+	discardRectangleMode:  DiscardRectangleModeEXT,
+	discardRectangleCount: u32,
+	pDiscardRectangles:    ^Rect2D,
+}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT :: struct {
+	sType:                                       StructureType,
+	pNext:                                       rawptr,
+	primitiveOverestimationSize:                 f32,
+	maxExtraPrimitiveOverestimationSize:         f32,
+	extraPrimitiveOverestimationSizeGranularity: f32,
+	primitiveUnderestimation:                    b32,
+	conservativePointAndLineRasterization:       b32,
+	degenerateTrianglesRasterized:               b32,
+	degenerateLinesRasterized:                   b32,
+	fullyCoveredFragmentShaderInputVariable:     b32,
+	conservativeRasterizationPostDepthCoverage:  b32,
+}
+
+PipelineRasterizationConservativeStateCreateInfoEXT :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	flags:                            PipelineRasterizationConservativeStateCreateFlagsEXT,
+	conservativeRasterizationMode:    ConservativeRasterizationModeEXT,
+	extraPrimitiveOverestimationSize: f32,
+}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	depthClipEnable: b32,
+}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           PipelineRasterizationDepthClipStateCreateFlagsEXT,
+	depthClipEnable: b32,
+}
+
+XYColorEXT :: struct {
+	x: f32,
+	y: f32,
+}
+
+HdrMetadataEXT :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	displayPrimaryRed:         XYColorEXT,
+	displayPrimaryGreen:       XYColorEXT,
+	displayPrimaryBlue:        XYColorEXT,
+	whitePoint:                XYColorEXT,
+	maxLuminance:              f32,
+	minLuminance:              f32,
+	maxContentLightLevel:      f32,
+	maxFrameAverageLightLevel: f32,
+}
+
+DebugUtilsLabelEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	pLabelName: cstring,
+	color:      [4]f32,
+}
+
+DebugUtilsObjectNameInfoEXT :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	objectType:   ObjectType,
+	objectHandle: u64,
+	pObjectName:  cstring,
+}
+
+DebugUtilsMessengerCallbackDataEXT :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	flags:            DebugUtilsMessengerCallbackDataFlagsEXT,
+	pMessageIdName:   cstring,
+	messageIdNumber:  i32,
+	pMessage:         cstring,
+	queueLabelCount:  u32,
+	pQueueLabels:     ^DebugUtilsLabelEXT,
+	cmdBufLabelCount: u32,
+	pCmdBufLabels:    ^DebugUtilsLabelEXT,
+	objectCount:      u32,
+	pObjects:         ^DebugUtilsObjectNameInfoEXT,
+}
+
+DebugUtilsMessengerCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           DebugUtilsMessengerCreateFlagsEXT,
+	messageSeverity: DebugUtilsMessageSeverityFlagsEXT,
+	messageType:     DebugUtilsMessageTypeFlagsEXT,
+	pfnUserCallback: ProcDebugUtilsMessengerCallbackEXT,
+	pUserData:       rawptr,
+}
+
+DebugUtilsObjectTagInfoEXT :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	objectType:   ObjectType,
+	objectHandle: u64,
+	tagName:      u64,
+	tagSize:      int,
+	pTag:         rawptr,
+}
+
+PhysicalDeviceInlineUniformBlockFeaturesEXT :: struct {
+	sType:                                              StructureType,
+	pNext:                                              rawptr,
+	inlineUniformBlock:                                 b32,
+	descriptorBindingInlineUniformBlockUpdateAfterBind: b32,
+}
+
+PhysicalDeviceInlineUniformBlockPropertiesEXT :: struct {
+	sType:                                                   StructureType,
+	pNext:                                                   rawptr,
+	maxInlineUniformBlockSize:                               u32,
+	maxPerStageDescriptorInlineUniformBlocks:                u32,
+	maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
+	maxDescriptorSetInlineUniformBlocks:                     u32,
+	maxDescriptorSetUpdateAfterBindInlineUniformBlocks:      u32,
+}
+
+WriteDescriptorSetInlineUniformBlockEXT :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	dataSize: u32,
+	pData:    rawptr,
+}
+
+DescriptorPoolInlineUniformBlockCreateInfoEXT :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	maxInlineUniformBlockBindings: u32,
+}
+
+SampleLocationEXT :: struct {
+	x: f32,
+	y: f32,
+}
+
+SampleLocationsInfoEXT :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	sampleLocationsPerPixel: SampleCountFlags,
+	sampleLocationGridSize:  Extent2D,
+	sampleLocationsCount:    u32,
+	pSampleLocations:        ^SampleLocationEXT,
+}
+
+AttachmentSampleLocationsEXT :: struct {
+	attachmentIndex:     u32,
+	sampleLocationsInfo: SampleLocationsInfoEXT,
+}
+
+SubpassSampleLocationsEXT :: struct {
+	subpassIndex:        u32,
+	sampleLocationsInfo: SampleLocationsInfoEXT,
+}
+
+RenderPassSampleLocationsBeginInfoEXT :: struct {
+	sType:                                 StructureType,
+	pNext:                                 rawptr,
+	attachmentInitialSampleLocationsCount: u32,
+	pAttachmentInitialSampleLocations:     ^AttachmentSampleLocationsEXT,
+	postSubpassSampleLocationsCount:       u32,
+	pPostSubpassSampleLocations:           ^SubpassSampleLocationsEXT,
+}
+
+PipelineSampleLocationsStateCreateInfoEXT :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	sampleLocationsEnable: b32,
+	sampleLocationsInfo:   SampleLocationsInfoEXT,
+}
+
+PhysicalDeviceSampleLocationsPropertiesEXT :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	sampleLocationSampleCounts:    SampleCountFlags,
+	maxSampleLocationGridSize:     Extent2D,
+	sampleLocationCoordinateRange: [2]f32,
+	sampleLocationSubPixelBits:    u32,
+	variableSampleLocations:       b32,
+}
+
+MultisamplePropertiesEXT :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	maxSampleLocationGridSize: Extent2D,
+}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	advancedBlendCoherentOperations: b32,
+}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT :: struct {
+	sType:                                 StructureType,
+	pNext:                                 rawptr,
+	advancedBlendMaxColorAttachments:      u32,
+	advancedBlendIndependentBlend:         b32,
+	advancedBlendNonPremultipliedSrcColor: b32,
+	advancedBlendNonPremultipliedDstColor: b32,
+	advancedBlendCorrelatedOverlap:        b32,
+	advancedBlendAllOperations:            b32,
+}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	srcPremultiplied: b32,
+	dstPremultiplied: b32,
+	blendOverlap:     BlendOverlapEXT,
+}
+
+PipelineCoverageToColorStateCreateInfoNV :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	flags:                   PipelineCoverageToColorStateCreateFlagsNV,
+	coverageToColorEnable:   b32,
+	coverageToColorLocation: u32,
+}
+
+PipelineCoverageModulationStateCreateInfoNV :: struct {
+	sType:                         StructureType,
+	pNext:                         rawptr,
+	flags:                         PipelineCoverageModulationStateCreateFlagsNV,
+	coverageModulationMode:        CoverageModulationModeNV,
+	coverageModulationTableEnable: b32,
+	coverageModulationTableCount:  u32,
+	pCoverageModulationTable:      ^f32,
+}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	shaderSMCount:    u32,
+	shaderWarpsPerSM: u32,
+}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	shaderSMBuiltins: b32,
+}
+
+DrmFormatModifierPropertiesEXT :: struct {
+	drmFormatModifier:               u64,
+	drmFormatModifierPlaneCount:     u32,
+	drmFormatModifierTilingFeatures: FormatFeatureFlags,
+}
+
+DrmFormatModifierPropertiesListEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	drmFormatModifierCount:       u32,
+	pDrmFormatModifierProperties: ^DrmFormatModifierPropertiesEXT,
+}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	drmFormatModifier:     u64,
+	sharingMode:           SharingMode,
+	queueFamilyIndexCount: u32,
+	pQueueFamilyIndices:   ^u32,
+}
+
+ImageDrmFormatModifierListCreateInfoEXT :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	drmFormatModifierCount: u32,
+	pDrmFormatModifiers:    ^u64,
+}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	drmFormatModifier:           u64,
+	drmFormatModifierPlaneCount: u32,
+	pPlaneLayouts:               ^SubresourceLayout,
+}
+
+ImageDrmFormatModifierPropertiesEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	drmFormatModifier: u64,
+}
+
+ValidationCacheCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           ValidationCacheCreateFlagsEXT,
+	initialDataSize: int,
+	pInitialData:    rawptr,
+}
+
+ShaderModuleValidationCacheCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	validationCache: ValidationCacheEXT,
+}
+
+ShadingRatePaletteNV :: struct {
+	shadingRatePaletteEntryCount: u32,
+	pShadingRatePaletteEntries:   ^ShadingRatePaletteEntryNV,
+}
+
+PipelineViewportShadingRateImageStateCreateInfoNV :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	shadingRateImageEnable: b32,
+	viewportCount:          u32,
+	pShadingRatePalettes:   ^ShadingRatePaletteNV,
+}
+
+PhysicalDeviceShadingRateImageFeaturesNV :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	shadingRateImage:             b32,
+	shadingRateCoarseSampleOrder: b32,
+}
+
+PhysicalDeviceShadingRateImagePropertiesNV :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	shadingRateTexelSize:        Extent2D,
+	shadingRatePaletteSize:      u32,
+	shadingRateMaxCoarseSamples: u32,
+}
+
+CoarseSampleLocationNV :: struct {
+	pixelX: u32,
+	pixelY: u32,
+	sample: u32,
+}
+
+CoarseSampleOrderCustomNV :: struct {
+	shadingRate:         ShadingRatePaletteEntryNV,
+	sampleCount:         u32,
+	sampleLocationCount: u32,
+	pSampleLocations:    ^CoarseSampleLocationNV,
+}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	sampleOrderType:        CoarseSampleOrderTypeNV,
+	customSampleOrderCount: u32,
+	pCustomSampleOrders:    ^CoarseSampleOrderCustomNV,
+}
+
+RayTracingShaderGroupCreateInfoNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	type:               RayTracingShaderGroupTypeKHR,
+	generalShader:      u32,
+	closestHitShader:   u32,
+	anyHitShader:       u32,
+	intersectionShader: u32,
+}
+
+RayTracingPipelineCreateInfoNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	flags:              PipelineCreateFlags,
+	stageCount:         u32,
+	pStages:            ^PipelineShaderStageCreateInfo,
+	groupCount:         u32,
+	pGroups:            ^RayTracingShaderGroupCreateInfoNV,
+	maxRecursionDepth:  u32,
+	layout:             PipelineLayout,
+	basePipelineHandle: Pipeline,
+	basePipelineIndex:  i32,
+}
+
+GeometryTrianglesNV :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	vertexData:      Buffer,
+	vertexOffset:    DeviceSize,
+	vertexCount:     u32,
+	vertexStride:    DeviceSize,
+	vertexFormat:    Format,
+	indexData:       Buffer,
+	indexOffset:     DeviceSize,
+	indexCount:      u32,
+	indexType:       IndexType,
+	transformData:   Buffer,
+	transformOffset: DeviceSize,
+}
+
+GeometryAABBNV :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	aabbData: Buffer,
+	numAABBs: u32,
+	stride:   u32,
+	offset:   DeviceSize,
+}
+
+GeometryDataNV :: struct {
+	triangles: GeometryTrianglesNV,
+	aabbs:     GeometryAABBNV,
+}
+
+GeometryNV :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	geometryType: GeometryTypeKHR,
+	geometry:     GeometryDataNV,
+	flags:        GeometryFlagsKHR,
+}
+
+AccelerationStructureInfoNV :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	type:          AccelerationStructureTypeNV,
+	flags:         BuildAccelerationStructureFlagsNV,
+	instanceCount: u32,
+	geometryCount: u32,
+	pGeometries:   ^GeometryNV,
+}
+
+AccelerationStructureCreateInfoNV :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	compactedSize: DeviceSize,
+	info:          AccelerationStructureInfoNV,
+}
+
+BindAccelerationStructureMemoryInfoNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	accelerationStructure: AccelerationStructureNV,
+	memory:                DeviceMemory,
+	memoryOffset:          DeviceSize,
+	deviceIndexCount:      u32,
+	pDeviceIndices:        ^u32,
+}
+
+WriteDescriptorSetAccelerationStructureNV :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	accelerationStructureCount: u32,
+	pAccelerationStructures:    ^AccelerationStructureNV,
+}
+
+AccelerationStructureMemoryRequirementsInfoNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	type:                  AccelerationStructureMemoryRequirementsTypeNV,
+	accelerationStructure: AccelerationStructureNV,
+}
+
+PhysicalDeviceRayTracingPropertiesNV :: struct {
+	sType:                                  StructureType,
+	pNext:                                  rawptr,
+	shaderGroupHandleSize:                  u32,
+	maxRecursionDepth:                      u32,
+	maxShaderGroupStride:                   u32,
+	shaderGroupBaseAlignment:               u32,
+	maxGeometryCount:                       u64,
+	maxInstanceCount:                       u64,
+	maxTriangleCount:                       u64,
+	maxDescriptorSetAccelerationStructures: u32,
+}
+
+TransformMatrixKHR :: struct {
+	matrix: [3][4]f32,
+}
+
+AabbPositionsKHR :: struct {
+	minX: f32,
+	minY: f32,
+	minZ: f32,
+	maxX: f32,
+	maxY: f32,
+	maxZ: f32,
+}
+
+AccelerationStructureInstanceKHR :: struct {
+	transform:                      TransformMatrixKHR,
+	accelerationStructureReference: u64,
+}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	representativeFragmentTest: b32,
+}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	representativeFragmentTestEnable: b32,
+}
+
+PhysicalDeviceImageViewImageFormatInfoEXT :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	imageViewType: ImageViewType,
+}
+
+FilterCubicImageViewImageFormatPropertiesEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	filterCubic:       b32,
+	filterCubicMinmax: b32,
+}
+
+DeviceQueueGlobalPriorityCreateInfoEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	globalPriority: QueueGlobalPriorityEXT,
+}
+
+ImportMemoryHostPointerInfoEXT :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	handleType:   ExternalMemoryHandleTypeFlags,
+	pHostPointer: rawptr,
+}
+
+MemoryHostPointerPropertiesEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	memoryTypeBits: u32,
+}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	minImportedHostPointerAlignment: DeviceSize,
+}
+
+PipelineCompilerControlCreateInfoAMD :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	compilerControlFlags: PipelineCompilerControlFlagsAMD,
+}
+
+CalibratedTimestampInfoEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	timeDomain: TimeDomainEXT,
+}
+
+PhysicalDeviceShaderCorePropertiesAMD :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	shaderEngineCount:          u32,
+	shaderArraysPerEngineCount: u32,
+	computeUnitsPerShaderArray: u32,
+	simdPerComputeUnit:         u32,
+	wavefrontsPerSimd:          u32,
+	wavefrontSize:              u32,
+	sgprsPerSimd:               u32,
+	minSgprAllocation:          u32,
+	maxSgprAllocation:          u32,
+	sgprAllocationGranularity:  u32,
+	vgprsPerSimd:               u32,
+	minVgprAllocation:          u32,
+	maxVgprAllocation:          u32,
+	vgprAllocationGranularity:  u32,
+}
+
+DeviceMemoryOverallocationCreateInfoAMD :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	overallocationBehavior: MemoryOverallocationBehaviorAMD,
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	maxVertexAttribDivisor: u32,
+}
+
+VertexInputBindingDivisorDescriptionEXT :: struct {
+	binding: u32,
+	divisor: u32,
+}
+
+PipelineVertexInputDivisorStateCreateInfoEXT :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	vertexBindingDivisorCount: u32,
+	pVertexBindingDivisors:    ^VertexInputBindingDivisorDescriptionEXT,
+}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesEXT :: struct {
+	sType:                                  StructureType,
+	pNext:                                  rawptr,
+	vertexAttributeInstanceRateDivisor:     b32,
+	vertexAttributeInstanceRateZeroDivisor: b32,
+}
+
+PipelineCreationFeedbackEXT :: struct {
+	flags:    PipelineCreationFeedbackFlagsEXT,
+	duration: u64,
+}
+
+PipelineCreationFeedbackCreateInfoEXT :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	pPipelineCreationFeedback:          ^PipelineCreationFeedbackEXT,
+	pipelineStageCreationFeedbackCount: u32,
+	pPipelineStageCreationFeedbacks:    ^PipelineCreationFeedbackEXT,
+}
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	computeDerivativeGroupQuads:  b32,
+	computeDerivativeGroupLinear: b32,
+}
+
+PhysicalDeviceMeshShaderFeaturesNV :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	taskShader: b32,
+	meshShader: b32,
+}
+
+PhysicalDeviceMeshShaderPropertiesNV :: struct {
+	sType:                             StructureType,
+	pNext:                             rawptr,
+	maxDrawMeshTasksCount:             u32,
+	maxTaskWorkGroupInvocations:       u32,
+	maxTaskWorkGroupSize:              [3]u32,
+	maxTaskTotalMemorySize:            u32,
+	maxTaskOutputCount:                u32,
+	maxMeshWorkGroupInvocations:       u32,
+	maxMeshWorkGroupSize:              [3]u32,
+	maxMeshTotalMemorySize:            u32,
+	maxMeshOutputVertices:             u32,
+	maxMeshOutputPrimitives:           u32,
+	maxMeshMultiviewViewCount:         u32,
+	meshOutputPerVertexGranularity:    u32,
+	meshOutputPerPrimitiveGranularity: u32,
+}
+
+DrawMeshTasksIndirectCommandNV :: struct {
+	taskCount: u32,
+	firstTask: u32,
+}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesNV :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	fragmentShaderBarycentric: b32,
+}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	imageFootprint: b32,
+}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	exclusiveScissorCount: u32,
+	pExclusiveScissors:    ^Rect2D,
+}
+
+PhysicalDeviceExclusiveScissorFeaturesNV :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	exclusiveScissor: b32,
+}
+
+QueueFamilyCheckpointPropertiesNV :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	checkpointExecutionStageMask: PipelineStageFlags,
+}
+
+CheckpointDataNV :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	stage:             PipelineStageFlags,
+	pCheckpointMarker: rawptr,
+}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	shaderIntegerFunctions2: b32,
+}
+
+PerformanceValueDataINTEL :: struct #raw_union {
+	value32:     u32,
+	value64:     u64,
+	valueFloat:  f32,
+	valueBool:   b32,
+	valueString: cstring,
+}
+
+PerformanceValueINTEL :: struct {
+	type: PerformanceValueTypeINTEL,
+	data: PerformanceValueDataINTEL,
+}
+
+InitializePerformanceApiInfoINTEL :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	pUserData: rawptr,
+}
+
+QueryPoolPerformanceQueryCreateInfoINTEL :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	performanceCountersSampling: QueryPoolSamplingModeINTEL,
+}
+
+PerformanceMarkerInfoINTEL :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	marker: u64,
+}
+
+PerformanceStreamMarkerInfoINTEL :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	marker: u32,
+}
+
+PerformanceOverrideInfoINTEL :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	type:      PerformanceOverrideTypeINTEL,
+	enable:    b32,
+	parameter: u64,
+}
+
+PerformanceConfigurationAcquireInfoINTEL :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	type:  PerformanceConfigurationTypeINTEL,
+}
+
+PhysicalDevicePCIBusInfoPropertiesEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pciDomain:   u32,
+	pciBus:      u32,
+	pciDevice:   u32,
+	pciFunction: u32,
+}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	localDimmingSupport: b32,
+}
+
+SwapchainDisplayNativeHdrCreateInfoAMD :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	localDimmingEnable: b32,
+}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT :: struct {
+	sType:                                 StructureType,
+	pNext:                                 rawptr,
+	fragmentDensityMap:                    b32,
+	fragmentDensityMapDynamic:             b32,
+	fragmentDensityMapNonSubsampledImages: b32,
+}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	minFragmentDensityTexelSize: Extent2D,
+	maxFragmentDensityTexelSize: Extent2D,
+	fragmentDensityInvocations:  b32,
+}
+
+RenderPassFragmentDensityMapCreateInfoEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	fragmentDensityMapAttachment: AttachmentReference,
+}
+
+PhysicalDeviceSubgroupSizeControlFeaturesEXT :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	subgroupSizeControl:  b32,
+	computeFullSubgroups: b32,
+}
+
+PhysicalDeviceSubgroupSizeControlPropertiesEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	minSubgroupSize:              u32,
+	maxSubgroupSize:              u32,
+	maxComputeWorkgroupSubgroups: u32,
+	requiredSubgroupSizeStages:   ShaderStageFlags,
+}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	requiredSubgroupSize: u32,
+}
+
+PhysicalDeviceShaderCoreProperties2AMD :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	shaderCoreFeatures:     ShaderCorePropertiesFlagsAMD,
+	activeComputeUnitCount: u32,
+}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	deviceCoherentMemory: b32,
+}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	shaderImageInt64Atomics: b32,
+	sparseImageInt64Atomics: b32,
+}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	heapBudget: [MAX_MEMORY_HEAPS]DeviceSize,
+	heapUsage:  [MAX_MEMORY_HEAPS]DeviceSize,
+}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	memoryPriority: b32,
+}
+
+MemoryPriorityAllocateInfoEXT :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	priority: f32,
+}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	dedicatedAllocationImageAliasing: b32,
+}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	bufferDeviceAddress:              b32,
+	bufferDeviceAddressCaptureReplay: b32,
+	bufferDeviceAddressMultiDevice:   b32,
+}
+
+BufferDeviceAddressCreateInfoEXT :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	deviceAddress: DeviceAddress,
+}
+
+PhysicalDeviceToolPropertiesEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	name:        [MAX_EXTENSION_NAME_SIZE]byte,
+	version:     [MAX_EXTENSION_NAME_SIZE]byte,
+	purposes:    ToolPurposeFlagsEXT,
+	description: [MAX_DESCRIPTION_SIZE]byte,
+	layer:       [MAX_EXTENSION_NAME_SIZE]byte,
+}
+
+ValidationFeaturesEXT :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	enabledValidationFeatureCount:  u32,
+	pEnabledValidationFeatures:     ^ValidationFeatureEnableEXT,
+	disabledValidationFeatureCount: u32,
+	pDisabledValidationFeatures:    ^ValidationFeatureDisableEXT,
+}
+
+CooperativeMatrixPropertiesNV :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	MSize: u32,
+	NSize: u32,
+	KSize: u32,
+	AType: ComponentTypeNV,
+	BType: ComponentTypeNV,
+	CType: ComponentTypeNV,
+	DType: ComponentTypeNV,
+	scope: ScopeNV,
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV :: struct {
+	sType:                               StructureType,
+	pNext:                               rawptr,
+	cooperativeMatrix:                   b32,
+	cooperativeMatrixRobustBufferAccess: b32,
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	cooperativeMatrixSupportedStages: ShaderStageFlags,
+}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	coverageReductionMode: b32,
+}
+
+PipelineCoverageReductionStateCreateInfoNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	flags:                 PipelineCoverageReductionStateCreateFlagsNV,
+	coverageReductionMode: CoverageReductionModeNV,
+}
+
+FramebufferMixedSamplesCombinationNV :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	coverageReductionMode: CoverageReductionModeNV,
+	rasterizationSamples:  SampleCountFlags,
+	depthStencilSamples:   SampleCountFlags,
+	colorSamples:          SampleCountFlags,
+}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	fragmentShaderSampleInterlock:      b32,
+	fragmentShaderPixelInterlock:       b32,
+	fragmentShaderShadingRateInterlock: b32,
+}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	ycbcrImageArrays: b32,
+}
+
+PhysicalDeviceProvokingVertexFeaturesEXT :: struct {
+	sType:                                     StructureType,
+	pNext:                                     rawptr,
+	provokingVertexLast:                       b32,
+	transformFeedbackPreservesProvokingVertex: b32,
+}
+
+PhysicalDeviceProvokingVertexPropertiesEXT :: struct {
+	sType:                                                StructureType,
+	pNext:                                                rawptr,
+	provokingVertexModePerPipeline:                       b32,
+	transformFeedbackPreservesTriangleFanProvokingVertex: b32,
+}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	provokingVertexMode: ProvokingVertexModeEXT,
+}
+
+HeadlessSurfaceCreateInfoEXT :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: HeadlessSurfaceCreateFlagsEXT,
+}
+
+PhysicalDeviceLineRasterizationFeaturesEXT :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	rectangularLines:         b32,
+	bresenhamLines:           b32,
+	smoothLines:              b32,
+	stippledRectangularLines: b32,
+	stippledBresenhamLines:   b32,
+	stippledSmoothLines:      b32,
+}
+
+PhysicalDeviceLineRasterizationPropertiesEXT :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	lineSubPixelPrecisionBits: u32,
+}
+
+PipelineRasterizationLineStateCreateInfoEXT :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	lineRasterizationMode: LineRasterizationModeEXT,
+	stippledLineEnable:    b32,
+	lineStippleFactor:     u32,
+	lineStipplePattern:    u16,
+}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	shaderBufferFloat32Atomics:   b32,
+	shaderBufferFloat32AtomicAdd: b32,
+	shaderBufferFloat64Atomics:   b32,
+	shaderBufferFloat64AtomicAdd: b32,
+	shaderSharedFloat32Atomics:   b32,
+	shaderSharedFloat32AtomicAdd: b32,
+	shaderSharedFloat64Atomics:   b32,
+	shaderSharedFloat64AtomicAdd: b32,
+	shaderImageFloat32Atomics:    b32,
+	shaderImageFloat32AtomicAdd:  b32,
+	sparseImageFloat32Atomics:    b32,
+	sparseImageFloat32AtomicAdd:  b32,
+}
+
+PhysicalDeviceIndexTypeUint8FeaturesEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	indexTypeUint8: b32,
+}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	extendedDynamicState: b32,
+}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	shaderBufferFloat16Atomics:      b32,
+	shaderBufferFloat16AtomicAdd:    b32,
+	shaderBufferFloat16AtomicMinMax: b32,
+	shaderBufferFloat32AtomicMinMax: b32,
+	shaderBufferFloat64AtomicMinMax: b32,
+	shaderSharedFloat16Atomics:      b32,
+	shaderSharedFloat16AtomicAdd:    b32,
+	shaderSharedFloat16AtomicMinMax: b32,
+	shaderSharedFloat32AtomicMinMax: b32,
+	shaderSharedFloat64AtomicMinMax: b32,
+	shaderImageFloat32AtomicMinMax:  b32,
+	sparseImageFloat32AtomicMinMax:  b32,
+}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	shaderDemoteToHelperInvocation: b32,
+}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV :: struct {
+	sType:                                    StructureType,
+	pNext:                                    rawptr,
+	maxGraphicsShaderGroupCount:              u32,
+	maxIndirectSequenceCount:                 u32,
+	maxIndirectCommandsTokenCount:            u32,
+	maxIndirectCommandsStreamCount:           u32,
+	maxIndirectCommandsTokenOffset:           u32,
+	maxIndirectCommandsStreamStride:          u32,
+	minSequencesCountBufferOffsetAlignment:   u32,
+	minSequencesIndexBufferOffsetAlignment:   u32,
+	minIndirectCommandsBufferOffsetAlignment: u32,
+}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	deviceGeneratedCommands: b32,
+}
+
+GraphicsShaderGroupCreateInfoNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	stageCount:         u32,
+	pStages:            ^PipelineShaderStageCreateInfo,
+	pVertexInputState:  ^PipelineVertexInputStateCreateInfo,
+	pTessellationState: ^PipelineTessellationStateCreateInfo,
+}
+
+GraphicsPipelineShaderGroupsCreateInfoNV :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	groupCount:    u32,
+	pGroups:       ^GraphicsShaderGroupCreateInfoNV,
+	pipelineCount: u32,
+	pPipelines:    ^Pipeline,
+}
+
+BindShaderGroupIndirectCommandNV :: struct {
+	groupIndex: u32,
+}
+
+BindIndexBufferIndirectCommandNV :: struct {
+	bufferAddress: DeviceAddress,
+	size:          u32,
+	indexType:     IndexType,
+}
+
+BindVertexBufferIndirectCommandNV :: struct {
+	bufferAddress: DeviceAddress,
+	size:          u32,
+	stride:        u32,
+}
+
+SetStateFlagsIndirectCommandNV :: struct {
+	data: u32,
+}
+
+IndirectCommandsStreamNV :: struct {
+	buffer: Buffer,
+	offset: DeviceSize,
+}
+
+IndirectCommandsLayoutTokenNV :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	tokenType:                    IndirectCommandsTokenTypeNV,
+	stream:                       u32,
+	offset:                       u32,
+	vertexBindingUnit:            u32,
+	vertexDynamicStride:          b32,
+	pushconstantPipelineLayout:   PipelineLayout,
+	pushconstantShaderStageFlags: ShaderStageFlags,
+	pushconstantOffset:           u32,
+	pushconstantSize:             u32,
+	indirectStateFlags:           IndirectStateFlagsNV,
+	indexTypeCount:               u32,
+	pIndexTypes:                  ^IndexType,
+	pIndexTypeValues:             ^u32,
+}
+
+IndirectCommandsLayoutCreateInfoNV :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	flags:             IndirectCommandsLayoutUsageFlagsNV,
+	pipelineBindPoint: PipelineBindPoint,
+	tokenCount:        u32,
+	pTokens:           ^IndirectCommandsLayoutTokenNV,
+	streamCount:       u32,
+	pStreamStrides:    ^u32,
+}
+
+GeneratedCommandsInfoNV :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	pipelineBindPoint:      PipelineBindPoint,
+	pipeline:               Pipeline,
+	indirectCommandsLayout: IndirectCommandsLayoutNV,
+	streamCount:            u32,
+	pStreams:               ^IndirectCommandsStreamNV,
+	sequencesCount:         u32,
+	preprocessBuffer:       Buffer,
+	preprocessOffset:       DeviceSize,
+	preprocessSize:         DeviceSize,
+	sequencesCountBuffer:   Buffer,
+	sequencesCountOffset:   DeviceSize,
+	sequencesIndexBuffer:   Buffer,
+	sequencesIndexOffset:   DeviceSize,
+}
+
+GeneratedCommandsMemoryRequirementsInfoNV :: struct {
+	sType:                  StructureType,
+	pNext:                  rawptr,
+	pipelineBindPoint:      PipelineBindPoint,
+	pipeline:               Pipeline,
+	indirectCommandsLayout: IndirectCommandsLayoutNV,
+	maxSequencesCount:      u32,
+}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	inheritedViewportScissor2D: b32,
+}
+
+CommandBufferInheritanceViewportScissorInfoNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	viewportScissor2D:  b32,
+	viewportDepthCount: u32,
+	pViewportDepths:    ^Viewport,
+}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT :: struct {
+	sType:                StructureType,
+	pNext:                rawptr,
+	texelBufferAlignment: b32,
+}
+
+PhysicalDeviceTexelBufferAlignmentPropertiesEXT :: struct {
+	sType:                                        StructureType,
+	pNext:                                        rawptr,
+	storageTexelBufferOffsetAlignmentBytes:       DeviceSize,
+	storageTexelBufferOffsetSingleTexelAlignment: b32,
+	uniformTexelBufferOffsetAlignmentBytes:       DeviceSize,
+	uniformTexelBufferOffsetSingleTexelAlignment: b32,
+}
+
+RenderPassTransformBeginInfoQCOM :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	transform: SurfaceTransformFlagsKHR,
+}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	transform:  SurfaceTransformFlagsKHR,
+	renderArea: Rect2D,
+}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	deviceMemoryReport: b32,
+}
+
+DeviceMemoryReportCallbackDataEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	flags:          DeviceMemoryReportFlagsEXT,
+	type:           DeviceMemoryReportEventTypeEXT,
+	memoryObjectId: u64,
+	size:           DeviceSize,
+	objectType:     ObjectType,
+	objectHandle:   u64,
+	heapIndex:      u32,
+}
+
+DeviceDeviceMemoryReportCreateInfoEXT :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	flags:           DeviceMemoryReportFlagsEXT,
+	pfnUserCallback: ProcDeviceMemoryReportCallbackEXT,
+	pUserData:       rawptr,
+}
+
+PhysicalDeviceRobustness2FeaturesEXT :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	robustBufferAccess2: b32,
+	robustImageAccess2:  b32,
+	nullDescriptor:      b32,
+}
+
+PhysicalDeviceRobustness2PropertiesEXT :: struct {
+	sType:                                  StructureType,
+	pNext:                                  rawptr,
+	robustStorageBufferAccessSizeAlignment: DeviceSize,
+	robustUniformBufferAccessSizeAlignment: DeviceSize,
+}
+
+SamplerCustomBorderColorCreateInfoEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	customBorderColor: ClearColorValue,
+	format:            Format,
+}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	maxCustomBorderColorSamplers: u32,
+}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	customBorderColors:             b32,
+	customBorderColorWithoutFormat: b32,
+}
+
+PhysicalDevicePrivateDataFeaturesEXT :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	privateData: b32,
+}
+
+DevicePrivateDataCreateInfoEXT :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	privateDataSlotRequestCount: u32,
+}
+
+PrivateDataSlotCreateInfoEXT :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: PrivateDataSlotCreateFlagsEXT,
+}
+
+PhysicalDevicePipelineCreationCacheControlFeaturesEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	pipelineCreationCacheControl: b32,
+}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	diagnosticsConfig: b32,
+}
+
+DeviceDiagnosticsConfigCreateInfoNV :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: DeviceDiagnosticsConfigFlagsNV,
+}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV :: struct {
+	sType:                            StructureType,
+	pNext:                            rawptr,
+	fragmentShadingRateEnums:         b32,
+	supersampleFragmentShadingRates:  b32,
+	noInvocationFragmentShadingRates: b32,
+}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV :: struct {
+	sType:                                 StructureType,
+	pNext:                                 rawptr,
+	maxFragmentShadingRateInvocationCount: SampleCountFlags,
+}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	shadingRateType: FragmentShadingRateTypeNV,
+	shadingRate:     FragmentShadingRateNV,
+	combinerOps:     [2]FragmentShadingRateCombinerOpKHR,
+}
+
+DeviceOrHostAddressConstKHR :: struct #raw_union {
+	deviceAddress: DeviceAddress,
+	hostAddress:   rawptr,
+}
+
+AccelerationStructureGeometryMotionTrianglesDataNV :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	vertexData: DeviceOrHostAddressConstKHR,
+}
+
+AccelerationStructureMotionInfoNV :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	maxInstances: u32,
+	flags:        AccelerationStructureMotionInfoFlagsNV,
+}
+
+AccelerationStructureMatrixMotionInstanceNV :: struct {
+	transformT0:                    TransformMatrixKHR,
+	transformT1:                    TransformMatrixKHR,
+	accelerationStructureReference: u64,
+}
+
+SRTDataNV :: struct {
+	sx:  f32,
+	a:   f32,
+	b:   f32,
+	pvx: f32,
+	sy:  f32,
+	c:   f32,
+	pvy: f32,
+	sz:  f32,
+	pvz: f32,
+	qx:  f32,
+	qy:  f32,
+	qz:  f32,
+	qw:  f32,
+	tx:  f32,
+	ty:  f32,
+	tz:  f32,
+}
+
+AccelerationStructureSRTMotionInstanceNV :: struct {
+	transformT0:                    SRTDataNV,
+	transformT1:                    SRTDataNV,
+	accelerationStructureReference: u64,
+}
+
+AccelerationStructureMotionInstanceDataNV :: struct #raw_union {
+	staticInstance:       AccelerationStructureInstanceKHR,
+	matrixMotionInstance: AccelerationStructureMatrixMotionInstanceNV,
+	srtMotionInstance:    AccelerationStructureSRTMotionInstanceNV,
+}
+
+AccelerationStructureMotionInstanceNV :: struct {
+	type:  AccelerationStructureMotionInstanceTypeNV,
+	flags: AccelerationStructureMotionInstanceFlagsNV,
+	data:  AccelerationStructureMotionInstanceDataNV,
+}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV :: struct {
+	sType:                                         StructureType,
+	pNext:                                         rawptr,
+	rayTracingMotionBlur:                          b32,
+	rayTracingMotionBlurPipelineTraceRaysIndirect: b32,
+}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	ycbcr2plane444Formats: b32,
+}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	fragmentDensityMapDeferred: b32,
+}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT :: struct {
+	sType:                                     StructureType,
+	pNext:                                     rawptr,
+	subsampledLoads:                           b32,
+	subsampledCoarseReconstructionEarlyAccess: b32,
+	maxSubsampledArrayLayers:                  u32,
+	maxDescriptorSetSubsampledSamplers:        u32,
+}
+
+CopyCommandTransformInfoQCOM :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	transform: SurfaceTransformFlagsKHR,
+}
+
+PhysicalDeviceImageRobustnessFeaturesEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	robustImageAccess: b32,
+}
+
+PhysicalDevice4444FormatsFeaturesEXT :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	formatA4R4G4B4: b32,
+	formatA4B4G4R4: b32,
+}
+
+PhysicalDeviceMutableDescriptorTypeFeaturesVALVE :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	mutableDescriptorType: b32,
+}
+
+MutableDescriptorTypeListVALVE :: struct {
+	descriptorTypeCount: u32,
+	pDescriptorTypes:    ^DescriptorType,
+}
+
+MutableDescriptorTypeCreateInfoVALVE :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	mutableDescriptorTypeListCount: u32,
+	pMutableDescriptorTypeLists:    ^MutableDescriptorTypeListVALVE,
+}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT :: struct {
+	sType:                   StructureType,
+	pNext:                   rawptr,
+	vertexInputDynamicState: b32,
+}
+
+VertexInputBindingDescription2EXT :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	binding:   u32,
+	stride:    u32,
+	inputRate: VertexInputRate,
+	divisor:   u32,
+}
+
+VertexInputAttributeDescription2EXT :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	location: u32,
+	binding:  u32,
+	format:   Format,
+	offset:   u32,
+}
+
+PhysicalDeviceDrmPropertiesEXT :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	hasPrimary:   b32,
+	hasRender:    b32,
+	primaryMajor: i64,
+	primaryMinor: i64,
+	renderMajor:  i64,
+	renderMinor:  i64,
+}
+
+SubpassShadingPipelineCreateInfoHUAWEI :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	renderPass: RenderPass,
+	subpass:    u32,
+}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	subpassShading: b32,
+}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI :: struct {
+	sType:                                     StructureType,
+	pNext:                                     rawptr,
+	maxSubpassShadingWorkgroupSizeAspectRatio: u32,
+}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	invocationMask: b32,
+}
+
+MemoryGetRemoteAddressInfoNV :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	memory:     DeviceMemory,
+	handleType: ExternalMemoryHandleTypeFlags,
+}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	externalMemoryRDMA: b32,
+}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT :: struct {
+	sType:                                   StructureType,
+	pNext:                                   rawptr,
+	extendedDynamicState2:                   b32,
+	extendedDynamicState2LogicOp:            b32,
+	extendedDynamicState2PatchControlPoints: b32,
+}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	colorWriteEnable: b32,
+}
+
+PipelineColorWriteCreateInfoEXT :: struct {
+	sType:              StructureType,
+	pNext:              rawptr,
+	attachmentCount:    u32,
+	pColorWriteEnables: ^b32,
+}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesEXT :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	globalPriorityQuery: b32,
+}
+
+QueueFamilyGlobalPriorityPropertiesEXT :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	priorityCount: u32,
+	priorities:    [MAX_GLOBAL_PRIORITY_SIZE_EXT]QueueGlobalPriorityEXT,
+}
+
+PhysicalDeviceMultiDrawFeaturesEXT :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	multiDraw: b32,
+}
+
+PhysicalDeviceMultiDrawPropertiesEXT :: struct {
+	sType:             StructureType,
+	pNext:             rawptr,
+	maxMultiDrawCount: u32,
+}
+
+MultiDrawInfoEXT :: struct {
+	firstVertex: u32,
+	vertexCount: u32,
+}
+
+MultiDrawIndexedInfoEXT :: struct {
+	firstIndex:   u32,
+	indexCount:   u32,
+	vertexOffset: i32,
+}
+
+DeviceOrHostAddressKHR :: struct #raw_union {
+	deviceAddress: DeviceAddress,
+	hostAddress:   rawptr,
+}
+
+AccelerationStructureBuildRangeInfoKHR :: struct {
+	primitiveCount:  u32,
+	primitiveOffset: u32,
+	firstVertex:     u32,
+	transformOffset: u32,
+}
+
+AccelerationStructureGeometryTrianglesDataKHR :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	vertexFormat:  Format,
+	vertexData:    DeviceOrHostAddressConstKHR,
+	vertexStride:  DeviceSize,
+	maxVertex:     u32,
+	indexType:     IndexType,
+	indexData:     DeviceOrHostAddressConstKHR,
+	transformData: DeviceOrHostAddressConstKHR,
+}
+
+AccelerationStructureGeometryAabbsDataKHR :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	data:   DeviceOrHostAddressConstKHR,
+	stride: DeviceSize,
+}
+
+AccelerationStructureGeometryInstancesDataKHR :: struct {
+	sType:           StructureType,
+	pNext:           rawptr,
+	arrayOfPointers: b32,
+	data:            DeviceOrHostAddressConstKHR,
+}
+
+AccelerationStructureGeometryDataKHR :: struct #raw_union {
+	triangles: AccelerationStructureGeometryTrianglesDataKHR,
+	aabbs:     AccelerationStructureGeometryAabbsDataKHR,
+	instances: AccelerationStructureGeometryInstancesDataKHR,
+}
+
+AccelerationStructureGeometryKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	geometryType: GeometryTypeKHR,
+	geometry:     AccelerationStructureGeometryDataKHR,
+	flags:        GeometryFlagsKHR,
+}
+
+AccelerationStructureBuildGeometryInfoKHR :: struct {
+	sType:                    StructureType,
+	pNext:                    rawptr,
+	type:                     AccelerationStructureTypeKHR,
+	flags:                    BuildAccelerationStructureFlagsKHR,
+	mode:                     BuildAccelerationStructureModeKHR,
+	srcAccelerationStructure: AccelerationStructureKHR,
+	dstAccelerationStructure: AccelerationStructureKHR,
+	geometryCount:            u32,
+	pGeometries:              ^AccelerationStructureGeometryKHR,
+	ppGeometries:             ^^AccelerationStructureGeometryKHR,
+	scratchData:              DeviceOrHostAddressKHR,
+}
+
+AccelerationStructureCreateInfoKHR :: struct {
+	sType:         StructureType,
+	pNext:         rawptr,
+	createFlags:   AccelerationStructureCreateFlagsKHR,
+	buffer:        Buffer,
+	offset:        DeviceSize,
+	size:          DeviceSize,
+	type:          AccelerationStructureTypeKHR,
+	deviceAddress: DeviceAddress,
+}
+
+WriteDescriptorSetAccelerationStructureKHR :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	accelerationStructureCount: u32,
+	pAccelerationStructures:    ^AccelerationStructureKHR,
+}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR :: struct {
+	sType:                                                 StructureType,
+	pNext:                                                 rawptr,
+	accelerationStructure:                                 b32,
+	accelerationStructureCaptureReplay:                    b32,
+	accelerationStructureIndirectBuild:                    b32,
+	accelerationStructureHostCommands:                     b32,
+	descriptorBindingAccelerationStructureUpdateAfterBind: b32,
+}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR :: struct {
+	sType:                                                      StructureType,
+	pNext:                                                      rawptr,
+	maxGeometryCount:                                           u64,
+	maxInstanceCount:                                           u64,
+	maxPrimitiveCount:                                          u64,
+	maxPerStageDescriptorAccelerationStructures:                u32,
+	maxPerStageDescriptorUpdateAfterBindAccelerationStructures: u32,
+	maxDescriptorSetAccelerationStructures:                     u32,
+	maxDescriptorSetUpdateAfterBindAccelerationStructures:      u32,
+	minAccelerationStructureScratchOffsetAlignment:             u32,
+}
+
+AccelerationStructureDeviceAddressInfoKHR :: struct {
+	sType:                 StructureType,
+	pNext:                 rawptr,
+	accelerationStructure: AccelerationStructureKHR,
+}
+
+AccelerationStructureVersionInfoKHR :: struct {
+	sType:        StructureType,
+	pNext:        rawptr,
+	pVersionData: ^u8,
+}
+
+CopyAccelerationStructureToMemoryInfoKHR :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	src:   AccelerationStructureKHR,
+	dst:   DeviceOrHostAddressKHR,
+	mode:  CopyAccelerationStructureModeKHR,
+}
+
+CopyMemoryToAccelerationStructureInfoKHR :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	src:   DeviceOrHostAddressConstKHR,
+	dst:   AccelerationStructureKHR,
+	mode:  CopyAccelerationStructureModeKHR,
+}
+
+CopyAccelerationStructureInfoKHR :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	src:   AccelerationStructureKHR,
+	dst:   AccelerationStructureKHR,
+	mode:  CopyAccelerationStructureModeKHR,
+}
+
+AccelerationStructureBuildSizesInfoKHR :: struct {
+	sType:                     StructureType,
+	pNext:                     rawptr,
+	accelerationStructureSize: DeviceSize,
+	updateScratchSize:         DeviceSize,
+	buildScratchSize:          DeviceSize,
+}
+
+RayTracingShaderGroupCreateInfoKHR :: struct {
+	sType:                           StructureType,
+	pNext:                           rawptr,
+	type:                            RayTracingShaderGroupTypeKHR,
+	generalShader:                   u32,
+	closestHitShader:                u32,
+	anyHitShader:                    u32,
+	intersectionShader:              u32,
+	pShaderGroupCaptureReplayHandle: rawptr,
+}
+
+RayTracingPipelineInterfaceCreateInfoKHR :: struct {
+	sType:                          StructureType,
+	pNext:                          rawptr,
+	maxPipelineRayPayloadSize:      u32,
+	maxPipelineRayHitAttributeSize: u32,
+}
+
+RayTracingPipelineCreateInfoKHR :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	flags:                        PipelineCreateFlags,
+	stageCount:                   u32,
+	pStages:                      ^PipelineShaderStageCreateInfo,
+	groupCount:                   u32,
+	pGroups:                      ^RayTracingShaderGroupCreateInfoKHR,
+	maxPipelineRayRecursionDepth: u32,
+	pLibraryInfo:                 ^PipelineLibraryCreateInfoKHR,
+	pLibraryInterface:            ^RayTracingPipelineInterfaceCreateInfoKHR,
+	pDynamicState:                ^PipelineDynamicStateCreateInfo,
+	layout:                       PipelineLayout,
+	basePipelineHandle:           Pipeline,
+	basePipelineIndex:            i32,
+}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR :: struct {
+	sType:                                                 StructureType,
+	pNext:                                                 rawptr,
+	rayTracingPipeline:                                    b32,
+	rayTracingPipelineShaderGroupHandleCaptureReplay:      b32,
+	rayTracingPipelineShaderGroupHandleCaptureReplayMixed: b32,
+	rayTracingPipelineTraceRaysIndirect:                   b32,
+	rayTraversalPrimitiveCulling:                          b32,
+}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR :: struct {
+	sType:                              StructureType,
+	pNext:                              rawptr,
+	shaderGroupHandleSize:              u32,
+	maxRayRecursionDepth:               u32,
+	maxShaderGroupStride:               u32,
+	shaderGroupBaseAlignment:           u32,
+	shaderGroupHandleCaptureReplaySize: u32,
+	maxRayDispatchInvocationCount:      u32,
+	shaderGroupHandleAlignment:         u32,
+	maxRayHitAttributeSize:             u32,
+}
+
+StridedDeviceAddressRegionKHR :: struct {
+	deviceAddress: DeviceAddress,
+	stride:        DeviceSize,
+	size:          DeviceSize,
+}
+
+TraceRaysIndirectCommandKHR :: struct {
+	width:  u32,
+	height: u32,
+	depth:  u32,
+}
+
+PhysicalDeviceRayQueryFeaturesKHR :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	rayQuery: b32,
+}
+
+NegotiateLayerInterface :: struct {
+	sType:                        NegotiateLayerStructType,
+	loaderLayerInterfaceVersion:  u32,
+	pfnGetInstanceProcAddr:       ProcGetInstanceProcAddr,
+	pfnGetDeviceProcAddr:         ProcGetDeviceProcAddr,
+	pfnGetPhysicalDeviceProcAddr: ProcGetPhysicalDeviceProcAddr,
+}
+
+LayerInstanceLink_ :: struct {
+	pfnNextGetInstanceProcAddr:       ProcGetInstanceProcAddr,
+	pfnNextGetPhysicalDeviceProcAddr: ProcGetPhysicalDeviceProcAddr,
+}
+
+LayerDeviceInfo_ :: struct {
+	pfnNextGetInstanceProcAddr: ProcGetInstanceProcAddr,
+}
+
+LayerDeviceLink_ :: struct {
+	pfnNextGetInstanceProcAddr: ProcGetInstanceProcAddr,
+	pfnNextGetDeviceProcAddr:   ProcGetDeviceProcAddr,
+}
+
+ChainHeader :: struct {
+	type:    ChainType,
+	version: u32,
+	size:    u32,
+}
+
+EnumerateInstanceExtensionPropertiesChain :: struct {
+	header: ChainHeader,
+}
+
+EnumerateInstanceLayerPropertiesChain :: struct {
+	header: ChainHeader,
+}
+
+EnumerateInstanceVersionChain :: struct {
+	header: ChainHeader,
+}
+
+Win32SurfaceCreateInfoKHR :: struct {
+	sType:     StructureType,
+	pNext:     rawptr,
+	flags:     Win32SurfaceCreateFlagsKHR,
+	hinstance: HINSTANCE,
+	hwnd:      HWND,
+}
+
+ImportMemoryWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalMemoryHandleTypeFlags,
+	handle:     HANDLE,
+	name:       LPCWSTR,
+}
+
+ExportMemoryWin32HandleInfoKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pAttributes: ^SECURITY_ATTRIBUTES,
+	dwAccess:    DWORD,
+	name:        LPCWSTR,
+}
+
+MemoryWin32HandlePropertiesKHR :: struct {
+	sType:          StructureType,
+	pNext:          rawptr,
+	memoryTypeBits: u32,
+}
+
+MemoryGetWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	memory:     DeviceMemory,
+	handleType: ExternalMemoryHandleTypeFlags,
+}
+
+Win32KeyedMutexAcquireReleaseInfoKHR :: struct {
+	sType:            StructureType,
+	pNext:            rawptr,
+	acquireCount:     u32,
+	pAcquireSyncs:    ^DeviceMemory,
+	pAcquireKeys:     ^u64,
+	pAcquireTimeouts: ^u32,
+	releaseCount:     u32,
+	pReleaseSyncs:    ^DeviceMemory,
+	pReleaseKeys:     ^u64,
+}
+
+ImportSemaphoreWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	semaphore:  Semaphore,
+	flags:      SemaphoreImportFlags,
+	handleType: ExternalSemaphoreHandleTypeFlags,
+	handle:     HANDLE,
+	name:       LPCWSTR,
+}
+
+ExportSemaphoreWin32HandleInfoKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pAttributes: ^SECURITY_ATTRIBUTES,
+	dwAccess:    DWORD,
+	name:        LPCWSTR,
+}
+
+D3D12FenceSubmitInfoKHR :: struct {
+	sType:                      StructureType,
+	pNext:                      rawptr,
+	waitSemaphoreValuesCount:   u32,
+	pWaitSemaphoreValues:       ^u64,
+	signalSemaphoreValuesCount: u32,
+	pSignalSemaphoreValues:     ^u64,
+}
+
+SemaphoreGetWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	semaphore:  Semaphore,
+	handleType: ExternalSemaphoreHandleTypeFlags,
+}
+
+ImportFenceWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	fence:      Fence,
+	flags:      FenceImportFlags,
+	handleType: ExternalFenceHandleTypeFlags,
+	handle:     HANDLE,
+	name:       LPCWSTR,
+}
+
+ExportFenceWin32HandleInfoKHR :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pAttributes: ^SECURITY_ATTRIBUTES,
+	dwAccess:    DWORD,
+	name:        LPCWSTR,
+}
+
+FenceGetWin32HandleInfoKHR :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	fence:      Fence,
+	handleType: ExternalFenceHandleTypeFlags,
+}
+
+ImportMemoryWin32HandleInfoNV :: struct {
+	sType:      StructureType,
+	pNext:      rawptr,
+	handleType: ExternalMemoryHandleTypeFlagsNV,
+	handle:     HANDLE,
+}
+
+ExportMemoryWin32HandleInfoNV :: struct {
+	sType:       StructureType,
+	pNext:       rawptr,
+	pAttributes: ^SECURITY_ATTRIBUTES,
+	dwAccess:    DWORD,
+}
+
+Win32KeyedMutexAcquireReleaseInfoNV :: struct {
+	sType:                       StructureType,
+	pNext:                       rawptr,
+	acquireCount:                u32,
+	pAcquireSyncs:               ^DeviceMemory,
+	pAcquireKeys:                ^u64,
+	pAcquireTimeoutMilliseconds: ^u32,
+	releaseCount:                u32,
+	pReleaseSyncs:               ^DeviceMemory,
+	pReleaseKeys:                ^u64,
+}
+
+SurfaceFullScreenExclusiveInfoEXT :: struct {
+	sType:               StructureType,
+	pNext:               rawptr,
+	fullScreenExclusive: FullScreenExclusiveEXT,
+}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT :: struct {
+	sType:                        StructureType,
+	pNext:                        rawptr,
+	fullScreenExclusiveSupported: b32,
+}
+
+SurfaceFullScreenExclusiveWin32InfoEXT :: struct {
+	sType:    StructureType,
+	pNext:    rawptr,
+	hmonitor: HMONITOR,
+}
+
+MetalSurfaceCreateInfoEXT :: struct {
+	sType:  StructureType,
+	pNext:  rawptr,
+	flags:  MetalSurfaceCreateFlagsEXT,
+	pLayer: ^CAMetalLayer,
+}
+
+MacOSSurfaceCreateInfoMVK :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: MacOSSurfaceCreateFlagsMVK,
+	pView: rawptr,
+}
+
+IOSSurfaceCreateInfoMVK :: struct {
+	sType: StructureType,
+	pNext: rawptr,
+	flags: IOSSurfaceCreateFlagsMVK,
+	pView: rawptr,
+}
+
+// Aliases
+PhysicalDeviceVariablePointerFeatures                :: PhysicalDeviceVariablePointersFeatures;
+PhysicalDeviceShaderDrawParameterFeatures            :: PhysicalDeviceShaderDrawParametersFeatures;
+RenderPassMultiviewCreateInfoKHR                     :: RenderPassMultiviewCreateInfo;
+PhysicalDeviceMultiviewFeaturesKHR                   :: PhysicalDeviceMultiviewFeatures;
+PhysicalDeviceMultiviewPropertiesKHR                 :: PhysicalDeviceMultiviewProperties;
+PhysicalDeviceFeatures2KHR                           :: PhysicalDeviceFeatures2;
+PhysicalDeviceProperties2KHR                         :: PhysicalDeviceProperties2;
+FormatProperties2KHR                                 :: FormatProperties2;
+ImageFormatProperties2KHR                            :: ImageFormatProperties2;
+PhysicalDeviceImageFormatInfo2KHR                    :: PhysicalDeviceImageFormatInfo2;
+QueueFamilyProperties2KHR                            :: QueueFamilyProperties2;
+PhysicalDeviceMemoryProperties2KHR                   :: PhysicalDeviceMemoryProperties2;
+SparseImageFormatProperties2KHR                      :: SparseImageFormatProperties2;
+PhysicalDeviceSparseImageFormatInfo2KHR              :: PhysicalDeviceSparseImageFormatInfo2;
+PeerMemoryFeatureFlagsKHR                            :: PeerMemoryFeatureFlags;
+PeerMemoryFeatureFlagKHR                             :: PeerMemoryFeatureFlag;
+MemoryAllocateFlagsKHR                               :: MemoryAllocateFlags;
+MemoryAllocateFlagKHR                                :: MemoryAllocateFlag;
+MemoryAllocateFlagsInfoKHR                           :: MemoryAllocateFlagsInfo;
+DeviceGroupRenderPassBeginInfoKHR                    :: DeviceGroupRenderPassBeginInfo;
+DeviceGroupCommandBufferBeginInfoKHR                 :: DeviceGroupCommandBufferBeginInfo;
+DeviceGroupSubmitInfoKHR                             :: DeviceGroupSubmitInfo;
+DeviceGroupBindSparseInfoKHR                         :: DeviceGroupBindSparseInfo;
+BindBufferMemoryDeviceGroupInfoKHR                   :: BindBufferMemoryDeviceGroupInfo;
+BindImageMemoryDeviceGroupInfoKHR                    :: BindImageMemoryDeviceGroupInfo;
+CommandPoolTrimFlagsKHR                              :: CommandPoolTrimFlags;
+PhysicalDeviceGroupPropertiesKHR                     :: PhysicalDeviceGroupProperties;
+DeviceGroupDeviceCreateInfoKHR                       :: DeviceGroupDeviceCreateInfo;
+ExternalMemoryHandleTypeFlagsKHR                     :: ExternalMemoryHandleTypeFlags;
+ExternalMemoryHandleTypeFlagKHR                      :: ExternalMemoryHandleTypeFlag;
+ExternalMemoryFeatureFlagsKHR                        :: ExternalMemoryFeatureFlags;
+ExternalMemoryFeatureFlagKHR                         :: ExternalMemoryFeatureFlag;
+ExternalMemoryPropertiesKHR                          :: ExternalMemoryProperties;
+PhysicalDeviceExternalImageFormatInfoKHR             :: PhysicalDeviceExternalImageFormatInfo;
+ExternalImageFormatPropertiesKHR                     :: ExternalImageFormatProperties;
+PhysicalDeviceExternalBufferInfoKHR                  :: PhysicalDeviceExternalBufferInfo;
+ExternalBufferPropertiesKHR                          :: ExternalBufferProperties;
+PhysicalDeviceIDPropertiesKHR                        :: PhysicalDeviceIDProperties;
+ExternalMemoryImageCreateInfoKHR                     :: ExternalMemoryImageCreateInfo;
+ExternalMemoryBufferCreateInfoKHR                    :: ExternalMemoryBufferCreateInfo;
+ExportMemoryAllocateInfoKHR                          :: ExportMemoryAllocateInfo;
+ExternalSemaphoreHandleTypeFlagsKHR                  :: ExternalSemaphoreHandleTypeFlags;
+ExternalSemaphoreHandleTypeFlagKHR                   :: ExternalSemaphoreHandleTypeFlag;
+ExternalSemaphoreFeatureFlagsKHR                     :: ExternalSemaphoreFeatureFlags;
+ExternalSemaphoreFeatureFlagKHR                      :: ExternalSemaphoreFeatureFlag;
+PhysicalDeviceExternalSemaphoreInfoKHR               :: PhysicalDeviceExternalSemaphoreInfo;
+ExternalSemaphorePropertiesKHR                       :: ExternalSemaphoreProperties;
+SemaphoreImportFlagsKHR                              :: SemaphoreImportFlags;
+SemaphoreImportFlagKHR                               :: SemaphoreImportFlag;
+ExportSemaphoreCreateInfoKHR                         :: ExportSemaphoreCreateInfo;
+PhysicalDeviceShaderFloat16Int8FeaturesKHR           :: PhysicalDeviceShaderFloat16Int8Features;
+PhysicalDeviceFloat16Int8FeaturesKHR                 :: PhysicalDeviceShaderFloat16Int8Features;
+PhysicalDevice16BitStorageFeaturesKHR                :: PhysicalDevice16BitStorageFeatures;
+DescriptorUpdateTemplateKHR                          :: DescriptorUpdateTemplate;
+DescriptorUpdateTemplateTypeKHR                      :: DescriptorUpdateTemplateType;
+DescriptorUpdateTemplateCreateFlagsKHR               :: DescriptorUpdateTemplateCreateFlags;
+DescriptorUpdateTemplateEntryKHR                     :: DescriptorUpdateTemplateEntry;
+DescriptorUpdateTemplateCreateInfoKHR                :: DescriptorUpdateTemplateCreateInfo;
+PhysicalDeviceImagelessFramebufferFeaturesKHR        :: PhysicalDeviceImagelessFramebufferFeatures;
+FramebufferAttachmentsCreateInfoKHR                  :: FramebufferAttachmentsCreateInfo;
+FramebufferAttachmentImageInfoKHR                    :: FramebufferAttachmentImageInfo;
+RenderPassAttachmentBeginInfoKHR                     :: RenderPassAttachmentBeginInfo;
+RenderPassCreateInfo2KHR                             :: RenderPassCreateInfo2;
+AttachmentDescription2KHR                            :: AttachmentDescription2;
+AttachmentReference2KHR                              :: AttachmentReference2;
+SubpassDescription2KHR                               :: SubpassDescription2;
+SubpassDependency2KHR                                :: SubpassDependency2;
+SubpassBeginInfoKHR                                  :: SubpassBeginInfo;
+SubpassEndInfoKHR                                    :: SubpassEndInfo;
+ExternalFenceHandleTypeFlagsKHR                      :: ExternalFenceHandleTypeFlags;
+ExternalFenceHandleTypeFlagKHR                       :: ExternalFenceHandleTypeFlag;
+ExternalFenceFeatureFlagsKHR                         :: ExternalFenceFeatureFlags;
+ExternalFenceFeatureFlagKHR                          :: ExternalFenceFeatureFlag;
+PhysicalDeviceExternalFenceInfoKHR                   :: PhysicalDeviceExternalFenceInfo;
+ExternalFencePropertiesKHR                           :: ExternalFenceProperties;
+FenceImportFlagsKHR                                  :: FenceImportFlags;
+FenceImportFlagKHR                                   :: FenceImportFlag;
+ExportFenceCreateInfoKHR                             :: ExportFenceCreateInfo;
+PointClippingBehaviorKHR                             :: PointClippingBehavior;
+TessellationDomainOriginKHR                          :: TessellationDomainOrigin;
+PhysicalDevicePointClippingPropertiesKHR             :: PhysicalDevicePointClippingProperties;
+RenderPassInputAttachmentAspectCreateInfoKHR         :: RenderPassInputAttachmentAspectCreateInfo;
+InputAttachmentAspectReferenceKHR                    :: InputAttachmentAspectReference;
+ImageViewUsageCreateInfoKHR                          :: ImageViewUsageCreateInfo;
+PipelineTessellationDomainOriginStateCreateInfoKHR   :: PipelineTessellationDomainOriginStateCreateInfo;
+PhysicalDeviceVariablePointerFeaturesKHR             :: PhysicalDeviceVariablePointersFeatures;
+PhysicalDeviceVariablePointersFeaturesKHR            :: PhysicalDeviceVariablePointersFeatures;
+MemoryDedicatedRequirementsKHR                       :: MemoryDedicatedRequirements;
+MemoryDedicatedAllocateInfoKHR                       :: MemoryDedicatedAllocateInfo;
+BufferMemoryRequirementsInfo2KHR                     :: BufferMemoryRequirementsInfo2;
+ImageMemoryRequirementsInfo2KHR                      :: ImageMemoryRequirementsInfo2;
+ImageSparseMemoryRequirementsInfo2KHR                :: ImageSparseMemoryRequirementsInfo2;
+MemoryRequirements2KHR                               :: MemoryRequirements2;
+SparseImageMemoryRequirements2KHR                    :: SparseImageMemoryRequirements2;
+ImageFormatListCreateInfoKHR                         :: ImageFormatListCreateInfo;
+SamplerYcbcrConversionKHR                            :: SamplerYcbcrConversion;
+SamplerYcbcrModelConversionKHR                       :: SamplerYcbcrModelConversion;
+SamplerYcbcrRangeKHR                                 :: SamplerYcbcrRange;
+ChromaLocationKHR                                    :: ChromaLocation;
+SamplerYcbcrConversionCreateInfoKHR                  :: SamplerYcbcrConversionCreateInfo;
+SamplerYcbcrConversionInfoKHR                        :: SamplerYcbcrConversionInfo;
+BindImagePlaneMemoryInfoKHR                          :: BindImagePlaneMemoryInfo;
+ImagePlaneMemoryRequirementsInfoKHR                  :: ImagePlaneMemoryRequirementsInfo;
+PhysicalDeviceSamplerYcbcrConversionFeaturesKHR      :: PhysicalDeviceSamplerYcbcrConversionFeatures;
+SamplerYcbcrConversionImageFormatPropertiesKHR       :: SamplerYcbcrConversionImageFormatProperties;
+BindBufferMemoryInfoKHR                              :: BindBufferMemoryInfo;
+BindImageMemoryInfoKHR                               :: BindImageMemoryInfo;
+PhysicalDeviceMaintenance3PropertiesKHR              :: PhysicalDeviceMaintenance3Properties;
+DescriptorSetLayoutSupportKHR                        :: DescriptorSetLayoutSupport;
+PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR :: PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+PhysicalDevice8BitStorageFeaturesKHR                 :: PhysicalDevice8BitStorageFeatures;
+PhysicalDeviceShaderAtomicInt64FeaturesKHR           :: PhysicalDeviceShaderAtomicInt64Features;
+DriverIdKHR                                          :: DriverId;
+ConformanceVersionKHR                                :: ConformanceVersion;
+PhysicalDeviceDriverPropertiesKHR                    :: PhysicalDeviceDriverProperties;
+ShaderFloatControlsIndependenceKHR                   :: ShaderFloatControlsIndependence;
+PhysicalDeviceFloatControlsPropertiesKHR             :: PhysicalDeviceFloatControlsProperties;
+ResolveModeFlagKHR                                   :: ResolveModeFlag;
+ResolveModeFlagsKHR                                  :: ResolveModeFlags;
+SubpassDescriptionDepthStencilResolveKHR             :: SubpassDescriptionDepthStencilResolve;
+PhysicalDeviceDepthStencilResolvePropertiesKHR       :: PhysicalDeviceDepthStencilResolveProperties;
+SemaphoreTypeKHR                                     :: SemaphoreType;
+SemaphoreWaitFlagKHR                                 :: SemaphoreWaitFlag;
+SemaphoreWaitFlagsKHR                                :: SemaphoreWaitFlags;
+PhysicalDeviceTimelineSemaphoreFeaturesKHR           :: PhysicalDeviceTimelineSemaphoreFeatures;
+PhysicalDeviceTimelineSemaphorePropertiesKHR         :: PhysicalDeviceTimelineSemaphoreProperties;
+SemaphoreTypeCreateInfoKHR                           :: SemaphoreTypeCreateInfo;
+TimelineSemaphoreSubmitInfoKHR                       :: TimelineSemaphoreSubmitInfo;
+SemaphoreWaitInfoKHR                                 :: SemaphoreWaitInfo;
+SemaphoreSignalInfoKHR                               :: SemaphoreSignalInfo;
+PhysicalDeviceVulkanMemoryModelFeaturesKHR           :: PhysicalDeviceVulkanMemoryModelFeatures;
+PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR :: PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+AttachmentReferenceStencilLayoutKHR                  :: AttachmentReferenceStencilLayout;
+AttachmentDescriptionStencilLayoutKHR                :: AttachmentDescriptionStencilLayout;
+PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR :: PhysicalDeviceUniformBufferStandardLayoutFeatures;
+PhysicalDeviceBufferDeviceAddressFeaturesKHR         :: PhysicalDeviceBufferDeviceAddressFeatures;
+BufferDeviceAddressInfoKHR                           :: BufferDeviceAddressInfo;
+BufferOpaqueCaptureAddressCreateInfoKHR              :: BufferOpaqueCaptureAddressCreateInfo;
+MemoryOpaqueCaptureAddressAllocateInfoKHR            :: MemoryOpaqueCaptureAddressAllocateInfo;
+DeviceMemoryOpaqueCaptureAddressInfoKHR              :: DeviceMemoryOpaqueCaptureAddressInfo;
+PipelineStageFlags2KHR                               :: Flags64;
+PipelineStageFlag2KHR                                :: Flags64;
+AccessFlags2KHR                                      :: Flags64;
+AccessFlag2KHR                                       :: Flags64;
+SamplerReductionModeEXT                              :: SamplerReductionMode;
+SamplerReductionModeCreateInfoEXT                    :: SamplerReductionModeCreateInfo;
+PhysicalDeviceSamplerFilterMinmaxPropertiesEXT       :: PhysicalDeviceSamplerFilterMinmaxProperties;
+DescriptorBindingFlagEXT                             :: DescriptorBindingFlag;
+DescriptorBindingFlagsEXT                            :: DescriptorBindingFlags;
+DescriptorSetLayoutBindingFlagsCreateInfoEXT         :: DescriptorSetLayoutBindingFlagsCreateInfo;
+PhysicalDeviceDescriptorIndexingFeaturesEXT          :: PhysicalDeviceDescriptorIndexingFeatures;
+PhysicalDeviceDescriptorIndexingPropertiesEXT        :: PhysicalDeviceDescriptorIndexingProperties;
+DescriptorSetVariableDescriptorCountAllocateInfoEXT  :: DescriptorSetVariableDescriptorCountAllocateInfo;
+DescriptorSetVariableDescriptorCountLayoutSupportEXT :: DescriptorSetVariableDescriptorCountLayoutSupport;
+RayTracingShaderGroupTypeNV                          :: RayTracingShaderGroupTypeKHR;
+GeometryTypeNV                                       :: GeometryTypeKHR;
+AccelerationStructureTypeNV                          :: AccelerationStructureTypeKHR;
+CopyAccelerationStructureModeNV                      :: CopyAccelerationStructureModeKHR;
+GeometryFlagsNV                                      :: GeometryFlagsKHR;
+GeometryFlagNV                                       :: GeometryFlagKHR;
+GeometryInstanceFlagsNV                              :: GeometryInstanceFlagsKHR;
+GeometryInstanceFlagNV                               :: GeometryInstanceFlagKHR;
+BuildAccelerationStructureFlagsNV                    :: BuildAccelerationStructureFlagsKHR;
+BuildAccelerationStructureFlagNV                     :: BuildAccelerationStructureFlagKHR;
+TransformMatrixNV                                    :: TransformMatrixKHR;
+AabbPositionsNV                                      :: AabbPositionsKHR;
+AccelerationStructureInstanceNV                      :: AccelerationStructureInstanceKHR;
+QueryPoolCreateInfoINTEL                             :: QueryPoolPerformanceQueryCreateInfoINTEL;
+PhysicalDeviceScalarBlockLayoutFeaturesEXT           :: PhysicalDeviceScalarBlockLayoutFeatures;
+PhysicalDeviceBufferAddressFeaturesEXT               :: PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+BufferDeviceAddressInfoEXT                           :: BufferDeviceAddressInfo;
+ImageStencilUsageCreateInfoEXT                       :: ImageStencilUsageCreateInfo;
+PhysicalDeviceHostQueryResetFeaturesEXT              :: PhysicalDeviceHostQueryResetFeatures;
+
+