diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
new file mode 100755
index 00000000000..6a6aa27a4f0
--- /dev/null
+++ b/dlls/winevulkan/make_vulkan
@@ -0,0 +1,1188 @@
+#!/usr/bin/python3
+# Wine Vulkan generator
+#
+# Copyright 2017-2018 Roderick Colenbrander
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+#
+
+import argparse
+import logging
+import re
+import sys
+import xml.etree.ElementTree as ET
+from collections import OrderedDict
+from collections.abc import Sequence
+from enum import Enum
+
+# This script generates code for a Wine Vulkan ICD driver from Vulkan's vk.xml.
+# Generating the code is like 10x worse than OpenGL, which is mostly a calling
+# convention passthrough.
+#
+# The script parses vk.xml and maps functions and types to helper objects. These
+# helper objects simplify the xml parsing and map closely to the Vulkan types.
+# The code generation utilizes the helper objects during code generation and
+# most of the ugly work is carried out by these objects.
+#
+# Vulkan ICD challenges:
+# - Vulkan ICD loader (vulkan-1.dll) relies on a section at the start of
+# 'dispatchable handles' (e.g. VkDevice, VkInstance) for it to insert
+# its private data. It uses this area to stare its own dispatch tables
+# for loader internal use. This means any dispatchable objects need wrapping.
+#
+# - Vulkan structures have different alignment between win32 and 32-bit Linux.
+# This means structures with alignment differences need conversion logic.
+# Often structures are nested, so the parent structure may not need any
+# conversion, but some child may need some.
+#
+# vk.xml parsing challenges:
+# - Contains type data for all platforms (generic Vulkan, Windows, Linux,..).
+# Parsing of extension information required to pull in types and functions
+# we really want to generate. Just tying all the data together is tricky.
+#
+# - Extensions can affect core types e.g. add new enum values, bitflags or
+# additional structure chaining through 'pNext' / 'sType'.
+#
+# - Arrays are used all over the place for parameters or for structure members.
+# Array length is often stored in a previous parameter or another structure
+# member and thus needs careful parsing.
+
+LOGGER = logging.Logger("vulkan")
+LOGGER.addHandler(logging.StreamHandler())
+
+# Filenames to create.
+WINE_VULKAN_H = "../../include/wine/vulkan.h"
+
+
+class VkBaseType(object):
+ def __init__(self, name, _type, requires=None):
+ """ Vulkan base type class.
+
+ VkBaseType is mostly used by Vulkan to define its own
+ base types like VkFlags through typedef out of e.g. uint32_t.
+
+ Args:
+ name (:obj:'str'): Name of the base type.
+ _type (:obj:'str'): Underlaying type
+ requires (:obj:'str', optional): Other types required.
+ Often bitmask values pull in a *FlagBits type.
+ """
+ self.name = name
+ self.type = _type
+ self.requires = requires
+ self.required = False
+
+ def definition(self):
+ text = "typedef {0} {1};\n".format(self.type, self.name)
+ return text
+
+
+class VkConstant(object):
+ def __init__(self, name, value):
+ self.name = name
+ self.value = value
+
+ def definition(self):
+ text = "#define {0} {1}\n".format(self.name, self.value)
+ return text
+
+
+class VkDefine(object):
+ def __init__(self, name, value):
+ self.name = name
+ self.value = value
+
+ @staticmethod
+ def from_xml(define):
+ name_elem = define.find("name")
+
+ if name_elem is None:
+ # some_value
+ # At the time of writing there is only 1 define of this category
+ # 'VK_DEFINE_NON_DISPATCHABLE_HANDLE'.
+ name = define.attrib.get("name")
+
+ # We override behavior of VK_DEFINE_NON_DISPATCHABLE handle as the default
+ # definition various between 64-bit (uses pointers) and 32-bit (uses uint64_t).
+ # This complicates TRACEs in the thunks, so just use uint64_t.
+ if name == "VK_DEFINE_NON_DISPATCHABLE_HANDLE":
+ value = "#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;"
+ else:
+ value = define.text
+ return VkDefine(name, value)
+
+ # With a name element the structure is like:
+ # some_namesome_value
+ name = name_elem.text
+
+ # VK_API_VERSION is a deprecated constant and we don't really want to parse it or generate
+ # code for it. However the vk.xml feature section still references it.
+ if name == "VK_API_VERSION":
+ return VkDefine(name, "")
+
+ # The body of the define is basically unstructured C code. It is not meant for easy parsing.
+ # Some lines contain deprecated values or comments, which we try to filter out.
+ value = ""
+ for line in define.text.splitlines():
+ # Skip comments or deprecated values.
+ if "//" in line:
+ continue
+ value += line
+
+ for child in define:
+ value += child.text
+ if child.tail is not None:
+ value += child.tail
+
+ return VkDefine(name, value.rstrip(' '))
+
+ def definition(self):
+ if self.value is None:
+ return ""
+
+ # Nothing to do as the value was already put in the right form during parsing.
+ return "{0}\n".format(self.value)
+
+
+class VkEnum(object):
+ def __init__(self, name, values):
+ self.name = name
+ self.values = values
+ self.required = False
+
+ @staticmethod
+ def from_xml(enum):
+ name = enum.attrib.get("name")
+ values = []
+
+ for v in enum.findall("enum"):
+ # Value is either a value or a bitpos, only one can exist.
+ value = v.attrib.get("value")
+ if value is None:
+ # bitmask
+ value = 1 << int(v.attrib.get("bitpos"))
+ values.append(VkEnumValue(v.attrib.get("name"), value, hex=True))
+ else:
+ # Some values are in hex form. We want to preserve the hex representation
+ # at least when we convert back to a string. Internally we want to use int.
+ if "0x" in value:
+ values.append(VkEnumValue(v.attrib.get("name"), int(value, 0), hex=True))
+ else:
+ values.append(VkEnumValue(v.attrib.get("name"), int(value, 0)))
+
+ # vulkan.h contains a *_MAX_ENUM value set to 32-bit at the time of writing,
+ # which is to prepare for extensions as they can add values and hence affect
+ # the size definition.
+ max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',name).upper() + "_MAX_ENUM"
+ values.append(VkEnumValue(max_name, 0x7fffffff, hex=True))
+
+ return VkEnum(name, values)
+
+ def add(self, value):
+ """ Add a value to enum. """
+ self.values.append(value)
+
+ def definition(self):
+ text = "typedef enum {0}\n{{\n".format(self.name)
+
+ # Print values sorted, values can have been added in a random order.
+ values = sorted(self.values, key=lambda value: value.value)
+ for value in values:
+ text += " {0},\n".format(value.definition())
+ text += "}} {0};\n\n".format(self.name)
+ return text
+
+
+class VkEnumValue(object):
+ def __init__(self, name, value, hex=False):
+ self.name = name
+ self.value = value
+ self.hex = hex
+
+ def __repr__(self):
+ return "{0}={1}".format(self.name, self.value)
+
+ def definition(self):
+ """ Convert to text definition e.g. VK_FOO = 1 """
+
+ # Hex is commonly used for FlagBits and sometimes within
+ # a non-FlagBits enum for a bitmask value as well.
+ if self.hex:
+ return "{0} = 0x{1:08x}".format(self.name, self.value)
+ else:
+ return "{0} = {1}".format(self.name, self.value)
+
+
+class VkFunction(object):
+ def __init__(self, _type=None, name=None, params=[], extension=None):
+ self.extension = extension
+ self.name = name
+ self.type = _type
+ self.params = params
+
+ # Required is set while parsing which APIs and types are required
+ # and is used by the code generation.
+ self.required = False
+
+ @staticmethod
+ def from_xml(command, types):
+ proto = command.find("proto")
+
+ func_name = proto.find("name").text
+ func_type = proto.find("type").text
+
+ params = []
+ for param in command.findall("param"):
+ vk_param = VkParam.from_xml(param, types)
+ params.append(vk_param)
+
+ return VkFunction(_type=func_type, name=func_name, params=params)
+
+ def is_device_func(self):
+ # If none of the other, it must be a device function
+ return not self.is_global_func() and not self.is_instance_func()
+
+ def is_global_func(self):
+ # Treat vkGetInstanceProcAddr as a global function as it
+ # can operate with NULL for vkInstance.
+ if self.name == "vkGetInstanceProcAddr":
+ return True
+ # Global functions are not passed a dispatchable object.
+ elif self.params[0].is_dispatchable():
+ return False
+ return True
+
+ def is_instance_func(self):
+ # Instance functions are passed VkInstance or VkPhysicalDevice.
+ if self.params[0].type in ["VkInstance", "VkPhysicalDevice"]:
+ return True
+ return False
+
+ def is_required(self):
+ return self.required
+
+ def pfn(self, call_conv=None, conv=False):
+ """ Create function pointer. """
+
+ if call_conv is not None:
+ pfn = "{0} ({1} *p_{2})(".format(self.type, call_conv, self.name)
+ else:
+ pfn = "{0} (*p_{1})(".format(self.type, self.name)
+
+ for i, param in enumerate(self.params):
+ if param.const:
+ pfn += param.const + " "
+
+ pfn += param.type
+ if conv and param.needs_conversion():
+ pfn += "_host"
+
+ if param.is_pointer():
+ pfn += " " + param.pointer
+
+ if param.array_len is not None:
+ pfn += "[{0}]".format(param.array_len)
+
+ if i < len(self.params) - 1:
+ pfn += ", "
+ pfn += ")"
+ return pfn
+
+ def prototype(self, call_conv=None, prefix=None, postfix=None):
+ """ Generate prototype for given function.
+
+ Args:
+ call_conv (str, optional): calling convention e.g. WINAPI
+ prefix (str, optional): prefix to append prior to function name e.g. vkFoo -> wine_vkFoo
+ postfix (str, optional): text to append after function name but prior to semicolon e.g. DECLSPEC_HIDDEN
+ """
+
+ proto = "{0}".format(self.type)
+
+ if call_conv is not None:
+ proto += " {0}".format(call_conv)
+
+ if prefix is not None:
+ proto += " {0}{1}(".format(prefix, self.name)
+ else:
+ proto += " {0}(".format(self.name)
+
+ # Add all the paremeters.
+ proto += ", ".join([p.definition() for p in self.params])
+
+ if postfix is not None:
+ proto += ") {0}".format(postfix)
+ else:
+ proto += ")"
+
+ return proto
+
+
+class VkFunctionPointer(object):
+ def __init__(self, _type, name, members):
+ self.name = name
+ self.members = members
+ self.type = _type
+ self.required = False
+
+ @staticmethod
+ def from_xml(funcpointer):
+ members = []
+ begin = None
+
+ for t in funcpointer.findall("type"):
+ # General form:
+ # void* pUserData,
+ # Parsing of the tail (anything past ) is tricky since there
+ # can be other data on the next line like: const int..
+ const = begin
+ _type = t.text
+ lines = t.tail.split(",\n")
+ if lines[0][0] == "*":
+ pointer = "*"
+ name = lines[0][1:].strip()
+ else:
+ pointer = None
+ name = lines[0].strip()
+
+ # Filter out ); if it is contained.
+ name = name.partition(");")[0]
+
+ # If tail encompasses multiple lines, assign the second line to begin
+ # for the next line.
+ try:
+ begin = lines[1].strip()
+ except IndexError:
+ begin = None
+
+ members.append(VkMember(const=const, _type=_type, pointer=pointer, name=name))
+
+ _type = funcpointer.text
+ name = funcpointer.find("name").text
+ return VkFunctionPointer(_type, name, members)
+
+ def definition(self):
+ text = "{0} {1})(\n".format(self.type, self.name)
+
+ first = True
+ if len(self.members) > 0:
+ for m in self.members:
+ if first:
+ text += " " + m.definition()
+ first = False
+ else:
+ text += ",\n " + m.definition()
+ else:
+ # Just make the compiler happy by adding a void parameter.
+ text += "void"
+ text += ");\n"
+ return text
+
+
+class VkHandle(object):
+ def __init__(self, name, _type, parent):
+ self.name = name
+ self.type = _type
+ self.parent = parent
+ self.required = False
+
+ @staticmethod
+ def from_xml(handle):
+ name = handle.find("name").text
+ _type = handle.find("type").text
+ parent = handle.attrib.get("parent") # Most objects have a parent e.g. VkQueue has VkDevice.
+ return VkHandle(name, _type, parent)
+
+ def definition(self):
+ """ Generates handle definition e.g. VK_DEFINE_HANDLE(vkInstance) """
+ return "{0}({1})\n".format(self.type, self.name)
+
+ def is_dispatchable(self):
+ """ Some handles like VkInstance, VkDevice are dispatchable objects,
+ which means they contain a dispatch table of function pointers.
+ """
+ return self.type == "VK_DEFINE_HANDLE"
+
+
+class VkMember(object):
+ def __init__(self, const=None, _type=None, pointer=None, name=None, array_len=None, dyn_array_len=None, optional=False,
+ extension_structs=None):
+ self.const = const
+ self.name = name
+ self.pointer = pointer
+ self.type = _type
+ self.type_info = None
+ self.array_len = array_len
+ self.dyn_array_len = dyn_array_len
+ self.optional = optional
+ self.extension_structs = extension_structs
+
+ def __eq__(self, other):
+ """ Compare member based on name against a string.
+
+ This method is for convenience by VkStruct, which holds a number of members and needs quick checking
+ if certain members exist.
+ """
+
+ if self.name == other:
+ return True
+
+ return False
+
+ def __repr__(self):
+ return "{0} {1} {2} {3} {4} {5}".format(self.const, self.type, self.pointer, self.name, self.array_len,
+ self.dyn_array_len)
+
+ @staticmethod
+ def from_xml(member):
+ """ Helper function for parsing a member tag within a struct or union. """
+
+ name_elem = member.find("name")
+ type_elem = member.find("type")
+
+ const = member.text.strip() if member.text else None
+ member_type = None
+ pointer = None
+ array_len = None
+
+ if type_elem is not None:
+ member_type = type_elem.text
+ if type_elem.tail is not None:
+ pointer = type_elem.tail.strip() if type_elem.tail.strip() != "" else None
+
+ # Name of other member within, which stores the number of
+ # elements pointed to be by this member.
+ dyn_array_len = member.get("len", None)
+
+ if "validextensionstructs" in member.attrib:
+ extension_structs = member.get("validextensionstructs").split(",")
+ else:
+ extension_structs = None
+
+ # Some members are optional, which is important for conversion code e.g. not dereference NULL pointer.
+ optional = True if member.get("optional") else False
+
+ # Usually we need to allocate memory for dynamic arrays. We need to do the same in a few other cases
+ # like for VkCommandBufferBeginInfo.pInheritanceInfo. Just threat such cases as dynamic arrays of
+ # size 1 to simplify code generation.
+ if dyn_array_len is None and pointer is not None:
+ dyn_array_len = 1
+
+ # Some members are arrays, attempt to parse these. Formats include:
+ # charextensionName[VK_MAX_EXTENSION_NAME_SIZE]
+ # uint32_tfoo[4]
+ if name_elem.tail and name_elem.tail[0] == '[':
+ LOGGER.debug("Found array type")
+ enum_elem = member.find("enum")
+ if enum_elem is not None:
+ array_len = enum_elem.text
+ else:
+ # Remove brackets around length
+ array_len = name_elem.tail.strip("[]")
+
+ return VkMember(const=const, _type=member_type, pointer=pointer, name=name_elem.text, array_len=array_len,
+ dyn_array_len=dyn_array_len, optional=optional, extension_structs=extension_structs)
+
+ def definition(self, align=False, conv=False):
+ """ Generate prototype for given function.
+
+ Args:
+ align (bool, optional): Enable alignment if a type needs it. This adds WINE_VK_ALIGN(8) to a member.
+ conv (bool, optional): Enable conversion if a type needs it. This appends '_host' to the name.
+ """
+
+ text = ""
+ if self.is_const():
+ text += "const "
+
+ if conv and self.is_struct():
+ text += "{0}_host".format(self.type)
+ else:
+ text += self.type
+
+ if self.is_pointer():
+ text += " {0}{1}".format(self.pointer, self.name)
+ else:
+ if align and self.needs_alignment():
+ text += " WINE_VK_ALIGN(8) " + self.name
+ else:
+ text += " " + self.name
+
+ if self.is_static_array():
+ text += "[{0}]".format(self.array_len)
+
+ return text
+
+ def is_const(self):
+ return self.const is not None
+
+ def is_dynamic_array(self):
+ """ Returns if the member is an array element.
+ Vulkan uses this for dynamically sized arrays for which
+ there is a 'count' parameter.
+ """
+ return self.dyn_array_len is not None
+
+ def is_handle(self):
+ return self.type_info["category"] == "handle"
+
+ def is_pointer(self):
+ return self.pointer is not None
+
+ def is_static_array(self):
+ """ Returns if the member is an array.
+ Vulkan uses this often for fixed size arrays in which the
+ length is part of the member.
+ """
+ return self.array_len is not None
+
+ def is_struct(self):
+ return self.type_info["category"] == "struct"
+
+ def is_union(self):
+ return self.type_info["category"] == "union"
+
+ def needs_alignment(self):
+ """ Check if this member needs alignment for 64-bit data.
+ Various structures need alignment on 64-bit variables due
+ to compiler differences on 32-bit between Win32 and Linux.
+ """
+
+ if self.is_pointer():
+ return False
+ elif self.type == "size_t":
+ return False
+ elif self.type in ["uint64_t", "VkDeviceSize"]:
+ return True
+ elif self.is_struct():
+ struct = self.type_info["data"]
+ return struct.needs_alignment()
+ elif self.is_handle():
+ # Dispatchable handles are pointers to objects, while
+ # non-dispatchable are uint64_t and hence need alignment.
+ handle = self.type_info["data"]
+ return False if handle.is_dispatchable() else True
+ return False
+
+ def set_type_info(self, type_info):
+ """ Helper function to set type information from the type registry.
+ This is needed, because not all type data is available at time of
+ parsing.
+ """
+ self.type_info = type_info
+
+
+class VkParam(object):
+ """ Helper class which describes a parameter to a function call. """
+
+ def __init__(self, type_info, const=None, pointer=None, name=None, array_len=None, dyn_array_len=None):
+ self.const = const
+ self.name = name
+ self.array_len = array_len
+ self.dyn_array_len = dyn_array_len
+ self.pointer = pointer
+ self.type_info = type_info
+ self.type = type_info["name"] # For convenience
+ self.handle = type_info["data"] if type_info["category"] == "handle" else None
+ self.struct = type_info["data"] if type_info["category"] == "struct" else None
+
+ def __repr__(self):
+ return "{0} {1} {2} {3} {4}".format(self.const, self.type, self.pointer, self.name, self.array_len, self.dyn_array_len)
+
+ @staticmethod
+ def from_xml(param, types):
+ """ Helper function to create VkParam from xml. """
+
+ # Parameter parsing is slightly tricky. All the data is contained within
+ # a param tag, but some data is within subtags while others are text
+ # before or after the type tag.
+ # Common structure:
+ # const char* pLayerName
+
+ name_elem = param.find("name")
+ array_len = None
+ name = name_elem.text
+ # Tail contains array length e.g. for blendConstants param of vkSetBlendConstants
+ if name_elem.tail is not None:
+ array_len = name_elem.tail.strip("[]")
+
+ # Name of other parameter in function prototype, which stores the number of
+ # elements pointed to be by this parameter.
+ dyn_array_len = param.get("len", None)
+
+ const = param.text.strip() if param.text else None
+ type_elem = param.find("type")
+ pointer = type_elem.tail.strip() if type_elem.tail.strip() != "" else None
+
+ # Since we have parsed all types before hand, this should not happen.
+ type_info = types.get(type_elem.text, None)
+ if type_info is None:
+ LOGGER.err("type info not found for: {0}".format(type_elem.text))
+
+ return VkParam(type_info, const=const, pointer=pointer, name=name, array_len=array_len, dyn_array_len=dyn_array_len)
+
+ def definition(self, postfix=None):
+ """ Return prototype for the parameter. E.g. 'const char *foo' """
+
+ proto = ""
+ if self.const:
+ proto += self.const + " "
+
+ proto += self.type
+
+ if self.is_pointer():
+ proto += " {0}{1}".format(self.pointer, self.name)
+ else:
+ proto += " " + self.name
+
+ # Allows appeninding something to the variable name useful for
+ # win32 to host conversion.
+ if postfix is not None:
+ proto += postfix
+
+ if self.is_static_array():
+ proto += "[{0}]".format(self.array_len)
+
+ return proto
+
+ def is_const(self):
+ return self.const is not None
+
+ def is_dynamic_array(self):
+ return self.dyn_array_len is not None
+
+ def is_dispatchable(self):
+ if not self.is_handle():
+ return False
+
+ return self.handle.is_dispatchable()
+
+ def is_handle(self):
+ return self.handle is not None
+
+ def is_pointer(self):
+ return self.pointer is not None
+
+ def is_static_array(self):
+ return self.array_len is not None
+
+ def is_struct(self):
+ return self.struct is not None
+
+
+class VkStruct(Sequence):
+ """ Class which represents the type union and struct. """
+
+ def __init__(self, name, members, returnedonly, union=False):
+ self.name = name
+ self.members = members
+ self.returnedonly = returnedonly
+ self.required = False
+ self.union = union
+ self.type_info = None # To be set later.
+
+ def __getitem__(self, i):
+ return self.members[i]
+
+ def __len__(self):
+ return len(self.members)
+
+ @staticmethod
+ def from_xml(struct):
+ # Unions and structs are the same parsing wise, but we need to
+ # know which one we are dealing with later on for code generation.
+ union = True if struct.attrib["category"] == "union" else False
+
+ name = struct.attrib.get("name", None)
+
+ # 'Output' structures for which data is filled in by the API are
+ # marked as 'returnedonly'.
+ returnedonly = True if struct.attrib.get("returnedonly") else False
+
+ members = []
+ for member in struct.findall("member"):
+ vk_member = VkMember.from_xml(member)
+ members.append(vk_member)
+
+ return VkStruct(name, members, returnedonly, union=union)
+
+ @staticmethod
+ def decouple_structs(structs):
+ """ Helper function which decouples a list of structs.
+ Structures often depend on other structures. To make the C compiler
+ happy we need to define 'substructures' first. This function analyzes
+ the list of structures and reorders them in such a way that they are
+ decoupled.
+ """
+
+ tmp_structs = list(structs) # Don't modify the original structures.
+ decoupled_structs = []
+
+ while (len(tmp_structs) > 0):
+ for struct in tmp_structs:
+ dependends = False
+
+ if not struct.required:
+ tmp_structs.remove(struct)
+ continue
+
+ for m in struct:
+ if not (m.is_struct() or m.is_union()):
+ continue
+
+ found = False
+ # Check if a struct we depend on has already been defined.
+ for s in decoupled_structs:
+ if s.name == m.type:
+ found = True
+ break
+
+ if not found:
+ # Check if the struct we depend on is even in the list of structs.
+ # If found now, it means we haven't met all dependencies before we
+ # can operate on the current struct.
+ # When generating 'host' structs we may not be able to find a struct
+ # as the list would only contain the structs requiring conversion.
+ for s in tmp_structs:
+ if s.name == m.type:
+ dependends = True
+ break
+
+ if dependends == False:
+ decoupled_structs.append(struct)
+ tmp_structs.remove(struct)
+
+ return decoupled_structs
+
+ def definition(self, align=False, conv=False, postfix=None):
+ """ Convert structure to textual definition.
+
+ Args:
+ align (bool, optional): enable alignment to 64-bit for win32 struct compatibility.
+ conv (bool, optional): enable struct conversion if the struct needs it.
+ postfix (str, optional): text to append to end of struct name, useful for struct renaming.
+ """
+
+ if self.union:
+ text = "typedef union {0}".format(self.name)
+ else:
+ text = "typedef struct {0}".format(self.name)
+
+ if postfix is not None:
+ text += postfix
+
+ text += "\n{\n"
+
+ for m in self:
+ if align and m.needs_alignment():
+ text += " {0};\n".format(m.definition(align=align))
+ elif conv and m.needs_conversion():
+ text += " {0};\n".format(m.definition(conv=conv))
+ else:
+ text += " {0};\n".format(m.definition())
+
+ if postfix is not None:
+ text += "}} {0}{1};\n\n".format(self.name, postfix)
+ else:
+ text += "}} {0};\n\n".format(self.name)
+ return text
+
+ def needs_alignment(self):
+ """ Check if structure needs alignment for 64-bit data.
+ Various structures need alignment on 64-bit variables due
+ to compiler differences on 32-bit between Win32 and Linux.
+ """
+
+ for m in self.members:
+ if m.needs_alignment():
+ return True
+ return False
+
+ def set_type_info(self, types):
+ """ Helper function to set type information from the type registry.
+ This is needed, because not all type data is available at time of
+ parsing.
+ """
+ for m in self.members:
+ type_info = types[m.type]
+ m.set_type_info(type_info)
+
+
+class VkGenerator(object):
+ def __init__(self, registry):
+ self.registry = registry
+
+ def generate_vulkan_h(self, f):
+ f.write("/* Automatically generated from Vulkan vk.xml; DO NOT EDIT! */\n\n")
+ f.write("#ifndef __WINE_VULKAN_H\n")
+ f.write("#define __WINE_VULKAN_H\n\n")
+
+ f.write("#include \n")
+ f.write("#include \n\n")
+
+ f.write("#ifndef VKAPI_CALL\n")
+ f.write("#define VKAPI_CALL __stdcall\n")
+ f.write("#endif\n\n")
+
+ f.write("#ifndef VKAPI_PTR\n")
+ f.write("#define VKAPI_PTR VKAPI_CALL\n")
+ f.write("#endif\n\n")
+
+ f.write("/* Callers can override WINE_VK_ALIGN if they want 'host' headers. */\n")
+ f.write("#ifndef WINE_VK_ALIGN\n")
+ f.write("#define WINE_VK_ALIGN DECLSPEC_ALIGN\n")
+ f.write("#endif\n\n")
+
+ # The overall strategy is to define independent constants and datatypes,
+ # prior to complex structures and function calls to avoid forward declarations.
+ for const in self.registry.consts:
+ # For now just generate things we may not need. The amount of parsing needed
+ # to get some of the info is tricky as you need to figure out which structure
+ # references a certain constant.
+ f.write(const.definition())
+ f.write("\n")
+
+ for define in self.registry.defines:
+ f.write(define.definition())
+
+ for handle in self.registry.handles:
+ if handle.required:
+ f.write(handle.definition())
+ f.write("\n")
+
+ for base_type in self.registry.base_types:
+ f.write(base_type.definition())
+ f.write("\n")
+
+ for bitmask in self.registry.bitmasks:
+ f.write(bitmask.definition())
+ f.write("\n")
+
+ # Define enums, this includes values for some of the bitmask types as well.
+ for enum in self.registry.enums.values():
+ if enum.required:
+ f.write(enum.definition())
+
+ for fp in self.registry.funcpointers:
+ if fp.required:
+ f.write(fp.definition())
+ f.write("\n")
+
+ # This generates both structures and unions. Since structures
+ # may depend on other structures/unions, we need a list of
+ # decoupled structs.
+ # Note: unions are stored in structs for dependency reasons,
+ # see comment in parsing section.
+ structs = VkStruct.decouple_structs(self.registry.structs)
+ for struct in structs:
+ LOGGER.debug("Generating struct: {0}".format(struct.name))
+ f.write(struct.definition(align=True))
+
+ for func in self.registry.funcs.values():
+ if not func.is_required():
+ LOGGER.debug("Skipping API definition for: {0}".format(func.name))
+ continue
+
+ LOGGER.debug("Generating API definition for: {0}".format(func.name))
+ f.write("{0};\n".format(func.prototype(call_conv="VKAPI_CALL")))
+ f.write("\n")
+
+ f.write("#endif /* __WINE_VULKAN_H */\n")
+
+
+class VkRegistry(object):
+ def __init__(self, reg_filename):
+ # Used for storage of type information.
+ self.base_types = None
+ self.bitmasks = None
+ self.consts = None
+ self.defines = None
+ self.enums = None
+ self.funcpointers = None
+ self.handles = None
+ self.structs = None
+
+ # We aggregate all types in here for cross-referencing.
+ self.funcs = {}
+ self.types = {}
+
+ # Overall strategy for parsing the registry is to first
+ # parse all type / function definitions. Then parse
+ # features and extensions to decide which types / functions
+ # to actually 'pull in' for code generation. For each type or
+ # function call we want we set a member 'required' to True.
+ tree = ET.parse(reg_filename)
+ root = tree.getroot()
+ self._parse_enums(root)
+ self._parse_types(root)
+ self._parse_commands(root)
+
+ # Pull in any required types and functions.
+ self._parse_features(root)
+
+ def _mark_command_required(self, command):
+ """ Helper function to mark a certain command and the datatypes it needs as required."""
+ def mark_bitmask_dependencies(bitmask, types):
+ if bitmask.requires is not None:
+ types[bitmask.requires]["data"].required = True
+
+ def mark_funcpointer_dependencies(fp, types):
+ for m in fp.members:
+ type_info = types[m.type]
+
+ # Complex types have a matching definition e.g. VkStruct.
+ # Not needed for base types such as uint32_t.
+ if "data" in type_info:
+ types[m.type]["data"].required = True
+
+ def mark_struct_dependencies(struct, types):
+ for m in struct:
+ type_info = types[m.type]
+
+ # Complex types have a matching definition e.g. VkStruct.
+ # Not needed for base types such as uint32_t.
+ if "data" in type_info:
+ types[m.type]["data"].required = True
+
+ if type_info["category"] == "struct":
+ # Yay, recurse
+ mark_struct_dependencies(type_info["data"], types)
+ elif type_info["category"] == "funcpointer":
+ mark_funcpointer_dependencies(type_info["data"], types)
+ elif type_info["category"] == "bitmask":
+ mark_bitmask_dependencies(type_info["data"], types)
+
+ func = self.funcs[command]
+ func.required = True
+
+ # Pull in return type
+ if func.type != "void":
+ self.types[func.type]["data"].required = True
+
+ # Analyze parameter dependencies and pull in any type needed.
+ for p in func.params:
+ type_info = self.types[p.type]
+
+ # Check if we are dealing with a complex type e.g. VkEnum, VkStruct and others.
+ if "data" not in type_info:
+ continue
+
+ # Mark the complex type as required.
+ type_info["data"].required = True
+ if type_info["category"] == "struct":
+ struct = type_info["data"]
+ mark_struct_dependencies(struct, self.types)
+
+ def _parse_commands(self, root):
+ """ Parse command section containing the Vulkan function calls. """
+ funcs = {}
+ commands = root.findall("./commands/")
+ for command in commands:
+ func = VkFunction.from_xml(command, self.types)
+ funcs[func.name] = func
+
+ # To make life easy for the code generation, separate all function
+ # calls out in the 3 types of vulkan functions: device, global and instance.
+ device_funcs = []
+ global_funcs = []
+ instance_funcs = []
+ for func in funcs.values():
+ if func.is_device_func():
+ device_funcs.append(func)
+ elif func.is_global_func():
+ global_funcs.append(func)
+ else:
+ instance_funcs.append(func)
+
+ # Sort function lists by name and store them.
+ self.device_funcs = sorted(device_funcs, key=lambda func: func.name)
+ self.global_funcs = sorted(global_funcs, key=lambda func: func.name)
+ self.instance_funcs = sorted(instance_funcs, key=lambda func: func.name)
+
+ # The funcs dictionary is used as a convenient way to lookup function
+ # calls when needed e.g. to adjust member variables.
+ self.funcs = OrderedDict(sorted(funcs.items()))
+
+ def _parse_enums(self, root):
+ """ Parse enums section or better described as constants section. """
+ enums = {}
+ self.consts = []
+ for enum in root.findall("./enums"):
+ name = enum.attrib.get("name")
+ _type = enum.attrib.get("type")
+
+ if _type in ("enum", "bitmask"):
+ enums[name] = VkEnum.from_xml(enum)
+ else:
+ # If no type is set, we are dealing with API constants.
+ values = []
+ for value in enum.findall("enum"):
+ self.consts.append(VkConstant(value.attrib.get("name"), value.attrib.get("value")))
+
+ self.enums = OrderedDict(sorted(enums.items()))
+
+ def _parse_features(self, root):
+ """ Parse the feature section, which describes Core commands and types needed. """
+ requires = root.findall("./feature/require")
+
+ for require in requires:
+ LOGGER.info("Including features for {0}".format(require.attrib.get("comment")))
+ for tag in require:
+ # Only deal with command. Other values which appear are enum and type for pulling in some
+ # constants and macros. Tricky to parse, so don't bother right now, we will generate them
+ # anyway for now.
+ name = tag.attrib["name"]
+ if tag.tag == "command":
+ self._mark_command_required(name)
+ elif tag.tag == "enum":
+ # We could pull in relevant constants here. Unfortunately
+ # this only gets half of them pulled in as others indirectly
+ # get pulled in through structures. Constants don't harm us,
+ # so don't bother.
+ pass
+ elif tag.tag == "type":
+ # Pull in types which may not have been pulled in through commands.
+
+ # Skip pull in for vk_platform.h for now.
+ if name == "vk_platform":
+ continue
+
+ type_info = self.types[name]
+ type_info["data"].required = True
+
+ def _parse_types(self, root):
+ """ Parse types section, which contains all data types e.g. structs, typedefs etcetera. """
+ types = root.findall("./types/type")
+
+ base_types = []
+ bitmasks = []
+ defines = []
+ funcpointers = []
+ handles = []
+ structs = []
+
+ for t in types:
+ type_info = {}
+ type_info["category"] = t.attrib.get("category", None)
+
+ if type_info["category"] in ["include"]:
+ continue
+
+ if type_info["category"] == "basetype":
+ name = t.find("name").text
+ _type = t.find("type").text
+ basetype = VkBaseType(name, _type)
+ base_types.append(basetype)
+ type_info["data"] = basetype
+
+ if type_info["category"] == "bitmask":
+ name = t.find("name").text
+ _type = t.find("type").text
+
+ # Most bitmasks have a requires attribute used to pull in
+ # required '*FlagBits" enum.
+ requires = t.attrib.get("requires")
+ bitmask = VkBaseType(name, _type, requires=requires)
+ bitmasks.append(bitmask)
+ type_info["data"] = bitmask
+
+ if type_info["category"] == "define":
+ name = t.attrib.get("name")
+ define = VkDefine.from_xml(t)
+ defines.append(define)
+ type_info["data"] = define
+
+ if type_info["category"] == "enum":
+ name = t.attrib.get("name")
+ # The type section only contains enum names, not the actual definition.
+ # Since we already parsed the enum before, just link it in.
+ try:
+ type_info["data"] = self.enums[name]
+ except KeyError as e:
+ # Not all enums seem to be defined yet, typically that's for
+ # ones ending in 'FlagBits' where future extensions may add
+ # definitions.
+ type_info["data"] = None
+
+ if type_info["category"] == "funcpointer":
+ funcpointer = VkFunctionPointer.from_xml(t)
+ funcpointers.append(funcpointer)
+ type_info["data"] = funcpointer
+
+ if type_info["category"] == "handle":
+ handle = VkHandle.from_xml(t)
+ handles.append(handle)
+ type_info["data"] = handle
+
+ if type_info["category"] in ["struct", "union"]:
+ # We store unions among structs as some structs depend
+ # on unions. The types are very similar in parsing and
+ # generation anyway. The official vulkan scripts use
+ # a similar kind of hack.
+ struct = VkStruct.from_xml(t)
+ structs.append(struct)
+ type_info["data"] = struct
+
+ # Name is in general within a name tag else it is an optional
+ # attribute on the type tag.
+ name_elem = t.find("name")
+ if name_elem is not None:
+ type_info["name"] = name_elem.text
+ else:
+ type_info["name"] = t.attrib.get("name", None)
+
+ # Store all type data in a shared dictionary, so we can easily
+ # look up information for a given type. There are no duplicate
+ # names.
+ self.types[type_info["name"]] = type_info
+
+ # We need detailed type information during code generation
+ # on structs for alignment reasons. Unfortunately structs
+ # are parsed among other types, so there is no guarantee
+ # that any types needed have been parsed already, so set
+ # the data now.
+ for struct in structs:
+ struct.set_type_info(self.types)
+
+ # Guarantee everything is sorted, so code generation doesn't have
+ # to deal with this.
+ self.base_types = sorted(base_types, key=lambda base_type: base_type.name)
+ self.bitmasks = sorted(bitmasks, key=lambda bitmask: bitmask.name)
+ self.defines = defines
+ self.funcpointers = sorted(funcpointers, key=lambda fp: fp.name)
+ self.handles = sorted(handles, key=lambda handle: handle.name)
+ self.structs = sorted(structs, key=lambda struct: struct.name)
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
+
+ args = parser.parse_args()
+ if args.verbose == 0:
+ LOGGER.setLevel(logging.WARNING)
+ elif args.verbose == 1:
+ LOGGER.setLevel(logging.INFO)
+ else: # > 1
+ LOGGER.setLevel(logging.DEBUG)
+
+ registry = VkRegistry("vk.xml")
+ generator = VkGenerator(registry)
+
+ with open(WINE_VULKAN_H, "w") as f:
+ generator.generate_vulkan_h(f)
+
+if __name__ == "__main__":
+ main()
diff --git a/dlls/winevulkan/vk.xml b/dlls/winevulkan/vk.xml
new file mode 100644
index 00000000000..e013ce8b603
--- /dev/null
+++ b/dlls/winevulkan/vk.xml
@@ -0,0 +1,6514 @@
+
+
+
+Copyright (c) 2015-2017 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+------------------------------------------------------------------------
+
+This file, vk.xml, is the Vulkan API Registry. It is a critically important
+and normative part of the Vulkan Specification, including a canonical
+machine-readable definition of the API, parameter and member validation
+language incorporated into the Specification and reference pages, and other
+material which is registered by Khronos, such as tags used by extension and
+layer authors. The only authoritative version of vk.xml is the one
+maintained in the master branch of the Khronos Vulkan GitHub project.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ #include "vk_platform.h"
+
+ #include "vulkan.h"
+ #include <X11/Xlib.h>
+ #include <X11/extensions/Xrandr.h>
+ #include <android/native_window.h>
+ #include <mir_toolkit/client_types.h>
+ #include <wayland-client.h>
+ #include <windows.h>
+ #include <xcb/xcb.h>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ #define VK_MAKE_VERSION(major, minor, patch) \
+ (((major) << 22) | ((minor) << 12) | (patch))
+ #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
+ #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
+ #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
+
+ // 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)
+ // Vulkan 1.0 version number
+#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
+ // Version of this file
+#define VK_HEADER_VERSION 51
+
+
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+
+
+#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+ #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
+
+
+
+#define VK_NULL_HANDLE 0
+
+
+ typedef uint32_t VkSampleMask;
+ typedef uint32_t VkBool32;
+ typedef uint32_t VkFlags;
+ typedef uint64_t VkDeviceSize;
+
+
+
+
+
+
+
+
+
+
+
+ typedef VkFlags VkFramebufferCreateFlags;
+ typedef VkFlags VkQueryPoolCreateFlags;
+ typedef VkFlags VkRenderPassCreateFlags;
+ typedef VkFlags VkSamplerCreateFlags;
+ typedef VkFlags VkPipelineLayoutCreateFlags;
+ typedef VkFlags VkPipelineCacheCreateFlags;
+ typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+ typedef VkFlags VkPipelineDynamicStateCreateFlags;
+ typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+ typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+ typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+ typedef VkFlags VkPipelineViewportStateCreateFlags;
+ typedef VkFlags VkPipelineTessellationStateCreateFlags;
+ typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+ typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+ typedef VkFlags VkPipelineShaderStageCreateFlags;
+ typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+ typedef VkFlags VkBufferViewCreateFlags;
+ typedef VkFlags VkInstanceCreateFlags;
+ typedef VkFlags VkDeviceCreateFlags;
+ typedef VkFlags VkDeviceQueueCreateFlags;
+ typedef VkFlags VkQueueFlags;
+ typedef VkFlags VkMemoryPropertyFlags;
+ typedef VkFlags VkMemoryHeapFlags;
+ typedef VkFlags VkAccessFlags;
+ typedef VkFlags VkBufferUsageFlags;
+ typedef VkFlags VkBufferCreateFlags;
+ typedef VkFlags VkShaderStageFlags;
+ typedef VkFlags VkImageUsageFlags;
+ typedef VkFlags VkImageCreateFlags;
+ typedef VkFlags VkImageViewCreateFlags;
+ typedef VkFlags VkPipelineCreateFlags;
+ typedef VkFlags VkColorComponentFlags;
+ typedef VkFlags VkFenceCreateFlags;
+ typedef VkFlags VkSemaphoreCreateFlags;
+ typedef VkFlags VkFormatFeatureFlags;
+ typedef VkFlags VkQueryControlFlags;
+ typedef VkFlags VkQueryResultFlags;
+ typedef VkFlags VkShaderModuleCreateFlags;
+ typedef VkFlags VkEventCreateFlags;
+ typedef VkFlags VkCommandPoolCreateFlags;
+ typedef VkFlags VkCommandPoolResetFlags;
+ typedef VkFlags VkCommandBufferResetFlags;
+ typedef VkFlags VkCommandBufferUsageFlags;
+ typedef VkFlags VkQueryPipelineStatisticFlags;
+ typedef VkFlags VkMemoryMapFlags;
+ typedef VkFlags VkImageAspectFlags;
+ typedef VkFlags VkSparseMemoryBindFlags;
+ typedef VkFlags VkSparseImageFormatFlags;
+ typedef VkFlags VkSubpassDescriptionFlags;
+ typedef VkFlags VkPipelineStageFlags;
+ typedef VkFlags VkSampleCountFlags;
+ typedef VkFlags VkAttachmentDescriptionFlags;
+ typedef VkFlags VkStencilFaceFlags;
+ typedef VkFlags VkCullModeFlags;
+ typedef VkFlags VkDescriptorPoolCreateFlags;
+ typedef VkFlags VkDescriptorPoolResetFlags;
+ typedef VkFlags VkDependencyFlags;
+
+ typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
+ typedef VkFlags VkObjectEntryUsageFlagsNVX;
+
+ typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
+
+ typedef VkFlags VkCompositeAlphaFlagsKHR;
+ typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+ typedef VkFlags VkSurfaceTransformFlagsKHR;
+ typedef VkFlags VkSwapchainCreateFlagsKHR;
+ typedef VkFlags VkDisplayModeCreateFlagsKHR;
+ typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+ typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+ typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+ typedef VkFlags VkViSurfaceCreateFlagsNN;
+ typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+ typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+ typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+ typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+ typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+ typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+ typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
+ typedef VkFlags VkMemoryAllocateFlagsKHX;
+ typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
+
+ typedef VkFlags VkDebugReportFlagsEXT;
+ typedef VkFlags VkCommandPoolTrimFlagsKHR;
+ typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
+ typedef VkFlags VkExternalMemoryFeatureFlagsNV;
+ typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX;
+ typedef VkFlags VkExternalMemoryFeatureFlagsKHX;
+ typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX;
+ typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX;
+ typedef VkFlags VkSurfaceCounterFlagsEXT;
+ typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
+ typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
+
+
+ VK_DEFINE_HANDLE(VkInstance)
+ VK_DEFINE_HANDLE(VkPhysicalDevice)
+ VK_DEFINE_HANDLE(VkDevice)
+ VK_DEFINE_HANDLE(VkQueue)
+ VK_DEFINE_HANDLE(VkCommandBuffer)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
+
+
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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_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_vkVoidFunction)(void);
+
+
+ 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);
+
+
+
+ int32_t x
+ int32_t y
+
+
+ int32_t x
+ int32_t y
+ int32_t z
+
+
+ uint32_t width
+ uint32_t height
+
+
+ uint32_t width
+ uint32_t height
+ uint32_t depth
+
+
+ float x
+ float y
+ float width
+ float height
+ float minDepth
+ float maxDepth
+
+
+ VkOffset2D offset
+ VkExtent2D extent
+
+
+ VkOffset3D offset
+ VkExtent3D extent
+
+
+ VkRect2D rect
+ uint32_t baseArrayLayer
+ uint32_t layerCount
+
+
+ VkComponentSwizzle r
+ VkComponentSwizzle g
+ VkComponentSwizzle b
+ VkComponentSwizzle a
+
+
+ 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
+
+
+ char extensionName[VK_MAX_EXTENSION_NAME_SIZE]
+ uint32_t specVersion
+
+
+ char layerName[VK_MAX_EXTENSION_NAME_SIZE]
+ uint32_t specVersion
+ uint32_t implementationVersion
+ char description[VK_MAX_DESCRIPTION_SIZE]
+
+
+ VkStructureType sType
+ const void* pNext
+ const char* pApplicationName
+ uint32_t applicationVersion
+ const char* pEngineName
+ uint32_t engineVersion
+ uint32_t apiVersion
+
+
+ void* pUserData
+ PFN_vkAllocationFunction pfnAllocation
+ PFN_vkReallocationFunction pfnReallocation
+ PFN_vkFreeFunction pfnFree
+ PFN_vkInternalAllocationNotification pfnInternalAllocation
+ PFN_vkInternalFreeNotification pfnInternalFree
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDeviceQueueCreateFlags flags
+ uint32_t queueFamilyIndex
+ uint32_t queueCount
+ const float* pQueuePriorities
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkInstanceCreateFlags flags
+ const VkApplicationInfo* pApplicationInfo
+ uint32_t enabledLayerCount
+ const char* const* ppEnabledLayerNames
+ uint32_t enabledExtensionCount
+ const char* const* ppEnabledExtensionNames
+
+
+ VkQueueFlags queueFlags
+ uint32_t queueCount
+ uint32_t timestampValidBits
+ VkExtent3D minImageTransferGranularity
+
+
+ uint32_t memoryTypeCount
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]
+ uint32_t memoryHeapCount
+ VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDeviceSize allocationSize
+ uint32_t memoryTypeIndex
+
+
+ VkDeviceSize size
+ VkDeviceSize alignment
+ uint32_t memoryTypeBits
+
+
+ VkImageAspectFlags aspectMask
+ VkExtent3D imageGranularity
+ VkSparseImageFormatFlags flags
+
+
+ VkSparseImageFormatProperties formatProperties
+ uint32_t imageMipTailFirstLod
+ VkDeviceSize imageMipTailSize
+ VkDeviceSize imageMipTailOffset
+ VkDeviceSize imageMipTailStride
+
+
+ VkMemoryPropertyFlags propertyFlags
+ uint32_t heapIndex
+
+
+ VkDeviceSize size
+ VkMemoryHeapFlags flags
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDeviceMemory memory
+ VkDeviceSize offset
+ VkDeviceSize size
+
+
+ VkFormatFeatureFlags linearTilingFeatures
+ VkFormatFeatureFlags optimalTilingFeatures
+ VkFormatFeatureFlags bufferFeatures
+
+
+ VkExtent3D maxExtent
+ uint32_t maxMipLevels
+ uint32_t maxArrayLayers
+ VkSampleCountFlags sampleCounts
+ VkDeviceSize maxResourceSize
+
+
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkDeviceSize range
+
+
+ VkSampler sampler
+ VkImageView imageView
+ VkImageLayout imageLayout
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDescriptorSet srcSet
+ uint32_t srcBinding
+ uint32_t srcArrayElement
+ VkDescriptorSet dstSet
+ uint32_t dstBinding
+ uint32_t dstArrayElement
+ uint32_t descriptorCount
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBufferCreateFlags flags
+ VkDeviceSize size
+ VkBufferUsageFlags usage
+ VkSharingMode sharingMode
+ uint32_t queueFamilyIndexCount
+ const uint32_t* pQueueFamilyIndices
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBufferViewCreateFlagsflags
+ VkBuffer buffer
+ VkFormat format
+ VkDeviceSize offset
+ VkDeviceSize range
+
+
+ VkImageAspectFlags aspectMask
+ uint32_t mipLevel
+ uint32_t arrayLayer
+
+
+ VkImageAspectFlags aspectMask
+ uint32_t mipLevel
+ uint32_t baseArrayLayer
+ uint32_t layerCount
+
+
+ VkImageAspectFlags aspectMask
+ uint32_t baseMipLevel
+ uint32_t levelCount
+ uint32_t baseArrayLayer
+ uint32_t layerCount
+
+
+ VkStructureType sType
+ const void* pNext
+ VkAccessFlags srcAccessMask
+ VkAccessFlags dstAccessMask
+
+
+ VkStructureType sType
+ const void* pNext
+ VkAccessFlags srcAccessMask
+ VkAccessFlags dstAccessMask
+ uint32_t srcQueueFamilyIndex
+ uint32_t dstQueueFamilyIndex
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkDeviceSize size
+
+
+ VkStructureType sType
+ const void* pNext
+ VkAccessFlags srcAccessMask
+ VkAccessFlags dstAccessMask
+ VkImageLayout oldLayout
+ VkImageLayout newLayout
+ uint32_t srcQueueFamilyIndex
+ uint32_t dstQueueFamilyIndex
+ VkImage image
+ VkImageSubresourceRange subresourceRange
+
+
+ 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
+
+
+ VkDeviceSize offset
+ VkDeviceSize size
+ VkDeviceSize rowPitch
+ VkDeviceSize arrayPitch
+ VkDeviceSize depthPitch
+
+
+ VkStructureType sType
+ const void* pNext
+ VkImageViewCreateFlags flags
+ VkImage image
+ VkImageViewType viewType
+ VkFormat format
+ VkComponentMapping components
+ VkImageSubresourceRange subresourceRange
+
+
+ VkDeviceSize srcOffset
+ VkDeviceSize dstOffset
+ VkDeviceSize size
+
+
+ VkDeviceSize resourceOffset
+ VkDeviceSize size
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+ VkSparseMemoryBindFlagsflags
+
+
+ VkImageSubresource subresource
+ VkOffset3D offset
+ VkExtent3D extent
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+ VkSparseMemoryBindFlagsflags
+
+
+ VkBuffer buffer
+ uint32_t bindCount
+ const VkSparseMemoryBind* pBinds
+
+
+ VkImage image
+ uint32_t bindCount
+ const VkSparseMemoryBind* pBinds
+
+
+ VkImage image
+ uint32_t bindCount
+ const VkSparseImageMemoryBind* pBinds
+
+
+ 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
+
+
+ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffset
+ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffset
+ VkExtent3D extent
+
+
+ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffsets[2]
+ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffsets[2]
+
+
+ VkDeviceSize bufferOffset
+ uint32_t bufferRowLength
+ uint32_t bufferImageHeight
+ VkImageSubresourceLayers imageSubresource
+ VkOffset3D imageOffset
+ VkExtent3D imageExtent
+
+
+ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffset
+ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffset
+ VkExtent3D extent
+
+
+ VkStructureType sType
+ const void* pNext
+ VkShaderModuleCreateFlags flags
+ size_t codeSize
+ const uint32_t* pCode
+
+
+ uint32_t binding
+ VkDescriptorType descriptorType
+ uint32_t descriptorCount
+ VkShaderStageFlags stageFlags
+ const VkSampler* pImmutableSamplers
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDescriptorSetLayoutCreateFlags flags
+ uint32_t bindingCount
+ const VkDescriptorSetLayoutBinding* pBindings
+
+
+ VkDescriptorType type
+ uint32_t descriptorCount
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDescriptorPoolCreateFlags flags
+ uint32_t maxSets
+ uint32_t poolSizeCount
+ const VkDescriptorPoolSize* pPoolSizes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDescriptorPool descriptorPool
+ uint32_t descriptorSetCount
+ const VkDescriptorSetLayout* pSetLayouts
+
+
+ uint32_t constantID
+ uint32_t offset
+ size_t size
+
+
+ uint32_t mapEntryCount
+ const VkSpecializationMapEntry* pMapEntries
+ size_t dataSize
+ const void* pData
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineShaderStageCreateFlags flags
+ VkShaderStageFlagBits stage
+ VkShaderModule module
+ const char* pName
+ const VkSpecializationInfo* pSpecializationInfo
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineCreateFlags flags
+ VkPipelineShaderStageCreateInfo stage
+ VkPipelineLayout layout
+ VkPipeline basePipelineHandle
+ int32_t basePipelineIndex
+
+
+ uint32_t binding
+ uint32_t stride
+ VkVertexInputRate inputRate
+
+
+ uint32_t location
+ uint32_t binding
+ VkFormat format
+ uint32_t offset
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineVertexInputStateCreateFlags flags
+ uint32_t vertexBindingDescriptionCount
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions
+ uint32_t vertexAttributeDescriptionCount
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineInputAssemblyStateCreateFlags flags
+ VkPrimitiveTopology topology
+ VkBool32 primitiveRestartEnable
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineTessellationStateCreateFlags flags
+ uint32_t patchControlPoints
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineViewportStateCreateFlags flags
+ uint32_t viewportCount
+ const VkViewport* pViewports
+ uint32_t scissorCount
+ const VkRect2D* pScissors
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineMultisampleStateCreateFlags flags
+ VkSampleCountFlagBits rasterizationSamples
+ VkBool32 sampleShadingEnable
+ float minSampleShading
+ const VkSampleMask* pSampleMask
+ VkBool32 alphaToCoverageEnable
+ VkBool32 alphaToOneEnable
+
+
+ VkBool32 blendEnable
+ VkBlendFactor srcColorBlendFactor
+ VkBlendFactor dstColorBlendFactor
+ VkBlendOp colorBlendOp
+ VkBlendFactor srcAlphaBlendFactor
+ VkBlendFactor dstAlphaBlendFactor
+ VkBlendOp alphaBlendOp
+ VkColorComponentFlags colorWriteMask
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineColorBlendStateCreateFlags flags
+ VkBool32 logicOpEnable
+ VkLogicOp logicOp
+ uint32_t attachmentCount
+ const VkPipelineColorBlendAttachmentState* pAttachments
+ float blendConstants[4]
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineDynamicStateCreateFlags flags
+ uint32_t dynamicStateCount
+ const VkDynamicState* pDynamicStates
+
+
+ VkStencilOp failOp
+ VkStencilOp passOp
+ VkStencilOp depthFailOp
+ VkCompareOp compareOp
+ uint32_t compareMask
+ uint32_t writeMask
+ uint32_t reference
+
+
+ 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
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineCacheCreateFlags flags
+ size_t initialDataSize
+ const void* pInitialData
+
+
+ VkShaderStageFlags stageFlags
+ uint32_t offset
+ uint32_t size
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineLayoutCreateFlags flags
+ uint32_t setLayoutCount
+ const VkDescriptorSetLayout* pSetLayouts
+ uint32_t pushConstantRangeCount
+ const VkPushConstantRange* pPushConstantRanges
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkCommandPoolCreateFlags flags
+ uint32_t queueFamilyIndex
+
+
+ VkStructureType sType
+ const void* pNext
+ VkCommandPool commandPool
+ VkCommandBufferLevel level
+ uint32_t commandBufferCount
+
+
+ VkStructureType sType
+ const void* pNext
+ VkRenderPass renderPass
+ uint32_t subpass
+ VkFramebuffer framebuffer
+ VkBool32 occlusionQueryEnable
+ VkQueryControlFlags queryFlags
+ VkQueryPipelineStatisticFlags pipelineStatistics
+
+
+ VkStructureType sType
+ const void* pNext
+ VkCommandBufferUsageFlags flags
+ const VkCommandBufferInheritanceInfo* pInheritanceInfo
+
+
+ VkStructureType sType
+ const void* pNext
+ VkRenderPass renderPass
+ VkFramebuffer framebuffer
+ VkRect2D renderArea
+ uint32_t clearValueCount
+ const VkClearValue* pClearValues
+
+
+ float float32[4]
+ int32_t int32[4]
+ uint32_t uint32[4]
+
+
+ float depth
+ uint32_t stencil
+
+
+ VkClearColorValue color
+ VkClearDepthStencilValue depthStencil
+
+
+ VkImageAspectFlags aspectMask
+ uint32_t colorAttachment
+ VkClearValue clearValue
+
+
+ VkAttachmentDescriptionFlags flags
+ VkFormat format
+ VkSampleCountFlagBits samples
+ VkAttachmentLoadOp loadOp
+ VkAttachmentStoreOp storeOp
+ VkAttachmentLoadOp stencilLoadOp
+ VkAttachmentStoreOp stencilStoreOp
+ VkImageLayout initialLayout
+ VkImageLayout finalLayout
+
+
+ uint32_t attachment
+ VkImageLayout layout
+
+
+ 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
+
+
+ uint32_t srcSubpass
+ uint32_t dstSubpass
+ VkPipelineStageFlags srcStageMask
+ VkPipelineStageFlags dstStageMask
+ VkAccessFlags srcAccessMask
+ VkAccessFlags dstAccessMask
+ VkDependencyFlags dependencyFlags
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkEventCreateFlags flags
+
+
+ VkStructureType sType
+ const void* pNext
+ VkFenceCreateFlags flags
+
+
+ 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
+
+
+ VkBool32 residencyStandard2DBlockShape
+ VkBool32 residencyStandard2DMultisampleBlockShape
+ VkBool32 residencyStandard3DBlockShape
+ VkBool32 residencyAlignedMipSize
+ VkBool32 residencyNonResidentStrict
+
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSemaphoreCreateFlags flags
+
+
+ VkStructureType sType
+ const void* pNext
+ VkQueryPoolCreateFlags flags
+ VkQueryType queryType
+ uint32_t queryCount
+ VkQueryPipelineStatisticFlags pipelineStatistics
+
+
+ VkStructureType sType
+ const void* pNext
+ VkFramebufferCreateFlags flags
+ VkRenderPass renderPass
+ uint32_t attachmentCount
+ const VkImageView* pAttachments
+ uint32_t width
+ uint32_t height
+ uint32_t layers
+
+
+ uint32_t vertexCount
+ uint32_t instanceCount
+ uint32_t firstVertex
+ uint32_t firstInstance
+
+
+ uint32_t indexCount
+ uint32_t instanceCount
+ uint32_t firstIndex
+ int32_t vertexOffset
+ uint32_t firstInstance
+
+
+ uint32_t x
+ uint32_t y
+ uint32_t z
+
+
+ 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
+
+
+
+ VkDisplayKHR display
+ const char* displayName
+ VkExtent2D physicalDimensions
+ VkExtent2D physicalResolution
+ VkSurfaceTransformFlagsKHR supportedTransforms
+ VkBool32 planeReorderPossible
+ VkBool32 persistentContent
+
+
+ VkDisplayKHR currentDisplay
+ uint32_t currentStackIndex
+
+
+ VkExtent2D visibleRegion
+ uint32_t refreshRate
+
+
+ VkDisplayModeKHR displayMode
+ VkDisplayModeParametersKHR parameters
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDisplayModeCreateFlagsKHR flags
+ VkDisplayModeParametersKHR parameters
+
+
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha
+ VkOffset2D minSrcPosition
+ VkOffset2D maxSrcPosition
+ VkExtent2D minSrcExtent
+ VkExtent2D maxSrcExtent
+ VkOffset2D minDstPosition
+ VkOffset2D maxDstPosition
+ VkExtent2D minDstExtent
+ VkExtent2D maxDstExtent
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDisplaySurfaceCreateFlagsKHR flags
+ VkDisplayModeKHR displayMode
+ uint32_t planeIndex
+ uint32_t planeStackIndex
+ VkSurfaceTransformFlagBitsKHR transform
+ float globalAlpha
+ VkDisplayPlaneAlphaFlagBitsKHR alphaMode
+ VkExtent2D imageExtent
+
+
+ VkStructureType sType
+ const void* pNext
+ VkRect2D srcRect
+ VkRect2D dstRect
+ VkBool32 persistent
+
+
+ uint32_t minImageCount
+ uint32_t maxImageCount
+ VkExtent2D currentExtent
+ VkExtent2D minImageExtent
+ VkExtent2D maxImageExtent
+ uint32_t maxImageArrayLayers
+ VkSurfaceTransformFlagsKHR supportedTransforms
+ VkSurfaceTransformFlagBitsKHR currentTransform
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha
+ VkImageUsageFlags supportedUsageFlags
+
+
+ VkStructureType sType
+ const void* pNext
+ VkAndroidSurfaceCreateFlagsKHR flags
+ ANativeWindow* window
+
+
+ VkStructureType sType
+ const void* pNext
+ VkMirSurfaceCreateFlagsKHR flags
+ MirConnection* connection
+ MirSurface* mirSurface
+
+
+ VkStructureType sType
+ const void* pNext
+ VkViSurfaceCreateFlagsNN flags
+ void* window
+
+
+ VkStructureType sType
+ const void* pNext
+ VkWaylandSurfaceCreateFlagsKHR flags
+ struct wl_display* display
+ struct wl_surface* surface
+
+
+ VkStructureType sType
+ const void* pNext
+ VkWin32SurfaceCreateFlagsKHR flags
+ HINSTANCE hinstance
+ HWND hwnd
+
+
+ VkStructureType sType
+ const void* pNext
+ VkXlibSurfaceCreateFlagsKHR flags
+ Display* dpy
+ Window window
+
+
+ VkStructureType sType
+ const void* pNext
+ VkXcbSurfaceCreateFlagsKHR flags
+ xcb_connection_t* connection
+ xcb_window_t window
+
+
+ VkFormat format
+ VkColorSpaceKHR colorSpace
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t waitSemaphoreCount
+ const VkSemaphore* pWaitSemaphores
+ uint32_t swapchainCount
+ const VkSwapchainKHR* pSwapchains
+ const uint32_t* pImageIndices
+ VkResult* pResults
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDebugReportFlagsEXT flags
+ PFN_vkDebugReportCallbackEXT pfnCallback
+ void* pUserData
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t disabledValidationCheckCount
+ VkValidationCheckEXT* pDisabledValidationChecks
+
+
+ VkStructureType sType
+ const void* pNext
+ VkRasterizationOrderAMD rasterizationOrder
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDebugReportObjectTypeEXT objectType
+ uint64_t object
+ const char* pObjectName
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDebugReportObjectTypeEXT objectType
+ uint64_t object
+ uint64_t tagName
+ size_t tagSize
+ const void* pTag
+
+
+ VkStructureType sType
+ const void* pNext
+ const char* pMarkerName
+ float color[4]
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBool32 dedicatedAllocation
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBool32 dedicatedAllocation
+
+
+ VkStructureType sType
+ const void* pNext
+ VkImage image
+ VkBuffer buffer
+
+
+ VkImageFormatProperties imageFormatProperties
+ VkExternalMemoryFeatureFlagsNV externalMemoryFeatures
+ VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes
+ VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsNV handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsNV handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsNV handleType
+ HANDLE handle
+
+
+ VkStructureType sType
+ const void* pNext
+ const SECURITY_ATTRIBUTES* pAttributes
+ DWORD dwAccess
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBool32 computeBindingPointSupport
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t maxIndirectCommandsLayoutTokenCount
+ uint32_t maxObjectEntryCounts
+ uint32_t minSequenceCountBufferOffsetAlignment
+ uint32_t minSequenceIndexBufferOffsetAlignment
+ uint32_t minCommandsTokenBufferOffsetAlignment
+
+
+ VkIndirectCommandsTokenTypeNVX tokenType
+ VkBuffer buffer
+ VkDeviceSize offset
+
+
+ VkIndirectCommandsTokenTypeNVX tokenType
+ uint32_t bindingUnit
+ uint32_t dynamicCount
+ uint32_t divisor
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineBindPoint pipelineBindPoint
+ VkIndirectCommandsLayoutUsageFlagsNVX flags
+ uint32_t tokenCount
+ const VkIndirectCommandsLayoutTokenNVX* pTokens
+
+
+ VkStructureType sType
+ const void* pNext
+ VkObjectTableNVX objectTable
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout
+ uint32_t indirectCommandsTokenCount
+ const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens
+ uint32_t maxSequencesCount
+ VkCommandBuffer targetCommandBuffer
+ VkBuffer sequencesCountBuffer
+ VkDeviceSize sequencesCountOffset
+ VkBuffer sequencesIndexBuffer
+ VkDeviceSize sequencesIndexOffset
+
+
+ VkStructureType sType
+ const void* pNext
+ VkObjectTableNVX objectTable
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout
+ uint32_t maxSequencesCount
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t objectCount
+ const VkObjectEntryTypeNVX* pObjectEntryTypes
+ const uint32_t* pObjectEntryCounts
+ const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags
+
+ uint32_t maxUniformBuffersPerDescriptor
+ uint32_t maxStorageBuffersPerDescriptor
+ uint32_t maxStorageImagesPerDescriptor
+ uint32_t maxSampledImagesPerDescriptor
+ uint32_t maxPipelineLayouts
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+ VkPipeline pipeline
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+ VkPipelineLayout pipelineLayout
+ VkDescriptorSet descriptorSet
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+ VkBuffer buffer
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+ VkBuffer buffer
+ VkIndexType indexType
+
+
+ VkObjectEntryTypeNVX type
+ VkObjectEntryUsageFlagsNVX flags
+ VkPipelineLayout pipelineLayout
+ VkShaderStageFlags stageFlags
+
+
+ VkStructureType sType
+ void* pNext
+ VkPhysicalDeviceFeatures features
+
+
+ VkStructureType sType
+ void* pNext
+ VkPhysicalDeviceProperties properties
+
+
+ VkStructureType sType
+ void* pNext
+ VkFormatProperties formatProperties
+
+
+ VkStructureType sType
+ void* pNext
+ VkImageFormatProperties imageFormatProperties
+
+
+ VkStructureType sType
+ const void* pNext
+ VkFormat format
+ VkImageType type
+ VkImageTiling tiling
+ VkImageUsageFlags usage
+ VkImageCreateFlags flags
+
+
+ VkStructureType sType
+ void* pNext
+ VkQueueFamilyProperties queueFamilyProperties
+
+
+ VkStructureType sType
+ void* pNext
+ VkPhysicalDeviceMemoryProperties memoryProperties
+
+
+ VkStructureType sType
+ void* pNext
+ VkSparseImageFormatProperties properties
+
+
+ VkStructureType sType
+ const void* pNext
+ VkFormat format
+ VkImageType type
+ VkSampleCountFlagBits samples
+ VkImageUsageFlags usage
+ VkImageTiling tiling
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t maxPushDescriptors
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t swapchainCount
+ const VkPresentRegionKHR* pRegions
+
+
+ uint32_t rectangleCount
+ const VkRectLayerKHR* pRectangles
+
+
+ VkOffset2D offset
+ VkExtent2D extent
+ uint32_t layer
+
+
+ VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures
+ VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes
+ VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+
+
+ VkStructureType sType
+ void* pNext
+ VkExternalMemoryPropertiesKHX externalMemoryProperties
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBufferCreateFlags flags
+ VkBufferUsageFlags usage
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+
+
+ VkStructureType sType
+ void* pNext
+ VkExternalMemoryPropertiesKHX externalMemoryProperties
+
+
+ VkStructureType sType
+ void* pNext
+ uint8_t deviceUUID[VK_UUID_SIZE]
+ uint8_t driverUUID[VK_UUID_SIZE]
+ uint8_t deviceLUID[VK_LUID_SIZE_KHX]
+ VkBool32 deviceLUIDValid
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ HANDLE handle
+
+
+ VkStructureType sType
+ const void* pNext
+ const SECURITY_ATTRIBUTES* pAttributes
+ DWORD dwAccess
+ LPCWSTR name
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t memoryTypeBits
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ int fd
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t memoryTypeBits
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType
+
+
+ VkStructureType sType
+ void* pNext
+ VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes
+ VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes
+ VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures
+
+
+ VkStructureType sType
+ const void* pNext
+ VkExternalSemaphoreHandleTypeFlagsKHX handleTypes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSemaphore semaphore
+ VkExternalSemaphoreHandleTypeFlagsKHX handleType
+ HANDLE handle
+
+
+ VkStructureType sType
+ const void* pNext
+ const SECURITY_ATTRIBUTES* pAttributes
+ DWORD dwAccess
+ LPCWSTR name
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t waitSemaphoreValuesCount
+ const uint64_t* pWaitSemaphoreValues
+ uint32_t signalSemaphoreValuesCount
+ const uint64_t* pSignalSemaphoreValues
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSemaphore semaphore
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType
+ int fd
+
+
+ VkStructureType sType
+ void* pNext
+ VkBool32 multiview
+ VkBool32 multiviewGeometryShader
+ VkBool32 multiviewTessellationShader
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t maxMultiviewViewCount
+ uint32_t maxMultiviewInstanceIndex
+
+
+ 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
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDisplayPowerStateEXT powerState
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDeviceEventTypeEXT deviceEvent
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDisplayEventTypeEXT displayEvent
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSurfaceCounterFlagsEXT surfaceCounters
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t physicalDeviceCount
+ VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]
+ VkBool32 subsetAllocation
+
+
+ VkStructureType sType
+ const void* pNext
+ VkMemoryAllocateFlagsKHX flags
+ uint32_t deviceMask
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBuffer buffer
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+ uint32_t deviceIndexCount
+ const uint32_t* pDeviceIndices
+
+
+ VkStructureType sType
+ const void* pNext
+ VkImage image
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+ uint32_t deviceIndexCount
+ const uint32_t* pDeviceIndices
+ uint32_t SFRRectCount
+ const VkRect2D* pSFRRects
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t deviceMask
+ uint32_t deviceRenderAreaCount
+ const VkRect2D* pDeviceRenderAreas
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t deviceMask
+
+
+ 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
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t resourceDeviceIndex
+ uint32_t memoryDeviceIndex
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]
+ VkDeviceGroupPresentModeFlagsKHX modes
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSwapchainKHR swapchain
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSwapchainKHR swapchain
+ uint32_t imageIndex
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSwapchainKHR swapchain
+ uint64_t timeout
+ VkSemaphore semaphore
+ VkFence fence
+ uint32_t deviceMask
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t swapchainCount
+ const uint32_t* pDeviceMasks
+ VkDeviceGroupPresentModeFlagBitsKHX mode
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t physicalDeviceCount
+ const VkPhysicalDevice* pPhysicalDevices
+
+
+ VkStructureType sType
+ const void* pNext
+ VkDeviceGroupPresentModeFlagsKHX modes
+
+
+ uint32_t dstBinding
+ uint32_t dstArrayElement
+ uint32_t descriptorCount
+ VkDescriptorType descriptorType
+ size_t offset
+ size_t stride
+
+
+ VkStructureType sType
+ void* pNext
+ VkDescriptorUpdateTemplateCreateFlagsKHR flags
+ uint32_t descriptorUpdateEntryCount
+ const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries
+ VkDescriptorUpdateTemplateTypeKHR templateType
+ VkDescriptorSetLayout descriptorSetLayout
+ VkPipelineBindPoint pipelineBindPoint
+ VkPipelineLayoutpipelineLayout
+ uint32_t set
+
+
+
+ float x
+ float y
+
+
+
+ VkStructureType sType
+ const void* pNext
+
+ VkXYColorEXT displayPrimaryRed
+ VkXYColorEXT displayPrimaryGreen
+ VkXYColorEXT displayPrimaryBlue
+ VkXYColorEXT whitePoint
+ float maxLuminance
+ float minLuminance
+
+ float maxContentLightLevel
+ float maxFrameAverageLightLevel
+
+
+ uint64_t refreshDuration
+
+
+ uint32_t presentID
+ uint64_t desiredPresentTime
+ uint64_t actualPresentTime
+ uint64_t earliestPresentTime
+ uint64_t presentMargin
+
+
+ VkStructureType sType
+ const void* pNext
+ uint32_t swapchainCount
+ const VkPresentTimeGOOGLE* pTimes
+
+
+ uint32_t presentID
+ uint64_t desiredPresentTime
+
+
+ VkStructureType sType
+ const void* pNext
+ VkIOSSurfaceCreateFlagsMVK flags
+ const void* pView
+
+
+ VkStructureType sType
+ const void* pNext
+ VkMacOSSurfaceCreateFlagsMVK flags
+ const void* pView
+
+
+ float xcoeff
+ float ycoeff
+
+
+ VkStructureType sType
+ const void* pNext
+ VkBool32 viewportWScalingEnable
+ uint32_t viewportCount
+ const VkViewportWScalingNV* pViewportWScalings
+
+
+ VkViewportCoordinateSwizzleNV x
+ VkViewportCoordinateSwizzleNV y
+ VkViewportCoordinateSwizzleNV z
+ VkViewportCoordinateSwizzleNV w
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineViewportSwizzleStateCreateFlagsNV flags
+ uint32_t viewportCount
+ const VkViewportSwizzleNV* pViewportSwizzles
+
+
+ VkStructureType sType
+ void* pNext
+ uint32_t maxDiscardRectangles
+
+
+ VkStructureType sType
+ const void* pNext
+ VkPipelineDiscardRectangleStateCreateFlagsEXT flags
+ VkDiscardRectangleModeEXT discardRectangleMode
+ uint32_t discardRectangleCount
+ const VkRect2D* pDiscardRectangles
+
+
+ VkStructureType sType
+ void* pNext
+ VkBool32 perViewPositionAllComponents
+
+
+ VkStructureType sType
+ const void* pNext
+ VkSurfaceKHR surface
+
+
+ VkStructureType sType
+ void* pNext
+ VkSurfaceCapabilitiesKHR surfaceCapabilities
+
+
+ VkStructureType sType
+ void* pNext
+ VkSurfaceFormatKHR surfaceFormat
+
+
+ VkStructureType sType
+ void* pNext
+ VkImageUsageFlags sharedPresentSupportedUsageFlags
+
+
+ VkStructureType sType
+ void* pNext
+ VkBool32 supportsTextureGatherLODBiasAMD
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ VkResult vkCreateInstance
+ const VkInstanceCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkInstance* pInstance
+
+
+ void vkDestroyInstance
+ VkInstance instance
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkEnumeratePhysicalDevices
+ VkInstance instance
+ uint32_t* pPhysicalDeviceCount
+ VkPhysicalDevice* pPhysicalDevices
+
+
+ PFN_vkVoidFunction vkGetDeviceProcAddr
+ VkDevice device
+ const char* pName
+
+
+ PFN_vkVoidFunction vkGetInstanceProcAddr
+ VkInstance instance
+ const char* pName
+
+
+ void vkGetPhysicalDeviceProperties
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceProperties* pProperties
+
+
+ void vkGetPhysicalDeviceQueueFamilyProperties
+ VkPhysicalDevice physicalDevice
+ uint32_t* pQueueFamilyPropertyCount
+ VkQueueFamilyProperties* pQueueFamilyProperties
+
+
+ void vkGetPhysicalDeviceMemoryProperties
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties
+
+
+ void vkGetPhysicalDeviceFeatures
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceFeatures* pFeatures
+
+
+ void vkGetPhysicalDeviceFormatProperties
+ VkPhysicalDevice physicalDevice
+ VkFormat format
+ VkFormatProperties* pFormatProperties
+
+
+ VkResult vkGetPhysicalDeviceImageFormatProperties
+ VkPhysicalDevice physicalDevice
+ VkFormat format
+ VkImageType type
+ VkImageTiling tiling
+ VkImageUsageFlags usage
+ VkImageCreateFlags flags
+ VkImageFormatProperties* pImageFormatProperties
+
+
+ VkResult vkCreateDevice
+ VkPhysicalDevice physicalDevice
+ const VkDeviceCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDevice* pDevice
+
+
+ void vkDestroyDevice
+ VkDevice device
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkEnumerateInstanceLayerProperties
+ uint32_t* pPropertyCount
+ VkLayerProperties* pProperties
+
+
+ VkResult vkEnumerateInstanceExtensionProperties
+ const char* pLayerName
+ uint32_t* pPropertyCount
+ VkExtensionProperties* pProperties
+
+
+ VkResult vkEnumerateDeviceLayerProperties
+ VkPhysicalDevice physicalDevice
+ uint32_t* pPropertyCount
+ VkLayerProperties* pProperties
+
+
+ VkResult vkEnumerateDeviceExtensionProperties
+ VkPhysicalDevice physicalDevice
+ const char* pLayerName
+ uint32_t* pPropertyCount
+ VkExtensionProperties* pProperties
+
+
+ void vkGetDeviceQueue
+ VkDevice device
+ uint32_t queueFamilyIndex
+ uint32_t queueIndex
+ VkQueue* pQueue
+
+
+ VkResult vkQueueSubmit
+ VkQueue queue
+ uint32_t submitCount
+ const VkSubmitInfo* pSubmits
+ VkFence fence
+
+
+ VkResult vkQueueWaitIdle
+ VkQueue queue
+
+
+ VkResult vkDeviceWaitIdle
+ VkDevice device
+
+ all sname:VkQueue objects created from pname:device
+
+
+
+ VkResult vkAllocateMemory
+ VkDevice device
+ const VkMemoryAllocateInfo* pAllocateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDeviceMemory* pMemory
+
+
+ void vkFreeMemory
+ VkDevice device
+ VkDeviceMemory memory
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkMapMemory
+ VkDevice device
+ VkDeviceMemory memory
+ VkDeviceSize offset
+ VkDeviceSize size
+ VkMemoryMapFlags flags
+ void** ppData
+
+
+ void vkUnmapMemory
+ VkDevice device
+ VkDeviceMemory memory
+
+
+ VkResult vkFlushMappedMemoryRanges
+ VkDevice device
+ uint32_t memoryRangeCount
+ const VkMappedMemoryRange* pMemoryRanges
+
+
+ VkResult vkInvalidateMappedMemoryRanges
+ VkDevice device
+ uint32_t memoryRangeCount
+ const VkMappedMemoryRange* pMemoryRanges
+
+
+ void vkGetDeviceMemoryCommitment
+ VkDevice device
+ VkDeviceMemory memory
+ VkDeviceSize* pCommittedMemoryInBytes
+
+
+ void vkGetBufferMemoryRequirements
+ VkDevice device
+ VkBuffer buffer
+ VkMemoryRequirements* pMemoryRequirements
+
+
+ VkResult vkBindBufferMemory
+ VkDevice device
+ VkBuffer buffer
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+
+
+ void vkGetImageMemoryRequirements
+ VkDevice device
+ VkImage image
+ VkMemoryRequirements* pMemoryRequirements
+
+
+ VkResult vkBindImageMemory
+ VkDevice device
+ VkImage image
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
+
+
+ void vkGetImageSparseMemoryRequirements
+ VkDevice device
+ VkImage image
+ uint32_t* pSparseMemoryRequirementCount
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements
+
+
+ void vkGetPhysicalDeviceSparseImageFormatProperties
+ VkPhysicalDevice physicalDevice
+ VkFormat format
+ VkImageType type
+ VkSampleCountFlagBits samples
+ VkImageUsageFlags usage
+ VkImageTiling tiling
+ uint32_t* pPropertyCount
+ VkSparseImageFormatProperties* pProperties
+
+
+ VkResult vkQueueBindSparse
+ VkQueue queue
+ uint32_t bindInfoCount
+ const VkBindSparseInfo* pBindInfo
+ VkFence fence
+
+
+ VkResult vkCreateFence
+ VkDevice device
+ const VkFenceCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkFence* pFence
+
+
+ void vkDestroyFence
+ VkDevice device
+ VkFence fence
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkResetFences
+ VkDevice device
+ uint32_t fenceCount
+ const VkFence* pFences
+
+
+ VkResult vkGetFenceStatus
+ VkDevice device
+ VkFence fence
+
+
+ VkResult vkWaitForFences
+ VkDevice device
+ uint32_t fenceCount
+ const VkFence* pFences
+ VkBool32 waitAll
+ uint64_t timeout
+
+
+ VkResult vkCreateSemaphore
+ VkDevice device
+ const VkSemaphoreCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSemaphore* pSemaphore
+
+
+ void vkDestroySemaphore
+ VkDevice device
+ VkSemaphore semaphore
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateEvent
+ VkDevice device
+ const VkEventCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkEvent* pEvent
+
+
+ void vkDestroyEvent
+ VkDevice device
+ VkEvent event
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkGetEventStatus
+ VkDevice device
+ VkEvent event
+
+
+ VkResult vkSetEvent
+ VkDevice device
+ VkEvent event
+
+
+ VkResult vkResetEvent
+ VkDevice device
+ VkEvent event
+
+
+ VkResult vkCreateQueryPool
+ VkDevice device
+ const VkQueryPoolCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkQueryPool* pQueryPool
+
+
+ void vkDestroyQueryPool
+ VkDevice device
+ VkQueryPool queryPool
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkGetQueryPoolResults
+ VkDevice device
+ VkQueryPool queryPool
+ uint32_t firstQuery
+ uint32_t queryCount
+ size_t dataSize
+ void* pData
+ VkDeviceSize stride
+ VkQueryResultFlags flags
+
+
+ VkResult vkCreateBuffer
+ VkDevice device
+ const VkBufferCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkBuffer* pBuffer
+
+
+ void vkDestroyBuffer
+ VkDevice device
+ VkBuffer buffer
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateBufferView
+ VkDevice device
+ const VkBufferViewCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkBufferView* pView
+
+
+ void vkDestroyBufferView
+ VkDevice device
+ VkBufferView bufferView
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateImage
+ VkDevice device
+ const VkImageCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkImage* pImage
+
+
+ void vkDestroyImage
+ VkDevice device
+ VkImage image
+ const VkAllocationCallbacks* pAllocator
+
+
+ void vkGetImageSubresourceLayout
+ VkDevice device
+ VkImage image
+ const VkImageSubresource* pSubresource
+ VkSubresourceLayout* pLayout
+
+
+ VkResult vkCreateImageView
+ VkDevice device
+ const VkImageViewCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkImageView* pView
+
+
+ void vkDestroyImageView
+ VkDevice device
+ VkImageView imageView
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateShaderModule
+ VkDevice device
+ const VkShaderModuleCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkShaderModule* pShaderModule
+
+
+ void vkDestroyShaderModule
+ VkDevice device
+ VkShaderModule shaderModule
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreatePipelineCache
+ VkDevice device
+ const VkPipelineCacheCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkPipelineCache* pPipelineCache
+
+
+ void vkDestroyPipelineCache
+ VkDevice device
+ VkPipelineCache pipelineCache
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkGetPipelineCacheData
+ VkDevice device
+ VkPipelineCache pipelineCache
+ size_t* pDataSize
+ void* pData
+
+
+ VkResult vkMergePipelineCaches
+ VkDevice device
+ VkPipelineCache dstCache
+ uint32_t srcCacheCount
+ const VkPipelineCache* pSrcCaches
+
+
+ VkResult vkCreateGraphicsPipelines
+ VkDevice device
+ VkPipelineCache pipelineCache
+ uint32_t createInfoCount
+ const VkGraphicsPipelineCreateInfo* pCreateInfos
+ const VkAllocationCallbacks* pAllocator
+ VkPipeline* pPipelines
+
+
+ VkResult vkCreateComputePipelines
+ VkDevice device
+ VkPipelineCache pipelineCache
+ uint32_t createInfoCount
+ const VkComputePipelineCreateInfo* pCreateInfos
+ const VkAllocationCallbacks* pAllocator
+ VkPipeline* pPipelines
+
+
+ void vkDestroyPipeline
+ VkDevice device
+ VkPipeline pipeline
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreatePipelineLayout
+ VkDevice device
+ const VkPipelineLayoutCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkPipelineLayout* pPipelineLayout
+
+
+ void vkDestroyPipelineLayout
+ VkDevice device
+ VkPipelineLayout pipelineLayout
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateSampler
+ VkDevice device
+ const VkSamplerCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSampler* pSampler
+
+
+ void vkDestroySampler
+ VkDevice device
+ VkSampler sampler
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateDescriptorSetLayout
+ VkDevice device
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDescriptorSetLayout* pSetLayout
+
+
+ void vkDestroyDescriptorSetLayout
+ VkDevice device
+ VkDescriptorSetLayout descriptorSetLayout
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateDescriptorPool
+ VkDevice device
+ const VkDescriptorPoolCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDescriptorPool* pDescriptorPool
+
+
+ void vkDestroyDescriptorPool
+ VkDevice device
+ VkDescriptorPool descriptorPool
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkResetDescriptorPool
+ VkDevice device
+ VkDescriptorPool descriptorPool
+ VkDescriptorPoolResetFlags flags
+
+ any sname:VkDescriptorSet objects allocated from pname:descriptorPool
+
+
+
+ VkResult vkAllocateDescriptorSets
+ VkDevice device
+ const VkDescriptorSetAllocateInfo* pAllocateInfo
+ VkDescriptorSet* pDescriptorSets
+
+
+ VkResult vkFreeDescriptorSets
+ VkDevice device
+ VkDescriptorPool descriptorPool
+ uint32_t descriptorSetCount
+ const VkDescriptorSet* pDescriptorSets
+
+
+ void vkUpdateDescriptorSets
+ VkDevice device
+ uint32_t descriptorWriteCount
+ const VkWriteDescriptorSet* pDescriptorWrites
+ uint32_t descriptorCopyCount
+ const VkCopyDescriptorSet* pDescriptorCopies
+
+
+ VkResult vkCreateFramebuffer
+ VkDevice device
+ const VkFramebufferCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkFramebuffer* pFramebuffer
+
+
+ void vkDestroyFramebuffer
+ VkDevice device
+ VkFramebuffer framebuffer
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateRenderPass
+ VkDevice device
+ const VkRenderPassCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkRenderPass* pRenderPass
+
+
+ void vkDestroyRenderPass
+ VkDevice device
+ VkRenderPass renderPass
+ const VkAllocationCallbacks* pAllocator
+
+
+ void vkGetRenderAreaGranularity
+ VkDevice device
+ VkRenderPass renderPass
+ VkExtent2D* pGranularity
+
+
+ VkResult vkCreateCommandPool
+ VkDevice device
+ const VkCommandPoolCreateInfo* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkCommandPool* pCommandPool
+
+
+ void vkDestroyCommandPool
+ VkDevice device
+ VkCommandPool commandPool
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkResetCommandPool
+ VkDevice device
+ VkCommandPool commandPool
+ VkCommandPoolResetFlags flags
+
+
+ VkResult vkAllocateCommandBuffers
+ VkDevice device
+ const VkCommandBufferAllocateInfo* pAllocateInfo
+ VkCommandBuffer* pCommandBuffers
+
+
+ void vkFreeCommandBuffers
+ VkDevice device
+ VkCommandPool commandPool
+ uint32_t commandBufferCount
+ const VkCommandBuffer* pCommandBuffers
+
+
+ VkResult vkBeginCommandBuffer
+ VkCommandBuffer commandBuffer
+ const VkCommandBufferBeginInfo* pBeginInfo
+
+ the sname:VkCommandPool that pname:commandBuffer was allocated from
+
+
+
+ VkResult vkEndCommandBuffer
+ VkCommandBuffer commandBuffer
+
+ the sname:VkCommandPool that pname:commandBuffer was allocated from
+
+
+
+ VkResult vkResetCommandBuffer
+ VkCommandBuffer commandBuffer
+ VkCommandBufferResetFlags flags
+
+
+ void vkCmdBindPipeline
+ VkCommandBuffer commandBuffer
+ VkPipelineBindPoint pipelineBindPoint
+ VkPipeline pipeline
+
+
+ void vkCmdSetViewport
+ VkCommandBuffer commandBuffer
+ uint32_t firstViewport
+ uint32_t viewportCount
+ const VkViewport* pViewports
+
+
+ void vkCmdSetScissor
+ VkCommandBuffer commandBuffer
+ uint32_t firstScissor
+ uint32_t scissorCount
+ const VkRect2D* pScissors
+
+
+ void vkCmdSetLineWidth
+ VkCommandBuffer commandBuffer
+ float lineWidth
+
+
+ void vkCmdSetDepthBias
+ VkCommandBuffer commandBuffer
+ float depthBiasConstantFactor
+ float depthBiasClamp
+ float depthBiasSlopeFactor
+
+
+ void vkCmdSetBlendConstants
+ VkCommandBuffer commandBuffer
+ const float blendConstants[4]
+
+
+ void vkCmdSetDepthBounds
+ VkCommandBuffer commandBuffer
+ float minDepthBounds
+ float maxDepthBounds
+
+
+ void vkCmdSetStencilCompareMask
+ VkCommandBuffer commandBuffer
+ VkStencilFaceFlags faceMask
+ uint32_t compareMask
+
+
+ void vkCmdSetStencilWriteMask
+ VkCommandBuffer commandBuffer
+ VkStencilFaceFlags faceMask
+ uint32_t writeMask
+
+
+ void vkCmdSetStencilReference
+ VkCommandBuffer commandBuffer
+ VkStencilFaceFlags faceMask
+ uint32_t reference
+
+
+ void vkCmdBindDescriptorSets
+ VkCommandBuffer commandBuffer
+ VkPipelineBindPoint pipelineBindPoint
+ VkPipelineLayout layout
+ uint32_t firstSet
+ uint32_t descriptorSetCount
+ const VkDescriptorSet* pDescriptorSets
+ uint32_t dynamicOffsetCount
+ const uint32_t* pDynamicOffsets
+
+
+ void vkCmdBindIndexBuffer
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkIndexType indexType
+
+
+ void vkCmdBindVertexBuffers
+ VkCommandBuffer commandBuffer
+ uint32_t firstBinding
+ uint32_t bindingCount
+ const VkBuffer* pBuffers
+ const VkDeviceSize* pOffsets
+
+
+ void vkCmdDraw
+ VkCommandBuffer commandBuffer
+ uint32_t vertexCount
+ uint32_t instanceCount
+ uint32_t firstVertex
+ uint32_t firstInstance
+
+
+ void vkCmdDrawIndexed
+ VkCommandBuffer commandBuffer
+ uint32_t indexCount
+ uint32_t instanceCount
+ uint32_t firstIndex
+ int32_t vertexOffset
+ uint32_t firstInstance
+
+
+ void vkCmdDrawIndirect
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+ uint32_t drawCount
+ uint32_t stride
+
+
+ void vkCmdDrawIndexedIndirect
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+ uint32_t drawCount
+ uint32_t stride
+
+
+ void vkCmdDispatch
+ VkCommandBuffer commandBuffer
+ uint32_t groupCountX
+ uint32_t groupCountY
+ uint32_t groupCountZ
+
+
+ void vkCmdDispatchIndirect
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+
+
+ void vkCmdCopyBuffer
+ VkCommandBuffer commandBuffer
+ VkBuffer srcBuffer
+ VkBuffer dstBuffer
+ uint32_t regionCount
+ const VkBufferCopy* pRegions
+
+
+ void vkCmdCopyImage
+ VkCommandBuffer commandBuffer
+ VkImage srcImage
+ VkImageLayout srcImageLayout
+ VkImage dstImage
+ VkImageLayout dstImageLayout
+ uint32_t regionCount
+ const VkImageCopy* pRegions
+
+
+ void vkCmdBlitImage
+ VkCommandBuffer commandBuffer
+ VkImage srcImage
+ VkImageLayout srcImageLayout
+ VkImage dstImage
+ VkImageLayout dstImageLayout
+ uint32_t regionCount
+ const VkImageBlit* pRegions
+ VkFilter filter
+
+
+ void vkCmdCopyBufferToImage
+ VkCommandBuffer commandBuffer
+ VkBuffer srcBuffer
+ VkImage dstImage
+ VkImageLayout dstImageLayout
+ uint32_t regionCount
+ const VkBufferImageCopy* pRegions
+
+
+ void vkCmdCopyImageToBuffer
+ VkCommandBuffer commandBuffer
+ VkImage srcImage
+ VkImageLayout srcImageLayout
+ VkBuffer dstBuffer
+ uint32_t regionCount
+ const VkBufferImageCopy* pRegions
+
+
+ void vkCmdUpdateBuffer
+ VkCommandBuffer commandBuffer
+ VkBuffer dstBuffer
+ VkDeviceSize dstOffset
+ VkDeviceSize dataSize
+ const void* pData
+
+
+ void vkCmdFillBuffer
+ VkCommandBuffer commandBuffer
+ VkBuffer dstBuffer
+ VkDeviceSize dstOffset
+ VkDeviceSize size
+ uint32_t data
+
+
+ void vkCmdClearColorImage
+ VkCommandBuffer commandBuffer
+ VkImage image
+ VkImageLayout imageLayout
+ const VkClearColorValue* pColor
+ uint32_t rangeCount
+ const VkImageSubresourceRange* pRanges
+
+
+ void vkCmdClearDepthStencilImage
+ VkCommandBuffer commandBuffer
+ VkImage image
+ VkImageLayout imageLayout
+ const VkClearDepthStencilValue* pDepthStencil
+ uint32_t rangeCount
+ const VkImageSubresourceRange* pRanges
+
+
+ void vkCmdClearAttachments
+ VkCommandBuffer commandBuffer
+ uint32_t attachmentCount
+ const VkClearAttachment* pAttachments
+ uint32_t rectCount
+ const VkClearRect* pRects
+
+
+ void vkCmdResolveImage
+ VkCommandBuffer commandBuffer
+ VkImage srcImage
+ VkImageLayout srcImageLayout
+ VkImage dstImage
+ VkImageLayout dstImageLayout
+ uint32_t regionCount
+ const VkImageResolve* pRegions
+
+
+ void vkCmdSetEvent
+ VkCommandBuffer commandBuffer
+ VkEvent event
+ VkPipelineStageFlags stageMask
+
+
+ void vkCmdResetEvent
+ VkCommandBuffer commandBuffer
+ VkEvent event
+ VkPipelineStageFlags stageMask
+
+
+ void 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
+
+
+ void 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
+
+
+ void vkCmdBeginQuery
+ VkCommandBuffer commandBuffer
+ VkQueryPool queryPool
+ uint32_t query
+ VkQueryControlFlags flags
+
+
+ void vkCmdEndQuery
+ VkCommandBuffer commandBuffer
+ VkQueryPool queryPool
+ uint32_t query
+
+
+ void vkCmdResetQueryPool
+ VkCommandBuffer commandBuffer
+ VkQueryPool queryPool
+ uint32_t firstQuery
+ uint32_t queryCount
+
+
+ void vkCmdWriteTimestamp
+ VkCommandBuffer commandBuffer
+ VkPipelineStageFlagBits pipelineStage
+ VkQueryPool queryPool
+ uint32_t query
+
+
+ void vkCmdCopyQueryPoolResults
+ VkCommandBuffer commandBuffer
+ VkQueryPool queryPool
+ uint32_t firstQuery
+ uint32_t queryCount
+ VkBuffer dstBuffer
+ VkDeviceSize dstOffset
+ VkDeviceSize stride
+ VkQueryResultFlags flags
+
+
+ void vkCmdPushConstants
+ VkCommandBuffer commandBuffer
+ VkPipelineLayout layout
+ VkShaderStageFlags stageFlags
+ uint32_t offset
+ uint32_t size
+ const void* pValues
+
+
+ void vkCmdBeginRenderPass
+ VkCommandBuffer commandBuffer
+ const VkRenderPassBeginInfo* pRenderPassBegin
+ VkSubpassContents contents
+
+
+ void vkCmdNextSubpass
+ VkCommandBuffer commandBuffer
+ VkSubpassContents contents
+
+
+ void vkCmdEndRenderPass
+ VkCommandBuffer commandBuffer
+
+
+ void vkCmdExecuteCommands
+ VkCommandBuffer commandBuffer
+ uint32_t commandBufferCount
+ const VkCommandBuffer* pCommandBuffers
+
+
+ VkResult vkCreateAndroidSurfaceKHR
+ VkInstance instance
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t* pPropertyCount
+ VkDisplayPropertiesKHR* pProperties
+
+
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t* pPropertyCount
+ VkDisplayPlanePropertiesKHR* pProperties
+
+
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t planeIndex
+ uint32_t* pDisplayCount
+ VkDisplayKHR* pDisplays
+
+
+ VkResult vkGetDisplayModePropertiesKHR
+ VkPhysicalDevice physicalDevice
+ VkDisplayKHR display
+ uint32_t* pPropertyCount
+ VkDisplayModePropertiesKHR* pProperties
+
+
+ VkResult vkCreateDisplayModeKHR
+ VkPhysicalDevice physicalDevice
+ VkDisplayKHR display
+ const VkDisplayModeCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDisplayModeKHR* pMode
+
+
+ VkResult vkGetDisplayPlaneCapabilitiesKHR
+ VkPhysicalDevice physicalDevice
+ VkDisplayModeKHR mode
+ uint32_t planeIndex
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities
+
+
+ VkResult vkCreateDisplayPlaneSurfaceKHR
+ VkInstance instance
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkResult vkCreateSharedSwapchainsKHR
+ VkDevice device
+ uint32_t swapchainCount
+ const VkSwapchainCreateInfoKHR* pCreateInfos
+ const VkAllocationCallbacks* pAllocator
+ VkSwapchainKHR* pSwapchains
+
+
+ VkResult vkCreateMirSurfaceKHR
+ VkInstance instance
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+ MirConnection* connection
+
+
+ void vkDestroySurfaceKHR
+ VkInstance instance
+ VkSurfaceKHR surface
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+ VkSurfaceKHR surface
+ VkBool32* pSupported
+
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+ VkPhysicalDevice physicalDevice
+ VkSurfaceKHR surface
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities
+
+
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR
+ VkPhysicalDevice physicalDevice
+ VkSurfaceKHR surface
+ uint32_t* pSurfaceFormatCount
+ VkSurfaceFormatKHR* pSurfaceFormats
+
+
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR
+ VkPhysicalDevice physicalDevice
+ VkSurfaceKHR surface
+ uint32_t* pPresentModeCount
+ VkPresentModeKHR* pPresentModes
+
+
+ VkResult vkCreateSwapchainKHR
+ VkDevice device
+ const VkSwapchainCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSwapchainKHR* pSwapchain
+
+
+ void vkDestroySwapchainKHR
+ VkDevice device
+ VkSwapchainKHR swapchain
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkGetSwapchainImagesKHR
+ VkDevice device
+ VkSwapchainKHR swapchain
+ uint32_t* pSwapchainImageCount
+ VkImage* pSwapchainImages
+
+
+ VkResult vkAcquireNextImageKHR
+ VkDevice device
+ VkSwapchainKHR swapchain
+ uint64_t timeout
+ VkSemaphore semaphore
+ VkFence fence
+ uint32_t* pImageIndex
+
+
+ VkResult vkQueuePresentKHR
+ VkQueue queue
+ const VkPresentInfoKHR* pPresentInfo
+
+
+ VkResult vkCreateViSurfaceNN
+ VkInstance instance
+ const VkViSurfaceCreateInfoNN* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkResult vkCreateWaylandSurfaceKHR
+ VkInstance instance
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+ struct wl_display* display
+
+
+ VkResult vkCreateWin32SurfaceKHR
+ VkInstance instance
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+
+
+ VkResult vkCreateXlibSurfaceKHR
+ VkInstance instance
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+ Display* dpy
+ VisualID visualID
+
+
+ VkResult vkCreateXcbSurfaceKHR
+ VkInstance instance
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR
+ VkPhysicalDevice physicalDevice
+ uint32_t queueFamilyIndex
+ xcb_connection_t* connection
+ xcb_visualid_t visual_id
+
+
+ VkResult vkCreateDebugReportCallbackEXT
+ VkInstance instance
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDebugReportCallbackEXT* pCallback
+
+
+ void vkDestroyDebugReportCallbackEXT
+ VkInstance instance
+ VkDebugReportCallbackEXT callback
+ const VkAllocationCallbacks* pAllocator
+
+
+ void vkDebugReportMessageEXT
+ VkInstance instance
+ VkDebugReportFlagsEXT flags
+ VkDebugReportObjectTypeEXT objectType
+ uint64_t object
+ size_t location
+ int32_t messageCode
+ const char* pLayerPrefix
+ const char* pMessage
+
+
+ VkResult vkDebugMarkerSetObjectNameEXT
+ VkDevice device
+ VkDebugMarkerObjectNameInfoEXT* pNameInfo
+
+
+ VkResult vkDebugMarkerSetObjectTagEXT
+ VkDevice device
+ VkDebugMarkerObjectTagInfoEXT* pTagInfo
+
+
+ void vkCmdDebugMarkerBeginEXT
+ VkCommandBuffer commandBuffer
+ VkDebugMarkerMarkerInfoEXT* pMarkerInfo
+
+
+ void vkCmdDebugMarkerEndEXT
+ VkCommandBuffer commandBuffer
+
+
+ void vkCmdDebugMarkerInsertEXT
+ VkCommandBuffer commandBuffer
+ VkDebugMarkerMarkerInfoEXT* pMarkerInfo
+
+
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV
+ VkPhysicalDevice physicalDevice
+ VkFormat format
+ VkImageType type
+ VkImageTiling tiling
+ VkImageUsageFlags usage
+ VkImageCreateFlags flags
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties
+
+
+ VkResult vkGetMemoryWin32HandleNV
+ VkDevice device
+ VkDeviceMemory memory
+ VkExternalMemoryHandleTypeFlagsNV handleType
+ HANDLE* pHandle
+
+
+ void vkCmdDrawIndirectCountAMD
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkBuffer countBuffer
+ VkDeviceSize countBufferOffset
+ uint32_t maxDrawCount
+ uint32_t stride
+
+
+ void vkCmdDrawIndexedIndirectCountAMD
+ VkCommandBuffer commandBuffer
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkBuffer countBuffer
+ VkDeviceSize countBufferOffset
+ uint32_t maxDrawCount
+ uint32_t stride
+
+
+ void vkCmdProcessCommandsNVX
+ VkCommandBuffer commandBuffer
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo
+
+
+ void vkCmdReserveSpaceForCommandsNVX
+ VkCommandBuffer commandBuffer
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo
+
+
+ VkResult vkCreateIndirectCommandsLayoutNVX
+ VkDevice device
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout
+
+
+ void vkDestroyIndirectCommandsLayoutNVX
+ VkDevice device
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkCreateObjectTableNVX
+ VkDevice device
+ const VkObjectTableCreateInfoNVX* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkObjectTableNVX* pObjectTable
+
+
+ void vkDestroyObjectTableNVX
+ VkDevice device
+ VkObjectTableNVX objectTable
+ const VkAllocationCallbacks* pAllocator
+
+
+ VkResult vkRegisterObjectsNVX
+ VkDevice device
+ VkObjectTableNVX objectTable
+ uint32_t objectCount
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries
+ const uint32_t* pObjectIndices
+
+
+ VkResult vkUnregisterObjectsNVX
+ VkDevice device
+ VkObjectTableNVX objectTable
+ uint32_t objectCount
+ const VkObjectEntryTypeNVX* pObjectEntryTypes
+ const uint32_t* pObjectIndices
+
+
+ void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
+ VkPhysicalDevice physicalDevice
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits
+
+
+ void vkGetPhysicalDeviceFeatures2KHR
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceFeatures2KHR* pFeatures
+
+
+ void vkGetPhysicalDeviceProperties2KHR
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceProperties2KHR* pProperties
+
+
+ void vkGetPhysicalDeviceFormatProperties2KHR
+ VkPhysicalDevice physicalDevice
+ VkFormat format
+ VkFormatProperties2KHR* pFormatProperties
+
+
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo
+ VkImageFormatProperties2KHR* pImageFormatProperties
+
+
+ void vkGetPhysicalDeviceQueueFamilyProperties2KHR
+ VkPhysicalDevice physicalDevice
+ uint32_t* pQueueFamilyPropertyCount
+ VkQueueFamilyProperties2KHR* pQueueFamilyProperties
+
+
+ void vkGetPhysicalDeviceMemoryProperties2KHR
+ VkPhysicalDevice physicalDevice
+ VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties
+
+
+ void vkGetPhysicalDeviceSparseImageFormatProperties2KHR
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo
+ uint32_t* pPropertyCount
+ VkSparseImageFormatProperties2KHR* pProperties
+
+
+ void vkCmdPushDescriptorSetKHR
+ VkCommandBuffer commandBuffer
+ VkPipelineBindPoint pipelineBindPoint
+ VkPipelineLayout layout
+ uint32_t set
+ uint32_t descriptorWriteCount
+ const VkWriteDescriptorSet* pDescriptorWrites
+
+
+ void vkTrimCommandPoolKHR
+ VkDevice device
+ VkCommandPool commandPool
+ VkCommandPoolTrimFlagsKHR flags
+
+
+ void vkGetPhysicalDeviceExternalBufferPropertiesKHX
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo
+ VkExternalBufferPropertiesKHX* pExternalBufferProperties
+
+
+ VkResult vkGetMemoryWin32HandleKHX
+ VkDevice device
+ VkDeviceMemory memory
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ HANDLE* pHandle
+
+
+ VkResult vkGetMemoryWin32HandlePropertiesKHX
+ VkDevice device
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ HANDLE handle
+ VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties
+
+
+ VkResult vkGetMemoryFdKHX
+ VkDevice device
+ VkDeviceMemory memory
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ int* pFd
+
+
+ VkResult vkGetMemoryFdPropertiesKHX
+ VkDevice device
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType
+ int fd
+ VkMemoryFdPropertiesKHX* pMemoryFdProperties
+
+
+ void vkGetPhysicalDeviceExternalSemaphorePropertiesKHX
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo
+ VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties
+
+
+ VkResult vkGetSemaphoreWin32HandleKHX
+ VkDevice device
+ VkSemaphore semaphore
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType
+ HANDLE* pHandle
+
+
+ VkResult vkImportSemaphoreWin32HandleKHX
+ VkDevice device
+ const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo
+
+
+ VkResult vkGetSemaphoreFdKHX
+ VkDevice device
+ VkSemaphore semaphore
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType
+ int* pFd
+
+
+ VkResult vkImportSemaphoreFdKHX
+ VkDevice device
+ const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo
+
+
+ VkResult vkReleaseDisplayEXT
+ VkPhysicalDevice physicalDevice
+ VkDisplayKHR display
+
+
+ VkResult vkAcquireXlibDisplayEXT
+ VkPhysicalDevice physicalDevice
+ Display* dpy
+ VkDisplayKHR display
+
+
+ VkResult vkGetRandROutputDisplayEXT
+ VkPhysicalDevice physicalDevice
+ Display* dpy
+ RROutput rrOutput
+ VkDisplayKHR* pDisplay
+
+
+ VkResult vkDisplayPowerControlEXT
+ VkDevice device
+ VkDisplayKHR display
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo
+
+
+ VkResult vkRegisterDeviceEventEXT
+ VkDevice device
+ const VkDeviceEventInfoEXT* pDeviceEventInfo
+ const VkAllocationCallbacks* pAllocator
+ VkFence* pFence
+
+
+ VkResult vkRegisterDisplayEventEXT
+ VkDevice device
+ VkDisplayKHR display
+ const VkDisplayEventInfoEXT* pDisplayEventInfo
+ const VkAllocationCallbacks* pAllocator
+ VkFence* pFence
+
+
+ VkResult vkGetSwapchainCounterEXT
+ VkDevice device
+ VkSwapchainKHR swapchain
+ VkSurfaceCounterFlagBitsEXT counter
+ uint64_t* pCounterValue
+
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT
+ VkPhysicalDevice physicalDevice
+ VkSurfaceKHR surface
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities
+
+
+ VkResult vkEnumeratePhysicalDeviceGroupsKHX
+ VkInstance instance
+ uint32_t* pPhysicalDeviceGroupCount
+ VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties
+
+
+ void vkGetDeviceGroupPeerMemoryFeaturesKHX
+ VkDevice device
+ uint32_t heapIndex
+ uint32_t localDeviceIndex
+ uint32_t remoteDeviceIndex
+ VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures
+
+
+ VkResult vkBindBufferMemory2KHX
+ VkDevice device
+ uint32_t bindInfoCount
+ const VkBindBufferMemoryInfoKHX* pBindInfos
+
+
+ VkResult vkBindImageMemory2KHX
+ VkDevice device
+ uint32_t bindInfoCount
+ const VkBindImageMemoryInfoKHX* pBindInfos
+
+
+ void vkCmdSetDeviceMaskKHX
+ VkCommandBuffer commandBuffer
+ uint32_t deviceMask
+
+
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHX
+ VkDevice device
+ VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities
+
+
+ VkResult vkGetDeviceGroupSurfacePresentModesKHX
+ VkDevice device
+ VkSurfaceKHR surface
+ VkDeviceGroupPresentModeFlagsKHX* pModes
+
+
+ VkResult vkAcquireNextImage2KHX
+ VkDevice device
+ const VkAcquireNextImageInfoKHX* pAcquireInfo
+ uint32_t* pImageIndex
+
+
+ void vkCmdDispatchBaseKHX
+ VkCommandBuffer commandBuffer
+ uint32_t baseGroupX
+ uint32_t baseGroupY
+ uint32_t baseGroupZ
+ uint32_t groupCountX
+ uint32_t groupCountY
+ uint32_t groupCountZ
+
+
+ VkResult vkGetPhysicalDevicePresentRectanglesKHX
+ VkPhysicalDevice physicalDevice
+ VkSurfaceKHR surface
+ uint32_t* pRectCount
+ VkRect2D* pRects
+
+
+ VkResult vkCreateDescriptorUpdateTemplateKHR
+ VkDevice device
+ const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate
+
+
+ void vkDestroyDescriptorUpdateTemplateKHR
+ VkDevice device
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
+ const VkAllocationCallbacks* pAllocator
+
+
+ void vkUpdateDescriptorSetWithTemplateKHR
+ VkDevice device
+ VkDescriptorSet descriptorSet
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
+ const void* pData
+
+
+ void vkCmdPushDescriptorSetWithTemplateKHR
+ VkCommandBuffer commandBuffer
+ VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
+ VkPipelineLayout layout
+ uint32_t set
+ const void* pData
+
+
+ void vkSetHdrMetadataEXT
+ VkDevice device
+ uint32_t swapchainCount
+ const VkSwapchainKHR* pSwapchains
+ const VkHdrMetadataEXT* pMetadata
+
+
+ VkResult vkGetSwapchainStatusKHR
+ VkDevice device
+ VkSwapchainKHR swapchain
+
+
+ VkResult vkGetRefreshCycleDurationGOOGLE
+ VkDevice device
+ VkSwapchainKHR swapchain
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties
+
+
+ VkResult vkGetPastPresentationTimingGOOGLE
+ VkDevice device
+ VkSwapchainKHR swapchain
+ uint32_t* pPresentationTimingCount
+ VkPastPresentationTimingGOOGLE* pPresentationTimings
+
+
+ VkResult vkCreateIOSSurfaceMVK
+ VkInstance instance
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ VkResult vkCreateMacOSSurfaceMVK
+ VkInstance instance
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo
+ const VkAllocationCallbacks* pAllocator
+ VkSurfaceKHR* pSurface
+
+
+ void vkCmdSetViewportWScalingNV
+ VkCommandBuffer commandBuffer
+ uint32_t firstViewport
+ uint32_t viewportCount
+ const VkViewportWScalingNV* pViewportWScalings
+
+
+ void vkCmdSetDiscardRectangleEXT
+ VkCommandBuffer commandBuffer
+ uint32_t firstDiscardRectangle
+ uint32_t discardRectangleCount
+ const VkRect2D* pDiscardRectangles
+
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities
+
+
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR
+ VkPhysicalDevice physicalDevice
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
+ uint32_t* pSurfaceFormatCount
+ VkSurfaceFormat2KHR* pSurfaceFormats
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
new file mode 100644
index 00000000000..fb0af61eb58
--- /dev/null
+++ b/include/wine/vulkan.h
@@ -0,0 +1,2423 @@
+/* Automatically generated from Vulkan vk.xml; DO NOT EDIT! */
+
+#ifndef __WINE_VULKAN_H
+#define __WINE_VULKAN_H
+
+#include
+#include
+
+#ifndef VKAPI_CALL
+#define VKAPI_CALL __stdcall
+#endif
+
+#ifndef VKAPI_PTR
+#define VKAPI_PTR VKAPI_CALL
+#endif
+
+/* Callers can override WINE_VK_ALIGN if they want 'host' headers. */
+#ifndef WINE_VK_ALIGN
+#define WINE_VK_ALIGN DECLSPEC_ALIGN
+#endif
+
+#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
+#define VK_UUID_SIZE 16
+#define VK_LUID_SIZE_KHX 8
+#define VK_MAX_EXTENSION_NAME_SIZE 256
+#define VK_MAX_DESCRIPTION_SIZE 256
+#define VK_MAX_MEMORY_TYPES 32
+#define VK_MAX_MEMORY_HEAPS 16
+#define VK_LOD_CLAMP_NONE 1000.0f
+#define VK_REMAINING_MIP_LEVELS (~0U)
+#define VK_REMAINING_ARRAY_LAYERS (~0U)
+#define VK_WHOLE_SIZE (~0ULL)
+#define VK_ATTACHMENT_UNUSED (~0U)
+#define VK_TRUE 1
+#define VK_FALSE 0
+#define VK_QUEUE_FAMILY_IGNORED (~0U)
+#define VK_QUEUE_FAMILY_EXTERNAL_KHX (~0U-1)
+#define VK_SUBPASS_EXTERNAL (~0U)
+#define VK_MAX_DEVICE_GROUP_SIZE_KHX 32
+
+#define VK_MAKE_VERSION(major, minor, patch) \
+ (((major) << 22) | ((minor) << 12) | (patch))
+#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
+#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
+#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
+
+#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
+#define VK_HEADER_VERSION 51
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+#define VK_NULL_HANDLE 0
+
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+VK_DEFINE_HANDLE(VkCommandBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+VK_DEFINE_HANDLE(VkDevice)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_HANDLE(VkInstance)
+VK_DEFINE_HANDLE(VkPhysicalDevice)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+VK_DEFINE_HANDLE(VkQueue)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+
+typedef uint32_t VkBool32;
+typedef uint64_t VkDeviceSize;
+typedef uint32_t VkFlags;
+typedef uint32_t VkSampleMask;
+
+typedef VkFlags VkAccessFlags;
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+typedef VkFlags VkAttachmentDescriptionFlags;
+typedef VkFlags VkBufferCreateFlags;
+typedef VkFlags VkBufferUsageFlags;
+typedef VkFlags VkBufferViewCreateFlags;
+typedef VkFlags VkColorComponentFlags;
+typedef VkFlags VkCommandBufferResetFlags;
+typedef VkFlags VkCommandBufferUsageFlags;
+typedef VkFlags VkCommandPoolCreateFlags;
+typedef VkFlags VkCommandPoolResetFlags;
+typedef VkFlags VkCommandPoolTrimFlagsKHR;
+typedef VkFlags VkCompositeAlphaFlagsKHR;
+typedef VkFlags VkCullModeFlags;
+typedef VkFlags VkDebugReportFlagsEXT;
+typedef VkFlags VkDependencyFlags;
+typedef VkFlags VkDescriptorPoolCreateFlags;
+typedef VkFlags VkDescriptorPoolResetFlags;
+typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
+typedef VkFlags VkDeviceCreateFlags;
+typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
+typedef VkFlags VkDeviceQueueCreateFlags;
+typedef VkFlags VkDisplayModeCreateFlagsKHR;
+typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+typedef VkFlags VkEventCreateFlags;
+typedef VkFlags VkExternalMemoryFeatureFlagsKHX;
+typedef VkFlags VkExternalMemoryFeatureFlagsNV;
+typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX;
+typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
+typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX;
+typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX;
+typedef VkFlags VkFenceCreateFlags;
+typedef VkFlags VkFormatFeatureFlags;
+typedef VkFlags VkFramebufferCreateFlags;
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+typedef VkFlags VkImageAspectFlags;
+typedef VkFlags VkImageCreateFlags;
+typedef VkFlags VkImageUsageFlags;
+typedef VkFlags VkImageViewCreateFlags;
+typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
+typedef VkFlags VkInstanceCreateFlags;
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+typedef VkFlags VkMemoryAllocateFlagsKHX;
+typedef VkFlags VkMemoryHeapFlags;
+typedef VkFlags VkMemoryMapFlags;
+typedef VkFlags VkMemoryPropertyFlags;
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+typedef VkFlags VkObjectEntryUsageFlagsNVX;
+typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
+typedef VkFlags VkPipelineCacheCreateFlags;
+typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+typedef VkFlags VkPipelineCreateFlags;
+typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
+typedef VkFlags VkPipelineDynamicStateCreateFlags;
+typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+typedef VkFlags VkPipelineLayoutCreateFlags;
+typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+typedef VkFlags VkPipelineShaderStageCreateFlags;
+typedef VkFlags VkPipelineStageFlags;
+typedef VkFlags VkPipelineTessellationStateCreateFlags;
+typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+typedef VkFlags VkPipelineViewportStateCreateFlags;
+typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
+typedef VkFlags VkQueryControlFlags;
+typedef VkFlags VkQueryPipelineStatisticFlags;
+typedef VkFlags VkQueryPoolCreateFlags;
+typedef VkFlags VkQueryResultFlags;
+typedef VkFlags VkQueueFlags;
+typedef VkFlags VkRenderPassCreateFlags;
+typedef VkFlags VkSampleCountFlags;
+typedef VkFlags VkSamplerCreateFlags;
+typedef VkFlags VkSemaphoreCreateFlags;
+typedef VkFlags VkShaderModuleCreateFlags;
+typedef VkFlags VkShaderStageFlags;
+typedef VkFlags VkSparseImageFormatFlags;
+typedef VkFlags VkSparseMemoryBindFlags;
+typedef VkFlags VkStencilFaceFlags;
+typedef VkFlags VkSubpassDescriptionFlags;
+typedef VkFlags VkSurfaceCounterFlagsEXT;
+typedef VkFlags VkSurfaceTransformFlagsKHR;
+typedef VkFlags VkSwapchainCreateFlagsKHR;
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkAccessFlagBits;
+
+typedef enum VkAttachmentDescriptionFlagBits
+{
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+ VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkAttachmentDescriptionFlagBits;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkAttachmentLoadOp;
+
+typedef enum VkAttachmentStoreOp
+{
+ VK_ATTACHMENT_STORE_OP_STORE = 0,
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
+ VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7fffffff,
+} VkAttachmentStoreOp;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkBlendOp;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkBorderColor;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkBufferCreateFlagBits;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkBufferUsageFlagBits;
+
+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 enum VkCommandBufferLevel
+{
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+ VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7fffffff,
+} VkCommandBufferLevel;
+
+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 enum VkCommandPoolCreateFlagBits
+{
+ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+ VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkCommandPoolCreateFlagBits;
+
+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 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 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 enum VkDependencyFlagBits
+{
+ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkDependencyFlagBits;
+
+typedef enum VkDescriptorPoolCreateFlagBits
+{
+ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+ VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkDescriptorPoolCreateFlagBits;
+
+typedef enum VkDescriptorSetLayoutCreateFlagBits
+{
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkDescriptorSetLayoutCreateFlagBits;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkDescriptorType;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkDynamicState;
+
+typedef enum VkFenceCreateFlagBits
+{
+ VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
+ VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkFenceCreateFlagBits;
+
+typedef enum VkFilter
+{
+ VK_FILTER_NEAREST = 0,
+ VK_FILTER_LINEAR = 1,
+ VK_FILTER_MAX_ENUM = 0x7fffffff,
+} VkFilter;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkFormat;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkFormatFeatureFlagBits;
+
+typedef enum VkFrontFace
+{
+ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+ VK_FRONT_FACE_CLOCKWISE = 1,
+ VK_FRONT_FACE_MAX_ENUM = 0x7fffffff,
+} VkFrontFace;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkImageAspectFlagBits;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkImageCreateFlagBits;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkImageLayout;
+
+typedef enum VkImageTiling
+{
+ VK_IMAGE_TILING_OPTIMAL = 0,
+ VK_IMAGE_TILING_LINEAR = 1,
+ 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 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,
+ VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkImageUsageFlagBits;
+
+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 VkIndexType
+{
+ VK_INDEX_TYPE_UINT16 = 0,
+ VK_INDEX_TYPE_UINT32 = 1,
+ VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff,
+} VkIndexType;
+
+typedef enum VkInternalAllocationType
+{
+ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
+ VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7fffffff,
+} VkInternalAllocationType;
+
+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 VkMemoryHeapFlagBits
+{
+ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+ VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkMemoryHeapFlagBits;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkMemoryPropertyFlagBits;
+
+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_MAX_ENUM = 0x7fffffff,
+} VkObjectType;
+
+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 VkPipelineBindPoint
+{
+ VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
+ VK_PIPELINE_BIND_POINT_COMPUTE = 1,
+ VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7fffffff,
+} VkPipelineBindPoint;
+
+typedef enum VkPipelineCacheHeaderVersion
+{
+ VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+ VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7fffffff,
+} VkPipelineCacheHeaderVersion;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkPipelineCreateFlagBits;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkPipelineStageFlagBits;
+
+typedef enum VkPolygonMode
+{
+ VK_POLYGON_MODE_FILL = 0,
+ VK_POLYGON_MODE_LINE = 1,
+ VK_POLYGON_MODE_POINT = 2,
+ VK_POLYGON_MODE_MAX_ENUM = 0x7fffffff,
+} VkPolygonMode;
+
+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 VkQueryControlFlagBits
+{
+ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+ VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkQueryControlFlagBits;
+
+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 enum VkQueryType
+{
+ VK_QUERY_TYPE_OCCLUSION = 0,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+ VK_QUERY_TYPE_TIMESTAMP = 2,
+ VK_QUERY_TYPE_MAX_ENUM = 0x7fffffff,
+} VkQueryType;
+
+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_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkQueueFlagBits;
+
+typedef enum VkResult
+{
+ VK_ERROR_FRAGMENTED_POOL = -12,
+ VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+ VK_ERROR_TOO_MANY_OBJECTS = -10,
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_ERROR_FEATURE_NOT_PRESENT = -8,
+ VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+ VK_ERROR_LAYER_NOT_PRESENT = -6,
+ VK_ERROR_MEMORY_MAP_FAILED = -5,
+ VK_ERROR_DEVICE_LOST = -4,
+ VK_ERROR_INITIALIZATION_FAILED = -3,
+ VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+ VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+ VK_SUCCESS = 0,
+ VK_NOT_READY = 1,
+ VK_TIMEOUT = 2,
+ VK_EVENT_SET = 3,
+ VK_EVENT_RESET = 4,
+ VK_INCOMPLETE = 5,
+ VK_RESULT_MAX_ENUM = 0x7fffffff,
+} VkResult;
+
+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 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_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 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_ALL_GRAPHICS = 0x0000001f,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+ VK_SHADER_STAGE_ALL = 0x7fffffff,
+ VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkShaderStageFlagBits;
+
+typedef enum VkSharingMode
+{
+ VK_SHARING_MODE_EXCLUSIVE = 0,
+ VK_SHARING_MODE_CONCURRENT = 1,
+ VK_SHARING_MODE_MAX_ENUM = 0x7fffffff,
+} VkSharingMode;
+
+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 enum VkSparseMemoryBindFlagBits
+{
+ VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
+ VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkSparseMemoryBindFlagBits;
+
+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 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_MAX_ENUM = 0x7fffffff,
+} VkStructureType;
+
+typedef enum VkSubpassContents
+{
+ VK_SUBPASS_CONTENTS_INLINE = 0,
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+ VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7fffffff,
+} VkSubpassContents;
+
+typedef enum VkSubpassDescriptionFlagBits
+{
+ VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+} VkSubpassDescriptionFlagBits;
+
+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 VkVertexInputRate
+{
+ VK_VERTEX_INPUT_RATE_VERTEX = 0,
+ VK_VERTEX_INPUT_RATE_INSTANCE = 1,
+ VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7fffffff,
+} VkVertexInputRate;
+
+typedef void* (VKAPI_PTR * PFN_vkAllocationFunction)(
+ void *pUserData,
+ const size_t size,
+ const size_t alignment,
+ const VkSystemAllocationScope allocationScope);
+typedef void (VKAPI_PTR * PFN_vkFreeFunction)(
+ void *pUserData,
+ const void *pMemory);
+typedef void (VKAPI_PTR * PFN_vkInternalAllocationNotification)(
+ void *pUserData,
+ const size_t size,
+ const VkInternalAllocationType allocationType,
+ const VkSystemAllocationScope allocationScope);
+typedef void (VKAPI_PTR * PFN_vkInternalFreeNotification)(
+ void *pUserData,
+ const size_t size,
+ const VkInternalAllocationType allocationType,
+ const VkSystemAllocationScope allocationScope);
+typedef void* (VKAPI_PTR * PFN_vkReallocationFunction)(
+ void *pUserData,
+ const void *pOriginal,
+ const size_t size,
+ const size_t alignment,
+ const VkSystemAllocationScope allocationScope);
+typedef void (VKAPI_PTR * PFN_vkVoidFunction)(
+void);
+
+typedef struct VkAttachmentDescription
+{
+ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+ VkSampleCountFlagBits samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
+ VkAttachmentLoadOp stencilLoadOp;
+ VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+} VkAttachmentDescription;
+
+typedef struct VkBufferCopy
+{
+ VkDeviceSize WINE_VK_ALIGN(8) srcOffset;
+ VkDeviceSize WINE_VK_ALIGN(8) dstOffset;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+} VkBufferCopy;
+
+typedef struct VkBufferMemoryBarrier
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkBuffer WINE_VK_ALIGN(8) buffer;
+ VkDeviceSize WINE_VK_ALIGN(8) offset;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+} VkBufferMemoryBarrier;
+
+typedef union VkClearColorValue
+{
+ float float32[4];
+ int32_t int32[4];
+ uint32_t uint32[4];
+} VkClearColorValue;
+
+typedef struct VkCommandBufferAllocateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkCommandPool WINE_VK_ALIGN(8) commandPool;
+ VkCommandBufferLevel level;
+ uint32_t commandBufferCount;
+} VkCommandBufferAllocateInfo;
+
+typedef struct VkCommandBufferInheritanceInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkRenderPass WINE_VK_ALIGN(8) renderPass;
+ uint32_t subpass;
+ VkFramebuffer WINE_VK_ALIGN(8) framebuffer;
+ VkBool32 occlusionQueryEnable;
+ VkQueryControlFlags queryFlags;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+} VkCommandBufferInheritanceInfo;
+
+typedef struct VkComponentMapping
+{
+ VkComponentSwizzle r;
+ VkComponentSwizzle g;
+ VkComponentSwizzle b;
+ VkComponentSwizzle a;
+} VkComponentMapping;
+
+typedef struct VkCopyDescriptorSet
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDescriptorSet WINE_VK_ALIGN(8) srcSet;
+ uint32_t srcBinding;
+ uint32_t srcArrayElement;
+ VkDescriptorSet WINE_VK_ALIGN(8) dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+} VkCopyDescriptorSet;
+
+typedef struct VkDescriptorImageInfo
+{
+ VkSampler WINE_VK_ALIGN(8) sampler;
+ VkImageView WINE_VK_ALIGN(8) imageView;
+ VkImageLayout imageLayout;
+} VkDescriptorImageInfo;
+
+typedef struct VkDescriptorPoolSize
+{
+ VkDescriptorType type;
+ uint32_t descriptorCount;
+} VkDescriptorPoolSize;
+
+typedef struct VkDescriptorSetLayoutBinding
+{
+ uint32_t binding;
+ VkDescriptorType descriptorType;
+ uint32_t descriptorCount;
+ VkShaderStageFlags stageFlags;
+ const VkSampler *pImmutableSamplers;
+} VkDescriptorSetLayoutBinding;
+
+typedef struct VkDispatchIndirectCommand
+{
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+} VkDispatchIndirectCommand;
+
+typedef struct VkDrawIndirectCommand
+{
+ uint32_t vertexCount;
+ uint32_t instanceCount;
+ uint32_t firstVertex;
+ uint32_t firstInstance;
+} VkDrawIndirectCommand;
+
+typedef struct VkExtensionProperties
+{
+ char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+} VkExtensionProperties;
+
+typedef struct VkExtent3D
+{
+ uint32_t width;
+ uint32_t height;
+ uint32_t depth;
+} VkExtent3D;
+
+typedef struct VkFormatProperties
+{
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
+ VkFormatFeatureFlags bufferFeatures;
+} VkFormatProperties;
+
+typedef struct VkFramebufferCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkFramebufferCreateFlags flags;
+ VkRenderPass WINE_VK_ALIGN(8) renderPass;
+ uint32_t attachmentCount;
+ const VkImageView *pAttachments;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layers;
+} VkFramebufferCreateInfo;
+
+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 VkImageSubresource
+{
+ VkImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t arrayLayer;
+} VkImageSubresource;
+
+typedef struct VkImageSubresourceRange
+{
+ VkImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+ uint32_t levelCount;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+} VkImageSubresourceRange;
+
+typedef struct VkImageViewCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkImageViewCreateFlags flags;
+ VkImage WINE_VK_ALIGN(8) image;
+ VkImageViewType viewType;
+ VkFormat format;
+ VkComponentMapping components;
+ VkImageSubresourceRange subresourceRange;
+} VkImageViewCreateInfo;
+
+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 VkMappedMemoryRange
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDeviceMemory WINE_VK_ALIGN(8) memory;
+ VkDeviceSize WINE_VK_ALIGN(8) offset;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+} VkMappedMemoryRange;
+
+typedef struct VkMemoryAllocateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDeviceSize WINE_VK_ALIGN(8) allocationSize;
+ uint32_t memoryTypeIndex;
+} VkMemoryAllocateInfo;
+
+typedef struct VkMemoryRequirements
+{
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkDeviceSize WINE_VK_ALIGN(8) alignment;
+ uint32_t memoryTypeBits;
+} VkMemoryRequirements;
+
+typedef struct VkOffset3D
+{
+ int32_t x;
+ int32_t y;
+ int32_t z;
+} VkOffset3D;
+
+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 VkPipelineColorBlendAttachmentState
+{
+ VkBool32 blendEnable;
+ VkBlendFactor srcColorBlendFactor;
+ VkBlendFactor dstColorBlendFactor;
+ VkBlendOp colorBlendOp;
+ VkBlendFactor srcAlphaBlendFactor;
+ VkBlendFactor dstAlphaBlendFactor;
+ VkBlendOp alphaBlendOp;
+ VkColorComponentFlags colorWriteMask;
+} VkPipelineColorBlendAttachmentState;
+
+typedef struct VkPipelineInputAssemblyStateCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineInputAssemblyStateCreateFlags flags;
+ VkPrimitiveTopology topology;
+ VkBool32 primitiveRestartEnable;
+} VkPipelineInputAssemblyStateCreateInfo;
+
+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 VkPipelineTessellationStateCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineTessellationStateCreateFlags flags;
+ uint32_t patchControlPoints;
+} VkPipelineTessellationStateCreateInfo;
+
+typedef struct VkQueryPoolCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkQueryPoolCreateFlags flags;
+ VkQueryType queryType;
+ uint32_t queryCount;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+} VkQueryPoolCreateInfo;
+
+typedef struct VkSemaphoreCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkSemaphoreCreateFlags flags;
+} VkSemaphoreCreateInfo;
+
+typedef struct VkSparseImageFormatProperties
+{
+ VkImageAspectFlags aspectMask;
+ VkExtent3D imageGranularity;
+ VkSparseImageFormatFlags flags;
+} VkSparseImageFormatProperties;
+
+typedef struct VkSparseImageMemoryBind
+{
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+ VkDeviceMemory WINE_VK_ALIGN(8) memory;
+ VkDeviceSize WINE_VK_ALIGN(8) memoryOffset;
+ VkSparseMemoryBindFlags flags;
+} VkSparseImageMemoryBind;
+
+typedef struct VkSparseImageMemoryRequirements
+{
+ VkSparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailFirstLod;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailSize;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailOffset;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailStride;
+} VkSparseImageMemoryRequirements;
+
+typedef struct VkSparseMemoryBind
+{
+ VkDeviceSize WINE_VK_ALIGN(8) resourceOffset;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkDeviceMemory WINE_VK_ALIGN(8) memory;
+ VkDeviceSize WINE_VK_ALIGN(8) memoryOffset;
+ VkSparseMemoryBindFlags flags;
+} VkSparseMemoryBind;
+
+typedef struct VkSpecializationMapEntry
+{
+ uint32_t constantID;
+ uint32_t offset;
+ size_t size;
+} VkSpecializationMapEntry;
+
+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 VkSubresourceLayout
+{
+ VkDeviceSize WINE_VK_ALIGN(8) offset;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkDeviceSize WINE_VK_ALIGN(8) rowPitch;
+ VkDeviceSize WINE_VK_ALIGN(8) arrayPitch;
+ VkDeviceSize WINE_VK_ALIGN(8) depthPitch;
+} VkSubresourceLayout;
+
+typedef struct VkVertexInputAttributeDescription
+{
+ uint32_t location;
+ uint32_t binding;
+ VkFormat format;
+ uint32_t offset;
+} VkVertexInputAttributeDescription;
+
+typedef struct VkAllocationCallbacks
+{
+ void *pUserData;
+ PFN_vkAllocationFunction pfnAllocation;
+ PFN_vkReallocationFunction pfnReallocation;
+ PFN_vkFreeFunction pfnFree;
+ PFN_vkInternalAllocationNotification pfnInternalAllocation;
+ PFN_vkInternalFreeNotification pfnInternalFree;
+} VkAllocationCallbacks;
+
+typedef struct VkAttachmentReference
+{
+ uint32_t attachment;
+ VkImageLayout layout;
+} VkAttachmentReference;
+
+typedef struct VkBufferCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkBufferCreateFlags flags;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkBufferUsageFlags usage;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t *pQueueFamilyIndices;
+} VkBufferCreateInfo;
+
+typedef struct VkBufferViewCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkBufferViewCreateFlags flags;
+ VkBuffer WINE_VK_ALIGN(8) buffer;
+ VkFormat format;
+ VkDeviceSize WINE_VK_ALIGN(8) offset;
+ VkDeviceSize WINE_VK_ALIGN(8) range;
+} VkBufferViewCreateInfo;
+
+typedef struct VkClearDepthStencilValue
+{
+ float depth;
+ uint32_t stencil;
+} VkClearDepthStencilValue;
+
+typedef union VkClearValue
+{
+ VkClearColorValue color;
+ VkClearDepthStencilValue depthStencil;
+} VkClearValue;
+
+typedef struct VkCommandBufferBeginInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkCommandBufferUsageFlags flags;
+ const VkCommandBufferInheritanceInfo *pInheritanceInfo;
+} VkCommandBufferBeginInfo;
+
+typedef struct VkDescriptorBufferInfo
+{
+ VkBuffer WINE_VK_ALIGN(8) buffer;
+ VkDeviceSize WINE_VK_ALIGN(8) offset;
+ VkDeviceSize WINE_VK_ALIGN(8) range;
+} VkDescriptorBufferInfo;
+
+typedef struct VkDescriptorSetAllocateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDescriptorPool WINE_VK_ALIGN(8) descriptorPool;
+ uint32_t descriptorSetCount;
+ const VkDescriptorSetLayout *pSetLayouts;
+} VkDescriptorSetAllocateInfo;
+
+typedef struct VkEventCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkEventCreateFlags flags;
+} VkEventCreateInfo;
+
+typedef struct VkExtent2D
+{
+ uint32_t width;
+ uint32_t height;
+} VkExtent2D;
+
+typedef struct VkImageFormatProperties
+{
+ VkExtent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ VkDeviceSize WINE_VK_ALIGN(8) maxResourceSize;
+} VkImageFormatProperties;
+
+typedef struct VkImageSubresourceLayers
+{
+ VkImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+} VkImageSubresourceLayers;
+
+typedef struct VkMemoryBarrier
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+} VkMemoryBarrier;
+
+typedef struct VkMemoryType
+{
+ VkMemoryPropertyFlags propertyFlags;
+ uint32_t heapIndex;
+} VkMemoryType;
+
+typedef struct VkPipelineCacheCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineCacheCreateFlags flags;
+ size_t initialDataSize;
+ const void *pInitialData;
+} VkPipelineCacheCreateInfo;
+
+typedef struct VkPipelineDynamicStateCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const VkDynamicState *pDynamicStates;
+} VkPipelineDynamicStateCreateInfo;
+
+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 VkQueueFamilyProperties
+{
+ VkQueueFlags queueFlags;
+ uint32_t queueCount;
+ uint32_t timestampValidBits;
+ VkExtent3D minImageTransferGranularity;
+} VkQueueFamilyProperties;
+
+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 VkSparseBufferMemoryBindInfo
+{
+ VkBuffer WINE_VK_ALIGN(8) buffer;
+ uint32_t bindCount;
+ const VkSparseMemoryBind *pBinds;
+} VkSparseBufferMemoryBindInfo;
+
+typedef struct VkSparseImageMemoryBindInfo
+{
+ VkImage WINE_VK_ALIGN(8) image;
+ uint32_t bindCount;
+ const VkSparseImageMemoryBind *pBinds;
+} VkSparseImageMemoryBindInfo;
+
+typedef struct VkSpecializationInfo
+{
+ uint32_t mapEntryCount;
+ const VkSpecializationMapEntry *pMapEntries;
+ size_t dataSize;
+ const void *pData;
+} VkSpecializationInfo;
+
+typedef struct VkSubpassDependency
+{
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags dstStageMask;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkDependencyFlags dependencyFlags;
+} VkSubpassDependency;
+
+typedef struct VkViewport
+{
+ float x;
+ float y;
+ float width;
+ float height;
+ float minDepth;
+ float maxDepth;
+} VkViewport;
+
+typedef struct VkWriteDescriptorSet
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDescriptorSet WINE_VK_ALIGN(8) dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ VkDescriptorType descriptorType;
+ const VkDescriptorImageInfo *pImageInfo;
+ const VkDescriptorBufferInfo *pBufferInfo;
+ const VkBufferView *pTexelBufferView;
+} VkWriteDescriptorSet;
+
+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 VkBufferImageCopy
+{
+ VkDeviceSize WINE_VK_ALIGN(8) bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
+ VkImageSubresourceLayers imageSubresource;
+ VkOffset3D imageOffset;
+ VkExtent3D imageExtent;
+} VkBufferImageCopy;
+
+typedef struct VkDescriptorPoolCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t poolSizeCount;
+ const VkDescriptorPoolSize *pPoolSizes;
+} VkDescriptorPoolCreateInfo;
+
+typedef struct VkDeviceQueueCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueCount;
+ const float *pQueuePriorities;
+} VkDeviceQueueCreateInfo;
+
+typedef struct VkFenceCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkFenceCreateFlags flags;
+} VkFenceCreateInfo;
+
+typedef struct VkImageBlit
+{
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffsets[2];
+ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffsets[2];
+} VkImageBlit;
+
+typedef struct VkImageMemoryBarrier
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkImage WINE_VK_ALIGN(8) image;
+ VkImageSubresourceRange subresourceRange;
+} VkImageMemoryBarrier;
+
+typedef struct VkOffset2D
+{
+ int32_t x;
+ int32_t y;
+} VkOffset2D;
+
+typedef struct VkPhysicalDeviceSparseProperties
+{
+ VkBool32 residencyStandard2DBlockShape;
+ VkBool32 residencyStandard2DMultisampleBlockShape;
+ VkBool32 residencyStandard3DBlockShape;
+ VkBool32 residencyAlignedMipSize;
+ VkBool32 residencyNonResidentStrict;
+} VkPhysicalDeviceSparseProperties;
+
+typedef struct VkPipelineShaderStageCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineShaderStageCreateFlags flags;
+ VkShaderStageFlagBits stage;
+ VkShaderModule WINE_VK_ALIGN(8) module;
+ const char *pName;
+ const VkSpecializationInfo *pSpecializationInfo;
+} VkPipelineShaderStageCreateInfo;
+
+typedef struct VkRect2D
+{
+ VkOffset2D offset;
+ VkExtent2D extent;
+} VkRect2D;
+
+typedef struct VkShaderModuleCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkShaderModuleCreateFlags flags;
+ size_t codeSize;
+ const uint32_t *pCode;
+} VkShaderModuleCreateInfo;
+
+typedef struct VkSparseImageOpaqueMemoryBindInfo
+{
+ VkImage WINE_VK_ALIGN(8) image;
+ uint32_t bindCount;
+ const VkSparseMemoryBind *pBinds;
+} VkSparseImageOpaqueMemoryBindInfo;
+
+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 VkClearAttachment
+{
+ VkImageAspectFlags aspectMask;
+ uint32_t colorAttachment;
+ VkClearValue clearValue;
+} VkClearAttachment;
+
+typedef struct VkCommandPoolCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkCommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+} VkCommandPoolCreateInfo;
+
+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 VkImageCopy
+{
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D extent;
+} VkImageCopy;
+
+typedef struct VkMemoryHeap
+{
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkMemoryHeapFlags flags;
+} VkMemoryHeap;
+
+typedef struct VkPhysicalDeviceMemoryProperties
+{
+ uint32_t memoryTypeCount;
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryProperties;
+
+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 VkPipelineViewportStateCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineViewportStateCreateFlags flags;
+ uint32_t viewportCount;
+ const VkViewport *pViewports;
+ uint32_t scissorCount;
+ const VkRect2D *pScissors;
+} VkPipelineViewportStateCreateInfo;
+
+typedef struct VkRenderPassBeginInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkRenderPass WINE_VK_ALIGN(8) renderPass;
+ VkFramebuffer WINE_VK_ALIGN(8) framebuffer;
+ VkRect2D renderArea;
+ uint32_t clearValueCount;
+ const VkClearValue *pClearValues;
+} VkRenderPassBeginInfo;
+
+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 VkComputePipelineCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkPipelineCreateFlags flags;
+ VkPipelineShaderStageCreateInfo WINE_VK_ALIGN(8) stage;
+ VkPipelineLayout WINE_VK_ALIGN(8) layout;
+ VkPipeline WINE_VK_ALIGN(8) basePipelineHandle;
+ int32_t basePipelineIndex;
+} VkComputePipelineCreateInfo;
+
+typedef struct VkImageResolve
+{
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D extent;
+} VkImageResolve;
+
+typedef struct VkPushConstantRange
+{
+ VkShaderStageFlags stageFlags;
+ uint32_t offset;
+ uint32_t size;
+} VkPushConstantRange;
+
+typedef struct VkStencilOpState
+{
+ VkStencilOp failOp;
+ VkStencilOp passOp;
+ VkStencilOp depthFailOp;
+ VkCompareOp compareOp;
+ uint32_t compareMask;
+ uint32_t writeMask;
+ uint32_t reference;
+} VkStencilOpState;
+
+typedef struct VkClearRect
+{
+ VkRect2D rect;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+} VkClearRect;
+
+typedef struct VkDrawIndexedIndirectCommand
+{
+ uint32_t indexCount;
+ uint32_t instanceCount;
+ uint32_t firstIndex;
+ int32_t vertexOffset;
+ uint32_t firstInstance;
+} VkDrawIndexedIndirectCommand;
+
+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 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 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 VkDescriptorSetLayoutCreateInfo
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ const VkDescriptorSetLayoutBinding *pBindings;
+} VkDescriptorSetLayoutCreateInfo;
+
+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 WINE_VK_ALIGN(8) bufferImageGranularity;
+ VkDeviceSize WINE_VK_ALIGN(8) 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 WINE_VK_ALIGN(8) minTexelBufferOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) minUniformBufferOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) 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 WINE_VK_ALIGN(8) optimalBufferCopyOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyRowPitchAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize;
+} VkPhysicalDeviceLimits;
+
+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 VkVertexInputBindingDescription
+{
+ uint32_t binding;
+ uint32_t stride;
+ VkVertexInputRate inputRate;
+} VkVertexInputBindingDescription;
+
+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 WINE_VK_ALIGN(8) limits;
+ VkPhysicalDeviceSparseProperties sparseProperties;
+} VkPhysicalDeviceProperties;
+
+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 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 WINE_VK_ALIGN(8) layout;
+ VkRenderPass WINE_VK_ALIGN(8) renderPass;
+ uint32_t subpass;
+ VkPipeline WINE_VK_ALIGN(8) basePipelineHandle;
+ int32_t basePipelineIndex;
+} VkGraphicsPipelineCreateInfo;
+
+VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers);
+VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets);
+VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory);
+VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo);
+VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents);
+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);
+void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets);
+void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter);
+void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects);
+void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
+void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
+void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions);
+void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions);
+void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions);
+void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions);
+void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer);
+void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+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);
+void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues);
+void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions);
+void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
+void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors);
+void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports);
+void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData);
+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);
+void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
+VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer);
+VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView);
+VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool);
+VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines);
+VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool);
+VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout);
+VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
+VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent);
+VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence);
+VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer);
+VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines);
+VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage);
+VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView);
+VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
+VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache);
+VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout);
+VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool);
+VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass);
+VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler);
+VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore);
+VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule);
+void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator);
+VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device);
+VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer);
+VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties);
+VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties);
+VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices);
+VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges);
+void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets);
+void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements);
+void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes);
+PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName);
+void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
+VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event);
+VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence);
+void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements);
+void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements);
+void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout);
+PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName);
+void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures);
+void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties);
+VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties);
+void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties);
+void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties);
+void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties);
+void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties);
+VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData);
+VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags);
+void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity);
+VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges);
+VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData);
+VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches);
+VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence);
+VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence);
+VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue);
+VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event);
+VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences);
+VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event);
+void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory);
+void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies);
+VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout);
+
+#endif /* __WINE_VULKAN_H */