mirror of
https://github.com/odin-lang/Odin.git
synced 2026-04-28 01:03:56 +00:00
Add vendor:vulkan
This commit is contained in:
gingerBill
608
vendor/vulkan/_gen/create_vulkan_odin_wrapper.py
vendored
Normal file
608
vendor/vulkan/_gen/create_vulkan_odin_wrapper.py
vendored
Normal file
@@ -0,0 +1,608 @@
|
||||
import re
|
||||
import urllib.request as req
|
||||
from tokenize import tokenize
|
||||
from io import BytesIO
|
||||
import string
|
||||
import os.path
|
||||
import math
|
||||
|
||||
file_and_urls = [
|
||||
("vk_platform.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_platform.h', True),
|
||||
("vulkan_core.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h', False),
|
||||
("vk_layer.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_layer.h', False),
|
||||
("vk_icd.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_icd.h', False),
|
||||
("vulkan_win32.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_win32.h', False),
|
||||
("vulkan_metal.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_metal.h', False),
|
||||
("vulkan_macos.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_macos.h', False),
|
||||
("vulkan_ios.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_ios.h', False),
|
||||
]
|
||||
|
||||
for file, url, _ in file_and_urls:
|
||||
if not os.path.isfile(file):
|
||||
with open(file, 'w', encoding='utf-8') as f:
|
||||
f.write(req.urlopen(url).read().decode('utf-8'))
|
||||
|
||||
src = ""
|
||||
for file, _, skip in file_and_urls:
|
||||
if skip: continue
|
||||
with open(file, 'r', encoding='utf-8') as f:
|
||||
src += f.read()
|
||||
|
||||
|
||||
def no_vk(t):
|
||||
t = t.replace('Vk', '')
|
||||
t = t.replace('PFN_vk_icd', 'Procicd')
|
||||
t = t.replace('PFN_vk', 'Proc')
|
||||
t = t.replace('PFN_', 'Proc')
|
||||
t = t.replace('PFN_', 'Proc')
|
||||
t = t.replace('VK_', '')
|
||||
return t
|
||||
|
||||
def convert_type(t):
|
||||
table = {
|
||||
"Bool32": 'b32',
|
||||
"float": 'f32',
|
||||
"double": 'f64',
|
||||
"uint32_t": 'u32',
|
||||
"uint64_t": 'u64',
|
||||
"size_t": 'int',
|
||||
'int32_t': 'i32',
|
||||
'int64_t': 'i64',
|
||||
'int': 'c.int',
|
||||
'uint8_t': 'u8',
|
||||
"uint16_t": 'u16',
|
||||
"char": "byte",
|
||||
"void": "void",
|
||||
"void*": "rawptr",
|
||||
"void *": "rawptr",
|
||||
"char*": 'cstring',
|
||||
"const uint32_t* const*": "^^u32",
|
||||
"const void*": 'rawptr',
|
||||
"const char*": 'cstring',
|
||||
"const char* const*": 'cstring_array',
|
||||
"const ObjectTableEntryNVX* const*": "^^ObjectTableEntryNVX",
|
||||
"const void* const *": "^rawptr",
|
||||
"const AccelerationStructureGeometryKHR* const*": "^^AccelerationStructureGeometryKHR",
|
||||
"const AccelerationStructureBuildRangeInfoKHR* const*": "^^AccelerationStructureBuildRangeInfoKHR",
|
||||
"struct BaseOutStructure": "BaseOutStructure",
|
||||
"struct BaseInStructure": "BaseInStructure",
|
||||
'v': '',
|
||||
}
|
||||
|
||||
if t in table.keys():
|
||||
return table[t]
|
||||
|
||||
if t == "":
|
||||
return t
|
||||
elif t.endswith("*"):
|
||||
if t.startswith("const"):
|
||||
ttype = t[6:len(t)-1]
|
||||
return "^{}".format(convert_type(ttype))
|
||||
else:
|
||||
ttype = t[:len(t)-1]
|
||||
return "^{}".format(convert_type(ttype))
|
||||
elif t[0].isupper():
|
||||
return t
|
||||
|
||||
return t
|
||||
|
||||
def parse_array(n, t):
|
||||
name, length = n.split('[', 1)
|
||||
length = no_vk(length[:-1])
|
||||
type_ = "[{}]{}".format(length, do_type(t))
|
||||
return name, type_
|
||||
|
||||
def remove_prefix(text, prefix):
|
||||
if text.startswith(prefix):
|
||||
return text[len(prefix):]
|
||||
return text
|
||||
def remove_suffix(text, suffix):
|
||||
if text.endswith(suffix):
|
||||
return text[:-len(suffix)]
|
||||
return text
|
||||
|
||||
|
||||
def to_snake_case(name):
|
||||
s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
|
||||
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
|
||||
|
||||
ext_suffixes = ["KHR", "EXT", "AMD", "NV", "NVX", "GOOGLE"]
|
||||
ext_suffixes_title = [ext.title() for ext in ext_suffixes]
|
||||
|
||||
|
||||
def fix_arg(arg):
|
||||
name = arg
|
||||
|
||||
# Remove useless pointer identifier in field name
|
||||
for p in ('s_', 'p_', 'pp_', 'pfn_'):
|
||||
if name.startswith(p):
|
||||
name = name[len(p)::]
|
||||
name = name.replace("__", "_")
|
||||
|
||||
return name
|
||||
|
||||
|
||||
def fix_ext_suffix(name):
|
||||
for ext in ext_suffixes_title:
|
||||
if name.endswith(ext):
|
||||
start = name[:-len(ext)]
|
||||
end = name[-len(ext):].upper()
|
||||
return start+end
|
||||
return name
|
||||
|
||||
def to_int(x):
|
||||
if x.startswith('0x'):
|
||||
return int(x, 16)
|
||||
return int(x)
|
||||
|
||||
def is_int(x):
|
||||
try:
|
||||
int(x)
|
||||
return True
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
def fix_enum_arg(name, is_flag_bit=False):
|
||||
# name = name.title()
|
||||
name = fix_ext_suffix(name)
|
||||
if len(name) > 0 and name[0].isdigit() and not name.startswith("0x") and not is_int(name):
|
||||
if name[1] == "D":
|
||||
name = name[1] + name[0] + (name[2:] if len(name) > 2 else "")
|
||||
else:
|
||||
name = "_"+name
|
||||
if is_flag_bit:
|
||||
name = name.replace("_BIT", "")
|
||||
return name
|
||||
|
||||
def do_type(t):
|
||||
return convert_type(no_vk(t)).replace("FlagBits", "Flags")
|
||||
|
||||
def parse_handles_def(f):
|
||||
f.write("// Handles types\n")
|
||||
handles = [h for h in re.findall(r"VK_DEFINE_HANDLE\(Vk(\w+)\)", src, re.S)]
|
||||
|
||||
max_len = max(len(h) for h in handles)
|
||||
for h in handles:
|
||||
f.write("{} :: distinct Handle;\n".format(h.ljust(max_len)))
|
||||
|
||||
handles_non_dispatchable = [h for h in re.findall(r"VK_DEFINE_NON_DISPATCHABLE_HANDLE\(Vk(\w+)\)", src, re.S)]
|
||||
max_len = max(len(h) for h in handles_non_dispatchable)
|
||||
for h in handles_non_dispatchable:
|
||||
f.write("{} :: distinct NonDispatchableHandle;\n".format(h.ljust(max_len)))
|
||||
|
||||
|
||||
flags_defs = set()
|
||||
|
||||
def parse_flags_def(f):
|
||||
names = [n for n in re.findall(r"typedef VkFlags Vk(\w+?);", src)]
|
||||
|
||||
global flags_defs
|
||||
flags_defs = set(names)
|
||||
|
||||
|
||||
class FlagError(ValueError):
|
||||
pass
|
||||
class IgnoreFlagError(ValueError):
|
||||
pass
|
||||
|
||||
def fix_enum_name(name, prefix, suffix, is_flag_bit):
|
||||
name = remove_prefix(name, prefix)
|
||||
if suffix:
|
||||
name = remove_suffix(name, suffix)
|
||||
if name.startswith("0x"):
|
||||
if is_flag_bit:
|
||||
i = int(name, 16)
|
||||
if i == 0:
|
||||
raise IgnoreFlagError(i)
|
||||
v = int(math.log2(i))
|
||||
if 2**v != i:
|
||||
raise FlagError(i)
|
||||
return str(v)
|
||||
return name
|
||||
elif is_flag_bit:
|
||||
ignore = False
|
||||
try:
|
||||
if int(name) == 0:
|
||||
ignore = True
|
||||
except:
|
||||
pass
|
||||
if ignore:
|
||||
raise IgnoreFlagError()
|
||||
|
||||
return fix_enum_arg(name, is_flag_bit)
|
||||
|
||||
|
||||
def fix_enum_value(value, prefix, suffix, is_flag_bit):
|
||||
v = no_vk(value)
|
||||
g = tokenize(BytesIO(v.encode('utf-8')).readline)
|
||||
tokens = [val for _, val, _, _, _ in g]
|
||||
assert len(tokens) > 2
|
||||
token = ''.join([t for t in tokens[1:-1] if t])
|
||||
token = fix_enum_name(token, prefix, suffix, is_flag_bit)
|
||||
return token
|
||||
|
||||
def parse_constants(f):
|
||||
f.write("// General Constants\n");
|
||||
all_data = re.findall(r"#define VK_(\w+)\s*(.*?)U?\n", src, re.S)
|
||||
allowed_names = (
|
||||
"HEADER_VERSION",
|
||||
"MAX_DRIVER_NAME_SIZE",
|
||||
"MAX_DRIVER_INFO_SIZE",
|
||||
)
|
||||
allowed_data = [nv for nv in all_data if nv[0] in allowed_names]
|
||||
max_len = max(len(name) for name, value in allowed_data)
|
||||
for name, value in allowed_data:
|
||||
f.write("{}{} :: {};\n".format(name, "".rjust(max_len-len(name)), value))
|
||||
|
||||
f.write("\n// Vendor Constants\n");
|
||||
data = re.findall(r"#define VK_((?:"+'|'.join(ext_suffixes)+r")\w+)\s*(.*?)\n", src, re.S)
|
||||
max_len = max(len(name) for name, value in data)
|
||||
for name, value in data:
|
||||
f.write("{}{} :: {};\n".format(name, "".rjust(max_len-len(name)), value))
|
||||
f.write("\n")
|
||||
|
||||
|
||||
def parse_enums(f):
|
||||
f.write("// Enums\n")
|
||||
|
||||
data = re.findall(r"typedef enum Vk(\w+) {(.+?)} \w+;", src, re.S)
|
||||
|
||||
generated_flags = set()
|
||||
|
||||
for name, fields in data:
|
||||
enum_name = name
|
||||
|
||||
is_flag_bit = False
|
||||
if "FlagBits" in enum_name:
|
||||
is_flag_bit = True
|
||||
flags_name = enum_name.replace("FlagBits", "Flags")
|
||||
enum_name = enum_name.replace("FlagBits", "Flag")
|
||||
generated_flags.add(flags_name)
|
||||
f.write("{} :: distinct bit_set[{}; Flags];\n".format(flags_name, enum_name))
|
||||
|
||||
|
||||
if is_flag_bit:
|
||||
f.write("{} :: enum Flags {{\n".format(name.replace("FlagBits", "Flag")))
|
||||
else:
|
||||
f.write("{} :: enum c.int {{\n".format(name))
|
||||
|
||||
prefix = to_snake_case(name).upper()
|
||||
suffix = None
|
||||
for ext in ext_suffixes:
|
||||
prefix_new = remove_suffix(prefix, "_"+ext)
|
||||
assert suffix is None
|
||||
if prefix_new != prefix:
|
||||
suffix = "_"+ext
|
||||
prefix = prefix_new
|
||||
break
|
||||
|
||||
|
||||
prefix = prefix.replace("_FLAG_BITS", "")
|
||||
prefix += "_"
|
||||
|
||||
ff = []
|
||||
|
||||
names_and_values = re.findall(r"VK_(\w+?) = (.*?)(?:,|})", fields, re.S)
|
||||
|
||||
groups = []
|
||||
flags = {}
|
||||
|
||||
for name, value in names_and_values:
|
||||
n = fix_enum_name(name, prefix, suffix, is_flag_bit)
|
||||
try:
|
||||
v = fix_enum_value(value, prefix, suffix, is_flag_bit)
|
||||
except FlagError as e:
|
||||
v = int(str(e))
|
||||
groups.append((n, v))
|
||||
continue
|
||||
except IgnoreFlagError as e:
|
||||
groups.append((n, 0))
|
||||
continue
|
||||
|
||||
if n == v:
|
||||
continue
|
||||
try:
|
||||
flags[int(v)] = n
|
||||
except ValueError as e:
|
||||
pass
|
||||
|
||||
if v == "NONE":
|
||||
continue
|
||||
|
||||
ff.append((n, v))
|
||||
|
||||
max_flag_value = max([int(v) for n, v in ff if is_int(v)] + [0])
|
||||
max_group_value = max([int(v) for n, v in groups if is_int(v)] + [0])
|
||||
if max_flag_value < max_group_value:
|
||||
if (1<<max_flag_value)+1 < max_group_value:
|
||||
ff.append(('_MAX', 31))
|
||||
flags[31] = '_MAX'
|
||||
pass
|
||||
|
||||
max_len = max([len(n) for n, v in ff] + [0])
|
||||
|
||||
flag_names = set([n for n, v in ff])
|
||||
|
||||
for n, v in ff:
|
||||
if is_flag_bit and not is_int(v) and v not in flag_names:
|
||||
print("Ignoring", n, "=", v)
|
||||
continue
|
||||
f.write("\t{} = {},".format(n.ljust(max_len), v))
|
||||
if n == "_MAX":
|
||||
f.write(" // Needed for the *_ALL bit set")
|
||||
f.write("\n")
|
||||
|
||||
|
||||
|
||||
f.write("}\n\n")
|
||||
|
||||
for n, v in groups:
|
||||
used_flags = []
|
||||
for i in range(0, 32):
|
||||
if 1<<i & v != 0:
|
||||
if i in flags:
|
||||
used_flags.append('.'+flags[i])
|
||||
else:
|
||||
used_flags.append('{}({})'.format(enum_name, i))
|
||||
s = "{enum_name}s_{n} :: {enum_name}s{{".format(enum_name=enum_name, n=n);
|
||||
s += ', '.join(used_flags)
|
||||
s += "};\n"
|
||||
f.write(s)
|
||||
|
||||
if len(groups) > 0:
|
||||
f.write("\n\n")
|
||||
|
||||
|
||||
unused_flags = [flag for flag in flags_defs if flag not in generated_flags]
|
||||
|
||||
max_len = max(len(flag) for flag in unused_flags)
|
||||
for flag in unused_flags:
|
||||
flag_name = flag.replace("Flags", "Flag")
|
||||
f.write("{} :: distinct bit_set[{}; Flags];\n".format(flag.ljust(max_len), flag_name))
|
||||
f.write("{} :: enum u32 {{}};\n".format(flag_name.ljust(max_len)))
|
||||
|
||||
|
||||
|
||||
def parse_structs(f):
|
||||
data = re.findall(r"typedef (struct|union) Vk(\w+?) {(.+?)} \w+?;", src, re.S)
|
||||
|
||||
for _type, name, fields in data:
|
||||
fields = re.findall(r"\s+(.+?)\s+([_a-zA-Z0-9[\]]+);", fields)
|
||||
f.write("{} :: struct ".format(name))
|
||||
if _type == "union":
|
||||
f.write("#raw_union ")
|
||||
f.write("{\n")
|
||||
|
||||
ffields = []
|
||||
for type_, fname in fields:
|
||||
if '[' in fname:
|
||||
fname, type_ = parse_array(fname, type_)
|
||||
comment = None
|
||||
n = fix_arg(fname)
|
||||
if "Flag_Bits" in type_:
|
||||
comment = " // only single bit set"
|
||||
t = do_type(type_)
|
||||
if t == "Structure_Type" and n == "type":
|
||||
n = "s_type"
|
||||
|
||||
ffields.append(tuple([n, t, comment]))
|
||||
|
||||
max_len = max(len(n) for n, _, _ in ffields)
|
||||
|
||||
for n, t, comment in ffields:
|
||||
k = max_len-len(n)+len(t)
|
||||
f.write("\t{}: {},{}\n".format(n, t.rjust(k), comment or ""))
|
||||
|
||||
|
||||
f.write("}\n\n")
|
||||
|
||||
|
||||
f.write("// Aliases\n")
|
||||
data = re.findall(r"typedef Vk(\w+?) Vk(\w+?);", src, re.S)
|
||||
aliases = []
|
||||
for _type, name in data:
|
||||
if _type == "Flags":
|
||||
continue
|
||||
name = name.replace("FlagBits", "Flag")
|
||||
_type = _type.replace("FlagBits", "Flag")
|
||||
aliases.append((name, _type))
|
||||
|
||||
max_len = max([len(n) for n, _ in aliases] + [0])
|
||||
for n, t in aliases:
|
||||
k = max_len
|
||||
f.write("{} :: {};\n".format(n.ljust(k), t))
|
||||
|
||||
|
||||
|
||||
procedure_map = {}
|
||||
|
||||
def parse_procedures(f):
|
||||
data = re.findall(r"typedef (\w+\*?) \(\w+ \*(\w+)\)\((.+?)\);", src, re.S)
|
||||
|
||||
ff = []
|
||||
|
||||
for rt, name, fields in data:
|
||||
proc_name = no_vk(name)
|
||||
pf = [(do_type(t), fix_arg(n)) for t, n in re.findall(r"(?:\s*|)(.+?)\s*(\w+)(?:,|$)", fields)]
|
||||
data_fields = ', '.join(["{}: {}".format(n, t) for t, n in pf if t != ""])
|
||||
|
||||
ts = "proc \"c\" ({})".format(data_fields)
|
||||
rt_str = do_type(rt)
|
||||
if rt_str != "void":
|
||||
ts += " -> {}".format(rt_str)
|
||||
|
||||
procedure_map[proc_name] = ts
|
||||
ff.append( (proc_name, ts) )
|
||||
|
||||
max_len = max(len(n) for n, t in ff)
|
||||
|
||||
f.write("// Procedure Types\n\n");
|
||||
f.write("when ODIN_OS == \"windows\" {\n");
|
||||
for n, t in ff:
|
||||
f.write("\t{} :: #type {};\n".format(n.ljust(max_len), t.replace('"c"', '"stdcall"')))
|
||||
f.write("} else {\n");
|
||||
for n, t in ff:
|
||||
f.write("\t{} :: #type {};\n".format(n.ljust(max_len), t))
|
||||
f.write("}\n\n");
|
||||
|
||||
def group_functions(f):
|
||||
data = re.findall(r"typedef (\w+\*?) \(\w+ \*(\w+)\)\((.+?)\);", src, re.S)
|
||||
group_map = {"Instance":[], "Device":[], "Loader":[]}
|
||||
|
||||
for rt, vkname, fields in data:
|
||||
fields_types_name = [do_type(t) for t in re.findall(r"(?:\s*|)(.+?)\s*\w+(?:,|$)", fields)]
|
||||
table_name = fields_types_name[0]
|
||||
name = no_vk(vkname)
|
||||
|
||||
nn = (fix_arg(name), fix_ext_suffix(name))
|
||||
|
||||
if table_name in ('Device', 'Queue', 'CommandBuffer') and name != 'GetDeviceProcAddr':
|
||||
group_map["Device"].append(nn)
|
||||
elif table_name in ('Instance', 'PhysicalDevice') or name == 'GetDeviceProcAddr':
|
||||
group_map["Instance"].append(nn)
|
||||
elif table_name in ('rawptr', '', 'DebugReportFlagsEXT') or name == 'GetInstanceProcAddr':
|
||||
# Skip the allocation function and the dll entry point
|
||||
pass
|
||||
else:
|
||||
group_map["Loader"].append(nn)
|
||||
|
||||
for group_name, group_lines in group_map.items():
|
||||
f.write("// {} Procedures\n".format(group_name))
|
||||
max_len = max(len(name) for name, _ in group_lines)
|
||||
for name, vk_name in group_lines:
|
||||
type_str = procedure_map[vk_name]
|
||||
f.write('{}: {};\n'.format(remove_prefix(name, "Proc"), name.rjust(max_len)))
|
||||
f.write("\n")
|
||||
|
||||
f.write("load_proc_addresses :: proc(set_proc_address: SetProcAddressType) {\n")
|
||||
for group_name, group_lines in group_map.items():
|
||||
f.write("\t// {} Procedures\n".format(group_name))
|
||||
max_len = max(len(name) for name, _ in group_lines)
|
||||
for name, vk_name in group_lines:
|
||||
k = max_len - len(name)
|
||||
f.write('\tset_proc_address(&{}, {}"vk{}");\n'.format(
|
||||
remove_prefix(name, 'Proc'),
|
||||
"".ljust(k),
|
||||
remove_prefix(vk_name, 'Proc'),
|
||||
))
|
||||
f.write("\n")
|
||||
f.write("}\n")
|
||||
|
||||
|
||||
|
||||
BASE = """
|
||||
//
|
||||
// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
|
||||
//
|
||||
package vulkan
|
||||
|
||||
import "core:c"
|
||||
"""[1::]
|
||||
|
||||
|
||||
with open("../core.odin", 'w', encoding='utf-8') as f:
|
||||
f.write(BASE)
|
||||
f.write("""
|
||||
API_VERSION_1_0 :: (1<<22) | (0<<12) | (0);
|
||||
|
||||
MAKE_VERSION :: proc(major, minor, patch: u32) -> u32 {
|
||||
return (major<<22) | (minor<<12) | (patch);
|
||||
}
|
||||
|
||||
// Base types
|
||||
Flags :: distinct u32;
|
||||
Flags64 :: distinct u64;
|
||||
DeviceSize :: distinct u64;
|
||||
DeviceAddress :: distinct u64;
|
||||
SampleMask :: distinct u32;
|
||||
|
||||
Handle :: distinct rawptr;
|
||||
NonDispatchableHandle :: distinct u64;
|
||||
|
||||
SetProcAddressType :: #type proc(p: rawptr, name: cstring);
|
||||
|
||||
|
||||
cstring_array :: ^cstring; // Helper Type
|
||||
|
||||
RemoteAddressNV :: distinct rawptr; // Declared inline before MemoryGetRemoteAddressInfoNV
|
||||
|
||||
// Base constants
|
||||
LOD_CLAMP_NONE :: 1000.0;
|
||||
REMAINING_MIP_LEVELS :: ~u32(0);
|
||||
REMAINING_ARRAY_LAYERS :: ~u32(0);
|
||||
WHOLE_SIZE :: ~u64(0);
|
||||
ATTACHMENT_UNUSED :: ~u32(0);
|
||||
TRUE :: 1;
|
||||
FALSE :: 0;
|
||||
QUEUE_FAMILY_IGNORED :: ~u32(0);
|
||||
SUBPASS_EXTERNAL :: ~u32(0);
|
||||
MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256;
|
||||
UUID_SIZE :: 16;
|
||||
MAX_MEMORY_TYPES :: 32;
|
||||
MAX_MEMORY_HEAPS :: 16;
|
||||
MAX_EXTENSION_NAME_SIZE :: 256;
|
||||
MAX_DESCRIPTION_SIZE :: 256;
|
||||
MAX_DEVICE_GROUP_SIZE_KHX :: 32;
|
||||
MAX_DEVICE_GROUP_SIZE :: 32;
|
||||
LUID_SIZE_KHX :: 8;
|
||||
LUID_SIZE_KHR :: 8;
|
||||
LUID_SIZE :: 8;
|
||||
MAX_DRIVER_NAME_SIZE_KHR :: 256;
|
||||
MAX_DRIVER_INFO_SIZE_KHR :: 256;
|
||||
MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(0)-1;
|
||||
MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16;
|
||||
|
||||
"""[1::])
|
||||
parse_constants(f)
|
||||
parse_handles_def(f)
|
||||
f.write("\n\n")
|
||||
parse_flags_def(f)
|
||||
with open("../enums.odin", 'w', encoding='utf-8') as f:
|
||||
f.write(BASE)
|
||||
f.write("\n")
|
||||
parse_enums(f)
|
||||
f.write("\n\n")
|
||||
with open("../structs.odin", 'w', encoding='utf-8') as f:
|
||||
f.write(BASE)
|
||||
f.write("""
|
||||
when ODIN_OS == "windows" {
|
||||
\timport win32 "core:sys/windows"
|
||||
|
||||
\tHINSTANCE :: win32.HINSTANCE;
|
||||
\tHWND :: win32.HWND;
|
||||
\tHMONITOR :: win32.HMONITOR;
|
||||
\tHANDLE :: win32.HANDLE;
|
||||
\tLPCWSTR :: win32.LPCWSTR;
|
||||
\tSECURITY_ATTRIBUTES :: win32.SECURITY_ATTRIBUTES;
|
||||
\tDWORD :: win32.DWORD;
|
||||
\tLONG :: win32.LONG;
|
||||
\tLUID :: win32.LUID;
|
||||
} else {
|
||||
\tHINSTANCE :: distinct rawptr;
|
||||
\tHWND :: distinct rawptr;
|
||||
\tHMONITOR :: distinct rawptr;
|
||||
\tHANDLE :: distinct rawptr;
|
||||
\tLPCWSTR :: ^u16;
|
||||
\tSECURITY_ATTRIBUTES :: struct {};
|
||||
\tDWORD :: u32;
|
||||
\tLONG :: c.long;
|
||||
\tLUID :: struct {
|
||||
\t\tLowPart: DWORD,
|
||||
\t\tHighPart: LONG,
|
||||
\t}
|
||||
}
|
||||
|
||||
CAMetalLayer :: struct {};
|
||||
|
||||
/********************************/
|
||||
""")
|
||||
f.write("\n")
|
||||
parse_structs(f)
|
||||
f.write("\n\n")
|
||||
with open("../procedures.odin", 'w', encoding='utf-8') as f:
|
||||
f.write(BASE)
|
||||
f.write("\n")
|
||||
parse_procedures(f)
|
||||
f.write("\n")
|
||||
group_functions(f)
|
||||
f.write("\n\n")
|
||||
245
vendor/vulkan/_gen/vk_icd.h
vendored
Normal file
245
vendor/vulkan/_gen/vk_icd.h
vendored
Normal file
@@ -0,0 +1,245 @@
|
||||
//
|
||||
// File: vk_icd.h
|
||||
//
|
||||
/*
|
||||
* Copyright (c) 2015-2016 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2016 Valve Corporation
|
||||
* Copyright (c) 2015-2016 LunarG, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef VKICD_H
|
||||
#define VKICD_H
|
||||
|
||||
#include "vulkan.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
// Loader-ICD version negotiation API. Versions add the following features:
|
||||
// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr
|
||||
// or vk_icdNegotiateLoaderICDInterfaceVersion.
|
||||
// Version 1 - Add support for vk_icdGetInstanceProcAddr.
|
||||
// Version 2 - Add Loader/ICD Interface version negotiation
|
||||
// via vk_icdNegotiateLoaderICDInterfaceVersion.
|
||||
// Version 3 - Add ICD creation/destruction of KHR_surface objects.
|
||||
// Version 4 - Add unknown physical device extension qyering via
|
||||
// vk_icdGetPhysicalDeviceProcAddr.
|
||||
// Version 5 - Tells ICDs that the loader is now paying attention to the
|
||||
// application version of Vulkan passed into the ApplicationInfo
|
||||
// structure during vkCreateInstance. This will tell the ICD
|
||||
// that if the loader is older, it should automatically fail a
|
||||
// call for any API version > 1.0. Otherwise, the loader will
|
||||
// manually determine if it can support the expected version.
|
||||
// Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices.
|
||||
#define CURRENT_LOADER_ICD_INTERFACE_VERSION 6
|
||||
#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
|
||||
#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
|
||||
|
||||
// Old typedefs that don't follow a proper naming convention but are preserved for compatibility
|
||||
typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
|
||||
// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
|
||||
// file directly, it won't be found.
|
||||
#ifndef PFN_GetPhysicalDeviceProcAddr
|
||||
typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
|
||||
#endif
|
||||
|
||||
// Typedefs for loader/ICD interface
|
||||
typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion);
|
||||
typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName);
|
||||
typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID,
|
||||
uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
|
||||
#endif
|
||||
|
||||
// Prototypes for loader/ICD interface
|
||||
#if !defined(VK_NO_PROTOTYPES)
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion);
|
||||
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName);
|
||||
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance isntance, const char* pName);
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID,
|
||||
uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The ICD must reserve space for a pointer for the loader's dispatch
|
||||
* table, at the start of <each object>.
|
||||
* The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
|
||||
*/
|
||||
|
||||
#define ICD_LOADER_MAGIC 0x01CDC0DE
|
||||
|
||||
typedef union {
|
||||
uintptr_t loaderMagic;
|
||||
void *loaderData;
|
||||
} VK_LOADER_DATA;
|
||||
|
||||
static inline void set_loader_magic_value(void *pNewObject) {
|
||||
VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
|
||||
loader_info->loaderMagic = ICD_LOADER_MAGIC;
|
||||
}
|
||||
|
||||
static inline bool valid_loader_magic_value(void *pNewObject) {
|
||||
const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
|
||||
return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
|
||||
}
|
||||
|
||||
/*
|
||||
* Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
|
||||
* contains the platform-specific connection and surface information.
|
||||
*/
|
||||
typedef enum {
|
||||
VK_ICD_WSI_PLATFORM_MIR,
|
||||
VK_ICD_WSI_PLATFORM_WAYLAND,
|
||||
VK_ICD_WSI_PLATFORM_WIN32,
|
||||
VK_ICD_WSI_PLATFORM_XCB,
|
||||
VK_ICD_WSI_PLATFORM_XLIB,
|
||||
VK_ICD_WSI_PLATFORM_ANDROID,
|
||||
VK_ICD_WSI_PLATFORM_MACOS,
|
||||
VK_ICD_WSI_PLATFORM_IOS,
|
||||
VK_ICD_WSI_PLATFORM_DISPLAY,
|
||||
VK_ICD_WSI_PLATFORM_HEADLESS,
|
||||
VK_ICD_WSI_PLATFORM_METAL,
|
||||
VK_ICD_WSI_PLATFORM_DIRECTFB,
|
||||
VK_ICD_WSI_PLATFORM_VI,
|
||||
VK_ICD_WSI_PLATFORM_GGP,
|
||||
VK_ICD_WSI_PLATFORM_SCREEN,
|
||||
} VkIcdWsiPlatform;
|
||||
|
||||
typedef struct {
|
||||
VkIcdWsiPlatform platform;
|
||||
} VkIcdSurfaceBase;
|
||||
|
||||
#ifdef VK_USE_PLATFORM_MIR_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
MirConnection *connection;
|
||||
MirSurface *mirSurface;
|
||||
} VkIcdSurfaceMir;
|
||||
#endif // VK_USE_PLATFORM_MIR_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
struct wl_display *display;
|
||||
struct wl_surface *surface;
|
||||
} VkIcdSurfaceWayland;
|
||||
#endif // VK_USE_PLATFORM_WAYLAND_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
HINSTANCE hinstance;
|
||||
HWND hwnd;
|
||||
} VkIcdSurfaceWin32;
|
||||
#endif // VK_USE_PLATFORM_WIN32_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_XCB_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
xcb_connection_t *connection;
|
||||
xcb_window_t window;
|
||||
} VkIcdSurfaceXcb;
|
||||
#endif // VK_USE_PLATFORM_XCB_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
Display *dpy;
|
||||
Window window;
|
||||
} VkIcdSurfaceXlib;
|
||||
#endif // VK_USE_PLATFORM_XLIB_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
IDirectFB *dfb;
|
||||
IDirectFBSurface *surface;
|
||||
} VkIcdSurfaceDirectFB;
|
||||
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
|
||||
|
||||
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
struct ANativeWindow *window;
|
||||
} VkIcdSurfaceAndroid;
|
||||
#endif // VK_USE_PLATFORM_ANDROID_KHR
|
||||
|
||||
#ifdef VK_USE_PLATFORM_MACOS_MVK
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
const void *pView;
|
||||
} VkIcdSurfaceMacOS;
|
||||
#endif // VK_USE_PLATFORM_MACOS_MVK
|
||||
|
||||
#ifdef VK_USE_PLATFORM_IOS_MVK
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
const void *pView;
|
||||
} VkIcdSurfaceIOS;
|
||||
#endif // VK_USE_PLATFORM_IOS_MVK
|
||||
|
||||
#ifdef VK_USE_PLATFORM_GGP
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
GgpStreamDescriptor streamDescriptor;
|
||||
} VkIcdSurfaceGgp;
|
||||
#endif // VK_USE_PLATFORM_GGP
|
||||
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
VkDisplayModeKHR displayMode;
|
||||
uint32_t planeIndex;
|
||||
uint32_t planeStackIndex;
|
||||
VkSurfaceTransformFlagBitsKHR transform;
|
||||
float globalAlpha;
|
||||
VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
|
||||
VkExtent2D imageExtent;
|
||||
} VkIcdSurfaceDisplay;
|
||||
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
} VkIcdSurfaceHeadless;
|
||||
|
||||
#ifdef VK_USE_PLATFORM_METAL_EXT
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
const CAMetalLayer *pLayer;
|
||||
} VkIcdSurfaceMetal;
|
||||
#endif // VK_USE_PLATFORM_METAL_EXT
|
||||
|
||||
#ifdef VK_USE_PLATFORM_VI_NN
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
void *window;
|
||||
} VkIcdSurfaceVi;
|
||||
#endif // VK_USE_PLATFORM_VI_NN
|
||||
|
||||
#ifdef VK_USE_PLATFORM_SCREEN_QNX
|
||||
typedef struct {
|
||||
VkIcdSurfaceBase base;
|
||||
struct _screen_context *context;
|
||||
struct _screen_window *window;
|
||||
} VkIcdSurfaceScreen;
|
||||
#endif // VK_USE_PLATFORM_SCREEN_QNX
|
||||
|
||||
#endif // VKICD_H
|
||||
210
vendor/vulkan/_gen/vk_layer.h
vendored
Normal file
210
vendor/vulkan/_gen/vk_layer.h
vendored
Normal file
@@ -0,0 +1,210 @@
|
||||
//
|
||||
// File: vk_layer.h
|
||||
//
|
||||
/*
|
||||
* Copyright (c) 2015-2017 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2017 Valve Corporation
|
||||
* Copyright (c) 2015-2017 LunarG, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Need to define dispatch table
|
||||
* Core struct can then have ptr to dispatch table at the top
|
||||
* Along with object ptrs for current and next OBJ
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include "vulkan.h"
|
||||
#if defined(__GNUC__) && __GNUC__ >= 4
|
||||
#define VK_LAYER_EXPORT __attribute__((visibility("default")))
|
||||
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
|
||||
#define VK_LAYER_EXPORT __attribute__((visibility("default")))
|
||||
#else
|
||||
#define VK_LAYER_EXPORT
|
||||
#endif
|
||||
|
||||
#define MAX_NUM_UNKNOWN_EXTS 250
|
||||
|
||||
// Loader-Layer version negotiation API. Versions add the following features:
|
||||
// Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr
|
||||
// or vk_icdNegotiateLoaderLayerInterfaceVersion.
|
||||
// Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and
|
||||
// vk_icdNegotiateLoaderLayerInterfaceVersion.
|
||||
#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
|
||||
#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
|
||||
|
||||
#define VK_CURRENT_CHAIN_VERSION 1
|
||||
|
||||
// Typedef for use in the interfaces below
|
||||
typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
|
||||
|
||||
// Version negotiation values
|
||||
typedef enum VkNegotiateLayerStructType {
|
||||
LAYER_NEGOTIATE_UNINTIALIZED = 0,
|
||||
LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
|
||||
} VkNegotiateLayerStructType;
|
||||
|
||||
// Version negotiation structures
|
||||
typedef struct VkNegotiateLayerInterface {
|
||||
VkNegotiateLayerStructType sType;
|
||||
void *pNext;
|
||||
uint32_t loaderLayerInterfaceVersion;
|
||||
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
|
||||
PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
|
||||
PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
|
||||
} VkNegotiateLayerInterface;
|
||||
|
||||
// Version negotiation functions
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
|
||||
|
||||
// Function prototype for unknown physical device extension command
|
||||
typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// CreateInstance and CreateDevice support structures
|
||||
|
||||
/* Sub type of structure for instance and device loader ext of CreateInfo.
|
||||
* When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
|
||||
* or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
|
||||
* then VkLayerFunction indicates struct type pointed to by pNext
|
||||
*/
|
||||
typedef enum VkLayerFunction_ {
|
||||
VK_LAYER_LINK_INFO = 0,
|
||||
VK_LOADER_DATA_CALLBACK = 1,
|
||||
VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2,
|
||||
VK_LOADER_FEATURES = 3,
|
||||
} VkLayerFunction;
|
||||
|
||||
typedef struct VkLayerInstanceLink_ {
|
||||
struct VkLayerInstanceLink_ *pNext;
|
||||
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
|
||||
PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
|
||||
} VkLayerInstanceLink;
|
||||
|
||||
/*
|
||||
* When creating the device chain the loader needs to pass
|
||||
* down information about it's device structure needed at
|
||||
* the end of the chain. Passing the data via the
|
||||
* VkLayerDeviceInfo avoids issues with finding the
|
||||
* exact instance being used.
|
||||
*/
|
||||
typedef struct VkLayerDeviceInfo_ {
|
||||
void *device_info;
|
||||
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
|
||||
} VkLayerDeviceInfo;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
|
||||
void *object);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
|
||||
void *object);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
|
||||
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
|
||||
typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
|
||||
|
||||
typedef enum VkLoaderFeastureFlagBits {
|
||||
VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001,
|
||||
} VkLoaderFlagBits;
|
||||
typedef VkFlags VkLoaderFeatureFlags;
|
||||
|
||||
typedef struct {
|
||||
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
|
||||
const void *pNext;
|
||||
VkLayerFunction function;
|
||||
union {
|
||||
VkLayerInstanceLink *pLayerInfo;
|
||||
PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
|
||||
struct {
|
||||
PFN_vkLayerCreateDevice pfnLayerCreateDevice;
|
||||
PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
|
||||
} layerDevice;
|
||||
VkLoaderFeatureFlags loaderFeatures;
|
||||
} u;
|
||||
} VkLayerInstanceCreateInfo;
|
||||
|
||||
typedef struct VkLayerDeviceLink_ {
|
||||
struct VkLayerDeviceLink_ *pNext;
|
||||
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
|
||||
PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
|
||||
} VkLayerDeviceLink;
|
||||
|
||||
typedef struct {
|
||||
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
|
||||
const void *pNext;
|
||||
VkLayerFunction function;
|
||||
union {
|
||||
VkLayerDeviceLink *pLayerInfo;
|
||||
PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
|
||||
} u;
|
||||
} VkLayerDeviceCreateInfo;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
|
||||
|
||||
typedef enum VkChainType {
|
||||
VK_CHAIN_TYPE_UNKNOWN = 0,
|
||||
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
|
||||
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
|
||||
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
|
||||
} VkChainType;
|
||||
|
||||
typedef struct VkChainHeader {
|
||||
VkChainType type;
|
||||
uint32_t version;
|
||||
uint32_t size;
|
||||
} VkChainHeader;
|
||||
|
||||
typedef struct VkEnumerateInstanceExtensionPropertiesChain {
|
||||
VkChainHeader header;
|
||||
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
|
||||
VkExtensionProperties *);
|
||||
const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
|
||||
|
||||
#if defined(__cplusplus)
|
||||
inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
|
||||
return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
|
||||
}
|
||||
#endif
|
||||
} VkEnumerateInstanceExtensionPropertiesChain;
|
||||
|
||||
typedef struct VkEnumerateInstanceLayerPropertiesChain {
|
||||
VkChainHeader header;
|
||||
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
|
||||
const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
|
||||
|
||||
#if defined(__cplusplus)
|
||||
inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
|
||||
return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
|
||||
}
|
||||
#endif
|
||||
} VkEnumerateInstanceLayerPropertiesChain;
|
||||
|
||||
typedef struct VkEnumerateInstanceVersionChain {
|
||||
VkChainHeader header;
|
||||
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
|
||||
const struct VkEnumerateInstanceVersionChain *pNextLink;
|
||||
|
||||
#if defined(__cplusplus)
|
||||
inline VkResult CallDown(uint32_t *pApiVersion) const {
|
||||
return pfnNextLayer(pNextLink, pApiVersion);
|
||||
}
|
||||
#endif
|
||||
} VkEnumerateInstanceVersionChain;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
84
vendor/vulkan/_gen/vk_platform.h
vendored
Normal file
84
vendor/vulkan/_gen/vk_platform.h
vendored
Normal file
@@ -0,0 +1,84 @@
|
||||
//
|
||||
// File: vk_platform.h
|
||||
//
|
||||
/*
|
||||
** Copyright 2014-2021 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
|
||||
#ifndef VK_PLATFORM_H_
|
||||
#define VK_PLATFORM_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif // __cplusplus
|
||||
|
||||
/*
|
||||
***************************************************************************************************
|
||||
* Platform-specific directives and type declarations
|
||||
***************************************************************************************************
|
||||
*/
|
||||
|
||||
/* Platform-specific calling convention macros.
|
||||
*
|
||||
* Platforms should define these so that Vulkan clients call Vulkan commands
|
||||
* with the same calling conventions that the Vulkan implementation expects.
|
||||
*
|
||||
* VKAPI_ATTR - Placed before the return type in function declarations.
|
||||
* Useful for C++11 and GCC/Clang-style function attribute syntax.
|
||||
* VKAPI_CALL - Placed after the return type in function declarations.
|
||||
* Useful for MSVC-style calling convention syntax.
|
||||
* VKAPI_PTR - Placed between the '(' and '*' in function pointer types.
|
||||
*
|
||||
* Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void);
|
||||
* Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
|
||||
*/
|
||||
#if defined(_WIN32)
|
||||
// On Windows, Vulkan commands use the stdcall convention
|
||||
#define VKAPI_ATTR
|
||||
#define VKAPI_CALL __stdcall
|
||||
#define VKAPI_PTR VKAPI_CALL
|
||||
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
|
||||
#error "Vulkan isn't supported for the 'armeabi' NDK ABI"
|
||||
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
|
||||
// On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
|
||||
// calling convention, i.e. float parameters are passed in registers. This
|
||||
// is true even if the rest of the application passes floats on the stack,
|
||||
// as it does by default when compiling for the armeabi-v7a NDK ABI.
|
||||
#define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
|
||||
#define VKAPI_CALL
|
||||
#define VKAPI_PTR VKAPI_ATTR
|
||||
#else
|
||||
// On other platforms, use the default calling convention
|
||||
#define VKAPI_ATTR
|
||||
#define VKAPI_CALL
|
||||
#define VKAPI_PTR
|
||||
#endif
|
||||
|
||||
#if !defined(VK_NO_STDDEF_H)
|
||||
#include <stddef.h>
|
||||
#endif // !defined(VK_NO_STDDEF_H)
|
||||
|
||||
#if !defined(VK_NO_STDINT_H)
|
||||
#if defined(_MSC_VER) && (_MSC_VER < 1600)
|
||||
typedef signed __int8 int8_t;
|
||||
typedef unsigned __int8 uint8_t;
|
||||
typedef signed __int16 int16_t;
|
||||
typedef unsigned __int16 uint16_t;
|
||||
typedef signed __int32 int32_t;
|
||||
typedef unsigned __int32 uint32_t;
|
||||
typedef signed __int64 int64_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#endif // !defined(VK_NO_STDINT_H)
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif
|
||||
13121
vendor/vulkan/_gen/vulkan_core.h
vendored
Normal file
13121
vendor/vulkan/_gen/vulkan_core.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
47
vendor/vulkan/_gen/vulkan_ios.h
vendored
Normal file
47
vendor/vulkan/_gen/vulkan_ios.h
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
#ifndef VULKAN_IOS_H_
|
||||
#define VULKAN_IOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2021 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define VK_MVK_ios_surface 1
|
||||
#define VK_MVK_IOS_SURFACE_SPEC_VERSION 3
|
||||
#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
|
||||
typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
|
||||
typedef struct VkIOSSurfaceCreateInfoMVK {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkIOSSurfaceCreateFlagsMVK flags;
|
||||
const void* pView;
|
||||
} VkIOSSurfaceCreateInfoMVK;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
|
||||
VkInstance instance,
|
||||
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
|
||||
const VkAllocationCallbacks* pAllocator,
|
||||
VkSurfaceKHR* pSurface);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
47
vendor/vulkan/_gen/vulkan_macos.h
vendored
Normal file
47
vendor/vulkan/_gen/vulkan_macos.h
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
#ifndef VULKAN_MACOS_H_
|
||||
#define VULKAN_MACOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2021 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define VK_MVK_macos_surface 1
|
||||
#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3
|
||||
#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
|
||||
typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
|
||||
typedef struct VkMacOSSurfaceCreateInfoMVK {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkMacOSSurfaceCreateFlagsMVK flags;
|
||||
const void* pView;
|
||||
} VkMacOSSurfaceCreateInfoMVK;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
|
||||
VkInstance instance,
|
||||
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
|
||||
const VkAllocationCallbacks* pAllocator,
|
||||
VkSurfaceKHR* pSurface);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
54
vendor/vulkan/_gen/vulkan_metal.h
vendored
Normal file
54
vendor/vulkan/_gen/vulkan_metal.h
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
#ifndef VULKAN_METAL_H_
|
||||
#define VULKAN_METAL_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2021 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define VK_EXT_metal_surface 1
|
||||
|
||||
#ifdef __OBJC__
|
||||
@class CAMetalLayer;
|
||||
#else
|
||||
typedef void CAMetalLayer;
|
||||
#endif
|
||||
|
||||
#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
|
||||
#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
|
||||
typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
|
||||
typedef struct VkMetalSurfaceCreateInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkMetalSurfaceCreateFlagsEXT flags;
|
||||
const CAMetalLayer* pLayer;
|
||||
} VkMetalSurfaceCreateInfoEXT;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
|
||||
VkInstance instance,
|
||||
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
|
||||
const VkAllocationCallbacks* pAllocator,
|
||||
VkSurfaceKHR* pSurface);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
315
vendor/vulkan/_gen/vulkan_win32.h
vendored
Normal file
315
vendor/vulkan/_gen/vulkan_win32.h
vendored
Normal file
@@ -0,0 +1,315 @@
|
||||
#ifndef VULKAN_WIN32_H_
|
||||
#define VULKAN_WIN32_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2021 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define VK_KHR_win32_surface 1
|
||||
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
|
||||
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
|
||||
typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
|
||||
typedef struct VkWin32SurfaceCreateInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkWin32SurfaceCreateFlagsKHR flags;
|
||||
HINSTANCE hinstance;
|
||||
HWND hwnd;
|
||||
} VkWin32SurfaceCreateInfoKHR;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
|
||||
VkInstance instance,
|
||||
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
|
||||
const VkAllocationCallbacks* pAllocator,
|
||||
VkSurfaceKHR* pSurface);
|
||||
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
|
||||
VkPhysicalDevice physicalDevice,
|
||||
uint32_t queueFamilyIndex);
|
||||
#endif
|
||||
|
||||
|
||||
#define VK_KHR_external_memory_win32 1
|
||||
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
|
||||
typedef struct VkImportMemoryWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkExternalMemoryHandleTypeFlagBits handleType;
|
||||
HANDLE handle;
|
||||
LPCWSTR name;
|
||||
} VkImportMemoryWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkExportMemoryWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const SECURITY_ATTRIBUTES* pAttributes;
|
||||
DWORD dwAccess;
|
||||
LPCWSTR name;
|
||||
} VkExportMemoryWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkMemoryWin32HandlePropertiesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t memoryTypeBits;
|
||||
} VkMemoryWin32HandlePropertiesKHR;
|
||||
|
||||
typedef struct VkMemoryGetWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkDeviceMemory memory;
|
||||
VkExternalMemoryHandleTypeFlagBits handleType;
|
||||
} VkMemoryGetWin32HandleInfoKHR;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
|
||||
VkDevice device,
|
||||
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
||||
HANDLE* pHandle);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
|
||||
VkDevice device,
|
||||
VkExternalMemoryHandleTypeFlagBits handleType,
|
||||
HANDLE handle,
|
||||
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
|
||||
#endif
|
||||
|
||||
|
||||
#define VK_KHR_win32_keyed_mutex 1
|
||||
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
|
||||
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
|
||||
typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t acquireCount;
|
||||
const VkDeviceMemory* pAcquireSyncs;
|
||||
const uint64_t* pAcquireKeys;
|
||||
const uint32_t* pAcquireTimeouts;
|
||||
uint32_t releaseCount;
|
||||
const VkDeviceMemory* pReleaseSyncs;
|
||||
const uint64_t* pReleaseKeys;
|
||||
} VkWin32KeyedMutexAcquireReleaseInfoKHR;
|
||||
|
||||
|
||||
|
||||
#define VK_KHR_external_semaphore_win32 1
|
||||
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
|
||||
typedef struct VkImportSemaphoreWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkSemaphore semaphore;
|
||||
VkSemaphoreImportFlags flags;
|
||||
VkExternalSemaphoreHandleTypeFlagBits handleType;
|
||||
HANDLE handle;
|
||||
LPCWSTR name;
|
||||
} VkImportSemaphoreWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkExportSemaphoreWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const SECURITY_ATTRIBUTES* pAttributes;
|
||||
DWORD dwAccess;
|
||||
LPCWSTR name;
|
||||
} VkExportSemaphoreWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkD3D12FenceSubmitInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t waitSemaphoreValuesCount;
|
||||
const uint64_t* pWaitSemaphoreValues;
|
||||
uint32_t signalSemaphoreValuesCount;
|
||||
const uint64_t* pSignalSemaphoreValues;
|
||||
} VkD3D12FenceSubmitInfoKHR;
|
||||
|
||||
typedef struct VkSemaphoreGetWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkSemaphore semaphore;
|
||||
VkExternalSemaphoreHandleTypeFlagBits handleType;
|
||||
} VkSemaphoreGetWin32HandleInfoKHR;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
|
||||
VkDevice device,
|
||||
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
|
||||
VkDevice device,
|
||||
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
||||
HANDLE* pHandle);
|
||||
#endif
|
||||
|
||||
|
||||
#define VK_KHR_external_fence_win32 1
|
||||
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
|
||||
typedef struct VkImportFenceWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkFence fence;
|
||||
VkFenceImportFlags flags;
|
||||
VkExternalFenceHandleTypeFlagBits handleType;
|
||||
HANDLE handle;
|
||||
LPCWSTR name;
|
||||
} VkImportFenceWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkExportFenceWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const SECURITY_ATTRIBUTES* pAttributes;
|
||||
DWORD dwAccess;
|
||||
LPCWSTR name;
|
||||
} VkExportFenceWin32HandleInfoKHR;
|
||||
|
||||
typedef struct VkFenceGetWin32HandleInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkFence fence;
|
||||
VkExternalFenceHandleTypeFlagBits handleType;
|
||||
} VkFenceGetWin32HandleInfoKHR;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
|
||||
VkDevice device,
|
||||
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
|
||||
VkDevice device,
|
||||
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
||||
HANDLE* pHandle);
|
||||
#endif
|
||||
|
||||
|
||||
#define VK_NV_external_memory_win32 1
|
||||
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
||||
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
|
||||
typedef struct VkImportMemoryWin32HandleInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkExternalMemoryHandleTypeFlagsNV handleType;
|
||||
HANDLE handle;
|
||||
} VkImportMemoryWin32HandleInfoNV;
|
||||
|
||||
typedef struct VkExportMemoryWin32HandleInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const SECURITY_ATTRIBUTES* pAttributes;
|
||||
DWORD dwAccess;
|
||||
} VkExportMemoryWin32HandleInfoNV;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
|
||||
VkDevice device,
|
||||
VkDeviceMemory memory,
|
||||
VkExternalMemoryHandleTypeFlagsNV handleType,
|
||||
HANDLE* pHandle);
|
||||
#endif
|
||||
|
||||
|
||||
#define VK_NV_win32_keyed_mutex 1
|
||||
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
|
||||
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
|
||||
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t acquireCount;
|
||||
const VkDeviceMemory* pAcquireSyncs;
|
||||
const uint64_t* pAcquireKeys;
|
||||
const uint32_t* pAcquireTimeoutMilliseconds;
|
||||
uint32_t releaseCount;
|
||||
const VkDeviceMemory* pReleaseSyncs;
|
||||
const uint64_t* pReleaseKeys;
|
||||
} VkWin32KeyedMutexAcquireReleaseInfoNV;
|
||||
|
||||
|
||||
|
||||
#define VK_EXT_full_screen_exclusive 1
|
||||
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
|
||||
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
|
||||
|
||||
typedef enum VkFullScreenExclusiveEXT {
|
||||
VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
|
||||
VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
|
||||
VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
|
||||
VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
|
||||
VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkFullScreenExclusiveEXT;
|
||||
typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkFullScreenExclusiveEXT fullScreenExclusive;
|
||||
} VkSurfaceFullScreenExclusiveInfoEXT;
|
||||
|
||||
typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 fullScreenExclusiveSupported;
|
||||
} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
|
||||
|
||||
typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
HMONITOR hmonitor;
|
||||
} VkSurfaceFullScreenExclusiveWin32InfoEXT;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
|
||||
VkPhysicalDevice physicalDevice,
|
||||
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
||||
uint32_t* pPresentModeCount,
|
||||
VkPresentModeKHR* pPresentModes);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
|
||||
VkDevice device,
|
||||
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
||||
VkDeviceGroupPresentModeFlagsKHR* pModes);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
770
vendor/vulkan/core.odin
vendored
Normal file
770
vendor/vulkan/core.odin
vendored
Normal file
@@ -0,0 +1,770 @@
|
||||
//
|
||||
// Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"
|
||||
//
|
||||
package vulkan
|
||||
|
||||
import "core:c"
|
||||
API_VERSION_1_0 :: (1<<22) | (0<<12) | (0);
|
||||
|
||||
MAKE_VERSION :: proc(major, minor, patch: u32) -> u32 {
|
||||
return (major<<22) | (minor<<12) | (patch);
|
||||
}
|
||||
|
||||
// Base types
|
||||
Flags :: distinct u32;
|
||||
Flags64 :: distinct u64;
|
||||
DeviceSize :: distinct u64;
|
||||
DeviceAddress :: distinct u64;
|
||||
SampleMask :: distinct u32;
|
||||
|
||||
Handle :: distinct rawptr;
|
||||
NonDispatchableHandle :: distinct u64;
|
||||
|
||||
SetProcAddressType :: #type proc(p: rawptr, name: cstring);
|
||||
|
||||
|
||||
cstring_array :: ^cstring; // Helper Type
|
||||
|
||||
RemoteAddressNV :: distinct rawptr; // Declared inline before MemoryGetRemoteAddressInfoNV
|
||||
|
||||
// Base constants
|
||||
LOD_CLAMP_NONE :: 1000.0;
|
||||
REMAINING_MIP_LEVELS :: ~u32(0);
|
||||
REMAINING_ARRAY_LAYERS :: ~u32(0);
|
||||
WHOLE_SIZE :: ~u64(0);
|
||||
ATTACHMENT_UNUSED :: ~u32(0);
|
||||
TRUE :: 1;
|
||||
FALSE :: 0;
|
||||
QUEUE_FAMILY_IGNORED :: ~u32(0);
|
||||
SUBPASS_EXTERNAL :: ~u32(0);
|
||||
MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256;
|
||||
UUID_SIZE :: 16;
|
||||
MAX_MEMORY_TYPES :: 32;
|
||||
MAX_MEMORY_HEAPS :: 16;
|
||||
MAX_EXTENSION_NAME_SIZE :: 256;
|
||||
MAX_DESCRIPTION_SIZE :: 256;
|
||||
MAX_DEVICE_GROUP_SIZE_KHX :: 32;
|
||||
MAX_DEVICE_GROUP_SIZE :: 32;
|
||||
LUID_SIZE_KHX :: 8;
|
||||
LUID_SIZE_KHR :: 8;
|
||||
LUID_SIZE :: 8;
|
||||
MAX_DRIVER_NAME_SIZE_KHR :: 256;
|
||||
MAX_DRIVER_INFO_SIZE_KHR :: 256;
|
||||
MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(0)-1;
|
||||
MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16;
|
||||
|
||||
// General Constants
|
||||
HEADER_VERSION :: 189;
|
||||
MAX_DRIVER_NAME_SIZE :: 256;
|
||||
MAX_DRIVER_INFO_SIZE :: 256;
|
||||
|
||||
// Vendor Constants
|
||||
KHR_surface :: 1;
|
||||
KHR_SURFACE_SPEC_VERSION :: 25;
|
||||
KHR_SURFACE_EXTENSION_NAME :: "VK_KHR_surface";
|
||||
KHR_swapchain :: 1;
|
||||
KHR_SWAPCHAIN_SPEC_VERSION :: 70;
|
||||
KHR_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_swapchain";
|
||||
KHR_display :: 1;
|
||||
KHR_DISPLAY_SPEC_VERSION :: 23;
|
||||
KHR_DISPLAY_EXTENSION_NAME :: "VK_KHR_display";
|
||||
KHR_display_swapchain :: 1;
|
||||
KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION :: 10;
|
||||
KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_display_swapchain";
|
||||
KHR_sampler_mirror_clamp_to_edge :: 1;
|
||||
KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION :: 3;
|
||||
KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: "VK_KHR_sampler_mirror_clamp_to_edge";
|
||||
KHR_multiview :: 1;
|
||||
KHR_MULTIVIEW_SPEC_VERSION :: 1;
|
||||
KHR_MULTIVIEW_EXTENSION_NAME :: "VK_KHR_multiview";
|
||||
KHR_get_physical_device_properties2 :: 1;
|
||||
KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION :: 2;
|
||||
KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_physical_device_properties2";
|
||||
KHR_device_group :: 1;
|
||||
KHR_DEVICE_GROUP_SPEC_VERSION :: 4;
|
||||
KHR_DEVICE_GROUP_EXTENSION_NAME :: "VK_KHR_device_group";
|
||||
KHR_shader_draw_parameters :: 1;
|
||||
KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: "VK_KHR_shader_draw_parameters";
|
||||
KHR_maintenance1 :: 1;
|
||||
KHR_MAINTENANCE1_SPEC_VERSION :: 2;
|
||||
KHR_MAINTENANCE1_EXTENSION_NAME :: "VK_KHR_maintenance1";
|
||||
KHR_device_group_creation :: 1;
|
||||
KHR_DEVICE_GROUP_CREATION_SPEC_VERSION :: 1;
|
||||
KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME :: "VK_KHR_device_group_creation";
|
||||
KHR_external_memory_capabilities :: 1;
|
||||
KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_memory_capabilities";
|
||||
KHR_external_memory :: 1;
|
||||
KHR_EXTERNAL_MEMORY_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_KHR_external_memory";
|
||||
KHR_external_memory_fd :: 1;
|
||||
KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: "VK_KHR_external_memory_fd";
|
||||
KHR_external_semaphore_capabilities :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_semaphore_capabilities";
|
||||
KHR_external_semaphore :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_external_semaphore";
|
||||
KHR_external_semaphore_fd :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: "VK_KHR_external_semaphore_fd";
|
||||
KHR_push_descriptor :: 1;
|
||||
KHR_PUSH_DESCRIPTOR_SPEC_VERSION :: 2;
|
||||
KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: "VK_KHR_push_descriptor";
|
||||
KHR_shader_float16_int8 :: 1;
|
||||
KHR_SHADER_FLOAT16_INT8_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME :: "VK_KHR_shader_float16_int8";
|
||||
KHR_16bit_storage :: 1;
|
||||
KHR_16BIT_STORAGE_SPEC_VERSION :: 1;
|
||||
KHR_16BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_16bit_storage";
|
||||
KHR_incremental_present :: 1;
|
||||
KHR_INCREMENTAL_PRESENT_SPEC_VERSION :: 2;
|
||||
KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: "VK_KHR_incremental_present";
|
||||
KHR_descriptor_update_template :: 1;
|
||||
KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION :: 1;
|
||||
KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: "VK_KHR_descriptor_update_template";
|
||||
KHR_imageless_framebuffer :: 1;
|
||||
KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION :: 1;
|
||||
KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME :: "VK_KHR_imageless_framebuffer";
|
||||
KHR_create_renderpass2 :: 1;
|
||||
KHR_CREATE_RENDERPASS_2_SPEC_VERSION :: 1;
|
||||
KHR_CREATE_RENDERPASS_2_EXTENSION_NAME :: "VK_KHR_create_renderpass2";
|
||||
KHR_shared_presentable_image :: 1;
|
||||
KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION :: 1;
|
||||
KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: "VK_KHR_shared_presentable_image";
|
||||
KHR_external_fence_capabilities :: 1;
|
||||
KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_fence_capabilities";
|
||||
KHR_external_fence :: 1;
|
||||
KHR_EXTERNAL_FENCE_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_FENCE_EXTENSION_NAME :: "VK_KHR_external_fence";
|
||||
KHR_external_fence_fd :: 1;
|
||||
KHR_EXTERNAL_FENCE_FD_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: "VK_KHR_external_fence_fd";
|
||||
KHR_performance_query :: 1;
|
||||
KHR_PERFORMANCE_QUERY_SPEC_VERSION :: 1;
|
||||
KHR_PERFORMANCE_QUERY_EXTENSION_NAME :: "VK_KHR_performance_query";
|
||||
KHR_maintenance2 :: 1;
|
||||
KHR_MAINTENANCE2_SPEC_VERSION :: 1;
|
||||
KHR_MAINTENANCE2_EXTENSION_NAME :: "VK_KHR_maintenance2";
|
||||
KHR_get_surface_capabilities2 :: 1;
|
||||
KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION :: 1;
|
||||
KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: "VK_KHR_get_surface_capabilities2";
|
||||
KHR_variable_pointers :: 1;
|
||||
KHR_VARIABLE_POINTERS_SPEC_VERSION :: 1;
|
||||
KHR_VARIABLE_POINTERS_EXTENSION_NAME :: "VK_KHR_variable_pointers";
|
||||
KHR_get_display_properties2 :: 1;
|
||||
KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION :: 1;
|
||||
KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_display_properties2";
|
||||
KHR_dedicated_allocation :: 1;
|
||||
KHR_DEDICATED_ALLOCATION_SPEC_VERSION :: 3;
|
||||
KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_KHR_dedicated_allocation";
|
||||
KHR_storage_buffer_storage_class :: 1;
|
||||
KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION :: 1;
|
||||
KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: "VK_KHR_storage_buffer_storage_class";
|
||||
KHR_relaxed_block_layout :: 1;
|
||||
KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION :: 1;
|
||||
KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_KHR_relaxed_block_layout";
|
||||
KHR_get_memory_requirements2 :: 1;
|
||||
KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION :: 1;
|
||||
KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: "VK_KHR_get_memory_requirements2";
|
||||
KHR_image_format_list :: 1;
|
||||
KHR_IMAGE_FORMAT_LIST_SPEC_VERSION :: 1;
|
||||
KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: "VK_KHR_image_format_list";
|
||||
KHR_sampler_ycbcr_conversion :: 1;
|
||||
KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION :: 14;
|
||||
KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: "VK_KHR_sampler_ycbcr_conversion";
|
||||
KHR_bind_memory2 :: 1;
|
||||
KHR_BIND_MEMORY_2_SPEC_VERSION :: 1;
|
||||
KHR_BIND_MEMORY_2_EXTENSION_NAME :: "VK_KHR_bind_memory2";
|
||||
KHR_maintenance3 :: 1;
|
||||
KHR_MAINTENANCE3_SPEC_VERSION :: 1;
|
||||
KHR_MAINTENANCE3_EXTENSION_NAME :: "VK_KHR_maintenance3";
|
||||
KHR_draw_indirect_count :: 1;
|
||||
KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 1;
|
||||
KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_KHR_draw_indirect_count";
|
||||
KHR_shader_subgroup_extended_types :: 1;
|
||||
KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME :: "VK_KHR_shader_subgroup_extended_types";
|
||||
KHR_8bit_storage :: 1;
|
||||
KHR_8BIT_STORAGE_SPEC_VERSION :: 1;
|
||||
KHR_8BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_8bit_storage";
|
||||
KHR_shader_atomic_int64 :: 1;
|
||||
KHR_SHADER_ATOMIC_INT64_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME :: "VK_KHR_shader_atomic_int64";
|
||||
KHR_shader_clock :: 1;
|
||||
KHR_SHADER_CLOCK_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_CLOCK_EXTENSION_NAME :: "VK_KHR_shader_clock";
|
||||
KHR_driver_properties :: 1;
|
||||
KHR_DRIVER_PROPERTIES_SPEC_VERSION :: 1;
|
||||
KHR_DRIVER_PROPERTIES_EXTENSION_NAME :: "VK_KHR_driver_properties";
|
||||
KHR_shader_float_controls :: 1;
|
||||
KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION :: 4;
|
||||
KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME :: "VK_KHR_shader_float_controls";
|
||||
KHR_depth_stencil_resolve :: 1;
|
||||
KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION :: 1;
|
||||
KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME :: "VK_KHR_depth_stencil_resolve";
|
||||
KHR_swapchain_mutable_format :: 1;
|
||||
KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION :: 1;
|
||||
KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME :: "VK_KHR_swapchain_mutable_format";
|
||||
KHR_timeline_semaphore :: 1;
|
||||
KHR_TIMELINE_SEMAPHORE_SPEC_VERSION :: 2;
|
||||
KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_timeline_semaphore";
|
||||
KHR_vulkan_memory_model :: 1;
|
||||
KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION :: 3;
|
||||
KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME :: "VK_KHR_vulkan_memory_model";
|
||||
KHR_shader_terminate_invocation :: 1;
|
||||
KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME :: "VK_KHR_shader_terminate_invocation";
|
||||
KHR_fragment_shading_rate :: 1;
|
||||
KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION :: 1;
|
||||
KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME :: "VK_KHR_fragment_shading_rate";
|
||||
KHR_spirv_1_4 :: 1;
|
||||
KHR_SPIRV_1_4_SPEC_VERSION :: 1;
|
||||
KHR_SPIRV_1_4_EXTENSION_NAME :: "VK_KHR_spirv_1_4";
|
||||
KHR_surface_protected_capabilities :: 1;
|
||||
KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION :: 1;
|
||||
KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_surface_protected_capabilities";
|
||||
KHR_separate_depth_stencil_layouts :: 1;
|
||||
KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION :: 1;
|
||||
KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME :: "VK_KHR_separate_depth_stencil_layouts";
|
||||
KHR_present_wait :: 1;
|
||||
KHR_PRESENT_WAIT_SPEC_VERSION :: 1;
|
||||
KHR_PRESENT_WAIT_EXTENSION_NAME :: "VK_KHR_present_wait";
|
||||
KHR_uniform_buffer_standard_layout :: 1;
|
||||
KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION :: 1;
|
||||
KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME :: "VK_KHR_uniform_buffer_standard_layout";
|
||||
KHR_buffer_device_address :: 1;
|
||||
KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 1;
|
||||
KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_KHR_buffer_device_address";
|
||||
KHR_deferred_host_operations :: 1;
|
||||
KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: 4;
|
||||
KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: "VK_KHR_deferred_host_operations";
|
||||
KHR_pipeline_executable_properties :: 1;
|
||||
KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION :: 1;
|
||||
KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME :: "VK_KHR_pipeline_executable_properties";
|
||||
KHR_pipeline_library :: 1;
|
||||
KHR_PIPELINE_LIBRARY_SPEC_VERSION :: 1;
|
||||
KHR_PIPELINE_LIBRARY_EXTENSION_NAME :: "VK_KHR_pipeline_library";
|
||||
KHR_shader_non_semantic_info :: 1;
|
||||
KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME :: "VK_KHR_shader_non_semantic_info";
|
||||
KHR_present_id :: 1;
|
||||
KHR_PRESENT_ID_SPEC_VERSION :: 1;
|
||||
KHR_PRESENT_ID_EXTENSION_NAME :: "VK_KHR_present_id";
|
||||
KHR_synchronization2 :: 1;
|
||||
KHR_SYNCHRONIZATION_2_SPEC_VERSION :: 1;
|
||||
KHR_SYNCHRONIZATION_2_EXTENSION_NAME :: "VK_KHR_synchronization2";
|
||||
KHR_shader_subgroup_uniform_control_flow :: 1;
|
||||
KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION :: 1;
|
||||
KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME :: "VK_KHR_shader_subgroup_uniform_control_flow";
|
||||
KHR_zero_initialize_workgroup_memory :: 1;
|
||||
KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION :: 1;
|
||||
KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME :: "VK_KHR_zero_initialize_workgroup_memory";
|
||||
KHR_workgroup_memory_explicit_layout :: 1;
|
||||
KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION :: 1;
|
||||
KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME :: "VK_KHR_workgroup_memory_explicit_layout";
|
||||
KHR_copy_commands2 :: 1;
|
||||
KHR_COPY_COMMANDS_2_SPEC_VERSION :: 1;
|
||||
KHR_COPY_COMMANDS_2_EXTENSION_NAME :: "VK_KHR_copy_commands2";
|
||||
EXT_debug_report :: 1;
|
||||
EXT_DEBUG_REPORT_SPEC_VERSION :: 10;
|
||||
EXT_DEBUG_REPORT_EXTENSION_NAME :: "VK_EXT_debug_report";
|
||||
NV_glsl_shader :: 1;
|
||||
NV_GLSL_SHADER_SPEC_VERSION :: 1;
|
||||
NV_GLSL_SHADER_EXTENSION_NAME :: "VK_NV_glsl_shader";
|
||||
EXT_depth_range_unrestricted :: 1;
|
||||
EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION :: 1;
|
||||
EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: "VK_EXT_depth_range_unrestricted";
|
||||
AMD_rasterization_order :: 1;
|
||||
AMD_RASTERIZATION_ORDER_SPEC_VERSION :: 1;
|
||||
AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: "VK_AMD_rasterization_order";
|
||||
AMD_shader_trinary_minmax :: 1;
|
||||
AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: "VK_AMD_shader_trinary_minmax";
|
||||
AMD_shader_explicit_vertex_parameter :: 1;
|
||||
AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: "VK_AMD_shader_explicit_vertex_parameter";
|
||||
EXT_debug_marker :: 1;
|
||||
EXT_DEBUG_MARKER_SPEC_VERSION :: 4;
|
||||
EXT_DEBUG_MARKER_EXTENSION_NAME :: "VK_EXT_debug_marker";
|
||||
AMD_gcn_shader :: 1;
|
||||
AMD_GCN_SHADER_SPEC_VERSION :: 1;
|
||||
AMD_GCN_SHADER_EXTENSION_NAME :: "VK_AMD_gcn_shader";
|
||||
NV_dedicated_allocation :: 1;
|
||||
NV_DEDICATED_ALLOCATION_SPEC_VERSION :: 1;
|
||||
NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_NV_dedicated_allocation";
|
||||
EXT_transform_feedback :: 1;
|
||||
EXT_TRANSFORM_FEEDBACK_SPEC_VERSION :: 1;
|
||||
EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME :: "VK_EXT_transform_feedback";
|
||||
NVX_binary_import :: 1;
|
||||
NVX_BINARY_IMPORT_SPEC_VERSION :: 1;
|
||||
NVX_BINARY_IMPORT_EXTENSION_NAME :: "VK_NVX_binary_import";
|
||||
NVX_image_view_handle :: 1;
|
||||
NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: 2;
|
||||
NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: "VK_NVX_image_view_handle";
|
||||
AMD_draw_indirect_count :: 1;
|
||||
AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 2;
|
||||
AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_AMD_draw_indirect_count";
|
||||
AMD_negative_viewport_height :: 1;
|
||||
AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION :: 1;
|
||||
AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: "VK_AMD_negative_viewport_height";
|
||||
AMD_gpu_shader_half_float :: 1;
|
||||
AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION :: 2;
|
||||
AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: "VK_AMD_gpu_shader_half_float";
|
||||
AMD_shader_ballot :: 1;
|
||||
AMD_SHADER_BALLOT_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_BALLOT_EXTENSION_NAME :: "VK_AMD_shader_ballot";
|
||||
AMD_texture_gather_bias_lod :: 1;
|
||||
AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION :: 1;
|
||||
AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: "VK_AMD_texture_gather_bias_lod";
|
||||
AMD_shader_info :: 1;
|
||||
AMD_SHADER_INFO_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_INFO_EXTENSION_NAME :: "VK_AMD_shader_info";
|
||||
AMD_shader_image_load_store_lod :: 1;
|
||||
AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: "VK_AMD_shader_image_load_store_lod";
|
||||
NV_corner_sampled_image :: 1;
|
||||
NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION :: 2;
|
||||
NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME :: "VK_NV_corner_sampled_image";
|
||||
NV_external_memory_capabilities :: 1;
|
||||
NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1;
|
||||
NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_NV_external_memory_capabilities";
|
||||
NV_external_memory :: 1;
|
||||
NV_EXTERNAL_MEMORY_SPEC_VERSION :: 1;
|
||||
NV_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_NV_external_memory";
|
||||
EXT_validation_flags :: 1;
|
||||
EXT_VALIDATION_FLAGS_SPEC_VERSION :: 2;
|
||||
EXT_VALIDATION_FLAGS_EXTENSION_NAME :: "VK_EXT_validation_flags";
|
||||
EXT_shader_subgroup_ballot :: 1;
|
||||
EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: "VK_EXT_shader_subgroup_ballot";
|
||||
EXT_shader_subgroup_vote :: 1;
|
||||
EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: "VK_EXT_shader_subgroup_vote";
|
||||
EXT_texture_compression_astc_hdr :: 1;
|
||||
EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION :: 1;
|
||||
EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME :: "VK_EXT_texture_compression_astc_hdr";
|
||||
EXT_astc_decode_mode :: 1;
|
||||
EXT_ASTC_DECODE_MODE_SPEC_VERSION :: 1;
|
||||
EXT_ASTC_DECODE_MODE_EXTENSION_NAME :: "VK_EXT_astc_decode_mode";
|
||||
EXT_conditional_rendering :: 1;
|
||||
EXT_CONDITIONAL_RENDERING_SPEC_VERSION :: 2;
|
||||
EXT_CONDITIONAL_RENDERING_EXTENSION_NAME :: "VK_EXT_conditional_rendering";
|
||||
NV_clip_space_w_scaling :: 1;
|
||||
NV_CLIP_SPACE_W_SCALING_SPEC_VERSION :: 1;
|
||||
NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: "VK_NV_clip_space_w_scaling";
|
||||
EXT_direct_mode_display :: 1;
|
||||
EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION :: 1;
|
||||
EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: "VK_EXT_direct_mode_display";
|
||||
EXT_display_surface_counter :: 1;
|
||||
EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION :: 1;
|
||||
EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: "VK_EXT_display_surface_counter";
|
||||
EXT_display_control :: 1;
|
||||
EXT_DISPLAY_CONTROL_SPEC_VERSION :: 1;
|
||||
EXT_DISPLAY_CONTROL_EXTENSION_NAME :: "VK_EXT_display_control";
|
||||
GOOGLE_display_timing :: 1;
|
||||
GOOGLE_DISPLAY_TIMING_SPEC_VERSION :: 1;
|
||||
GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: "VK_GOOGLE_display_timing";
|
||||
NV_sample_mask_override_coverage :: 1;
|
||||
NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION :: 1;
|
||||
NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: "VK_NV_sample_mask_override_coverage";
|
||||
NV_geometry_shader_passthrough :: 1;
|
||||
NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION :: 1;
|
||||
NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: "VK_NV_geometry_shader_passthrough";
|
||||
NV_viewport_array2 :: 1;
|
||||
NV_VIEWPORT_ARRAY2_SPEC_VERSION :: 1;
|
||||
NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: "VK_NV_viewport_array2";
|
||||
NVX_multiview_per_view_attributes :: 1;
|
||||
NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION :: 1;
|
||||
NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: "VK_NVX_multiview_per_view_attributes";
|
||||
NV_viewport_swizzle :: 1;
|
||||
NV_VIEWPORT_SWIZZLE_SPEC_VERSION :: 1;
|
||||
NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: "VK_NV_viewport_swizzle";
|
||||
EXT_discard_rectangles :: 1;
|
||||
EXT_DISCARD_RECTANGLES_SPEC_VERSION :: 1;
|
||||
EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: "VK_EXT_discard_rectangles";
|
||||
EXT_conservative_rasterization :: 1;
|
||||
EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION :: 1;
|
||||
EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_conservative_rasterization";
|
||||
EXT_depth_clip_enable :: 1;
|
||||
EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION :: 1;
|
||||
EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME :: "VK_EXT_depth_clip_enable";
|
||||
EXT_swapchain_colorspace :: 1;
|
||||
EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION :: 4;
|
||||
EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: "VK_EXT_swapchain_colorspace";
|
||||
EXT_hdr_metadata :: 1;
|
||||
EXT_HDR_METADATA_SPEC_VERSION :: 2;
|
||||
EXT_HDR_METADATA_EXTENSION_NAME :: "VK_EXT_hdr_metadata";
|
||||
EXT_external_memory_dma_buf :: 1;
|
||||
EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION :: 1;
|
||||
EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: "VK_EXT_external_memory_dma_buf";
|
||||
EXT_queue_family_foreign :: 1;
|
||||
EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION :: 1;
|
||||
EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: "VK_EXT_queue_family_foreign";
|
||||
EXT_debug_utils :: 1;
|
||||
EXT_DEBUG_UTILS_SPEC_VERSION :: 2;
|
||||
EXT_DEBUG_UTILS_EXTENSION_NAME :: "VK_EXT_debug_utils";
|
||||
EXT_sampler_filter_minmax :: 1;
|
||||
EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION :: 2;
|
||||
EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: "VK_EXT_sampler_filter_minmax";
|
||||
AMD_gpu_shader_int16 :: 1;
|
||||
AMD_GPU_SHADER_INT16_SPEC_VERSION :: 2;
|
||||
AMD_GPU_SHADER_INT16_EXTENSION_NAME :: "VK_AMD_gpu_shader_int16";
|
||||
AMD_mixed_attachment_samples :: 1;
|
||||
AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION :: 1;
|
||||
AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: "VK_AMD_mixed_attachment_samples";
|
||||
AMD_shader_fragment_mask :: 1;
|
||||
AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: "VK_AMD_shader_fragment_mask";
|
||||
EXT_inline_uniform_block :: 1;
|
||||
EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION :: 1;
|
||||
EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME :: "VK_EXT_inline_uniform_block";
|
||||
EXT_shader_stencil_export :: 1;
|
||||
EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: "VK_EXT_shader_stencil_export";
|
||||
EXT_sample_locations :: 1;
|
||||
EXT_SAMPLE_LOCATIONS_SPEC_VERSION :: 1;
|
||||
EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: "VK_EXT_sample_locations";
|
||||
EXT_blend_operation_advanced :: 1;
|
||||
EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION :: 2;
|
||||
EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: "VK_EXT_blend_operation_advanced";
|
||||
NV_fragment_coverage_to_color :: 1;
|
||||
NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION :: 1;
|
||||
NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: "VK_NV_fragment_coverage_to_color";
|
||||
NV_framebuffer_mixed_samples :: 1;
|
||||
NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: 1;
|
||||
NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: "VK_NV_framebuffer_mixed_samples";
|
||||
NV_fill_rectangle :: 1;
|
||||
NV_FILL_RECTANGLE_SPEC_VERSION :: 1;
|
||||
NV_FILL_RECTANGLE_EXTENSION_NAME :: "VK_NV_fill_rectangle";
|
||||
NV_shader_sm_builtins :: 1;
|
||||
NV_SHADER_SM_BUILTINS_SPEC_VERSION :: 1;
|
||||
NV_SHADER_SM_BUILTINS_EXTENSION_NAME :: "VK_NV_shader_sm_builtins";
|
||||
EXT_post_depth_coverage :: 1;
|
||||
EXT_POST_DEPTH_COVERAGE_SPEC_VERSION :: 1;
|
||||
EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: "VK_EXT_post_depth_coverage";
|
||||
EXT_image_drm_format_modifier :: 1;
|
||||
EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION :: 1;
|
||||
EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME :: "VK_EXT_image_drm_format_modifier";
|
||||
EXT_validation_cache :: 1;
|
||||
EXT_VALIDATION_CACHE_SPEC_VERSION :: 1;
|
||||
EXT_VALIDATION_CACHE_EXTENSION_NAME :: "VK_EXT_validation_cache";
|
||||
EXT_descriptor_indexing :: 1;
|
||||
EXT_DESCRIPTOR_INDEXING_SPEC_VERSION :: 2;
|
||||
EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME :: "VK_EXT_descriptor_indexing";
|
||||
EXT_shader_viewport_index_layer :: 1;
|
||||
EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: "VK_EXT_shader_viewport_index_layer";
|
||||
NV_shading_rate_image :: 1;
|
||||
NV_SHADING_RATE_IMAGE_SPEC_VERSION :: 3;
|
||||
NV_SHADING_RATE_IMAGE_EXTENSION_NAME :: "VK_NV_shading_rate_image";
|
||||
NV_ray_tracing :: 1;
|
||||
NV_RAY_TRACING_SPEC_VERSION :: 3;
|
||||
NV_RAY_TRACING_EXTENSION_NAME :: "VK_NV_ray_tracing";
|
||||
NV_representative_fragment_test :: 1;
|
||||
NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION :: 2;
|
||||
NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME :: "VK_NV_representative_fragment_test";
|
||||
EXT_filter_cubic :: 1;
|
||||
EXT_FILTER_CUBIC_SPEC_VERSION :: 3;
|
||||
EXT_FILTER_CUBIC_EXTENSION_NAME :: "VK_EXT_filter_cubic";
|
||||
EXT_global_priority :: 1;
|
||||
EXT_GLOBAL_PRIORITY_SPEC_VERSION :: 2;
|
||||
EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: "VK_EXT_global_priority";
|
||||
EXT_external_memory_host :: 1;
|
||||
EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION :: 1;
|
||||
EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: "VK_EXT_external_memory_host";
|
||||
AMD_buffer_marker :: 1;
|
||||
AMD_BUFFER_MARKER_SPEC_VERSION :: 1;
|
||||
AMD_BUFFER_MARKER_EXTENSION_NAME :: "VK_AMD_buffer_marker";
|
||||
AMD_pipeline_compiler_control :: 1;
|
||||
AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION :: 1;
|
||||
AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME :: "VK_AMD_pipeline_compiler_control";
|
||||
EXT_calibrated_timestamps :: 1;
|
||||
EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION :: 2;
|
||||
EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME :: "VK_EXT_calibrated_timestamps";
|
||||
AMD_shader_core_properties :: 1;
|
||||
AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION :: 2;
|
||||
AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME :: "VK_AMD_shader_core_properties";
|
||||
AMD_memory_overallocation_behavior :: 1;
|
||||
AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION :: 1;
|
||||
AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME :: "VK_AMD_memory_overallocation_behavior";
|
||||
EXT_vertex_attribute_divisor :: 1;
|
||||
EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION :: 3;
|
||||
EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME :: "VK_EXT_vertex_attribute_divisor";
|
||||
EXT_pipeline_creation_feedback :: 1;
|
||||
EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION :: 1;
|
||||
EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME :: "VK_EXT_pipeline_creation_feedback";
|
||||
NV_shader_subgroup_partitioned :: 1;
|
||||
NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION :: 1;
|
||||
NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME :: "VK_NV_shader_subgroup_partitioned";
|
||||
NV_compute_shader_derivatives :: 1;
|
||||
NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION :: 1;
|
||||
NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME :: "VK_NV_compute_shader_derivatives";
|
||||
NV_mesh_shader :: 1;
|
||||
NV_MESH_SHADER_SPEC_VERSION :: 1;
|
||||
NV_MESH_SHADER_EXTENSION_NAME :: "VK_NV_mesh_shader";
|
||||
NV_fragment_shader_barycentric :: 1;
|
||||
NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION :: 1;
|
||||
NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME :: "VK_NV_fragment_shader_barycentric";
|
||||
NV_shader_image_footprint :: 1;
|
||||
NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION :: 2;
|
||||
NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME :: "VK_NV_shader_image_footprint";
|
||||
NV_scissor_exclusive :: 1;
|
||||
NV_SCISSOR_EXCLUSIVE_SPEC_VERSION :: 1;
|
||||
NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME :: "VK_NV_scissor_exclusive";
|
||||
NV_device_diagnostic_checkpoints :: 1;
|
||||
NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION :: 2;
|
||||
NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME :: "VK_NV_device_diagnostic_checkpoints";
|
||||
EXT_pci_bus_info :: 1;
|
||||
EXT_PCI_BUS_INFO_SPEC_VERSION :: 2;
|
||||
EXT_PCI_BUS_INFO_EXTENSION_NAME :: "VK_EXT_pci_bus_info";
|
||||
AMD_display_native_hdr :: 1;
|
||||
AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION :: 1;
|
||||
AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME :: "VK_AMD_display_native_hdr";
|
||||
EXT_fragment_density_map :: 1;
|
||||
EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION :: 1;
|
||||
EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME :: "VK_EXT_fragment_density_map";
|
||||
EXT_scalar_block_layout :: 1;
|
||||
EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION :: 1;
|
||||
EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_EXT_scalar_block_layout";
|
||||
GOOGLE_hlsl_functionality1 :: 1;
|
||||
GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION :: 1;
|
||||
GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME :: "VK_GOOGLE_hlsl_functionality1";
|
||||
GOOGLE_decorate_string :: 1;
|
||||
GOOGLE_DECORATE_STRING_SPEC_VERSION :: 1;
|
||||
GOOGLE_DECORATE_STRING_EXTENSION_NAME :: "VK_GOOGLE_decorate_string";
|
||||
EXT_subgroup_size_control :: 1;
|
||||
EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION :: 2;
|
||||
EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME :: "VK_EXT_subgroup_size_control";
|
||||
AMD_shader_core_properties2 :: 1;
|
||||
AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION :: 1;
|
||||
AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME :: "VK_AMD_shader_core_properties2";
|
||||
AMD_device_coherent_memory :: 1;
|
||||
AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION :: 1;
|
||||
AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME :: "VK_AMD_device_coherent_memory";
|
||||
EXT_shader_image_atomic_int64 :: 1;
|
||||
EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME :: "VK_EXT_shader_image_atomic_int64";
|
||||
EXT_memory_budget :: 1;
|
||||
EXT_MEMORY_BUDGET_SPEC_VERSION :: 1;
|
||||
EXT_MEMORY_BUDGET_EXTENSION_NAME :: "VK_EXT_memory_budget";
|
||||
EXT_memory_priority :: 1;
|
||||
EXT_MEMORY_PRIORITY_SPEC_VERSION :: 1;
|
||||
EXT_MEMORY_PRIORITY_EXTENSION_NAME :: "VK_EXT_memory_priority";
|
||||
NV_dedicated_allocation_image_aliasing :: 1;
|
||||
NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION :: 1;
|
||||
NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME :: "VK_NV_dedicated_allocation_image_aliasing";
|
||||
EXT_buffer_device_address :: 1;
|
||||
EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 2;
|
||||
EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_EXT_buffer_device_address";
|
||||
EXT_tooling_info :: 1;
|
||||
EXT_TOOLING_INFO_SPEC_VERSION :: 1;
|
||||
EXT_TOOLING_INFO_EXTENSION_NAME :: "VK_EXT_tooling_info";
|
||||
EXT_separate_stencil_usage :: 1;
|
||||
EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION :: 1;
|
||||
EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME :: "VK_EXT_separate_stencil_usage";
|
||||
EXT_validation_features :: 1;
|
||||
EXT_VALIDATION_FEATURES_SPEC_VERSION :: 5;
|
||||
EXT_VALIDATION_FEATURES_EXTENSION_NAME :: "VK_EXT_validation_features";
|
||||
NV_cooperative_matrix :: 1;
|
||||
NV_COOPERATIVE_MATRIX_SPEC_VERSION :: 1;
|
||||
NV_COOPERATIVE_MATRIX_EXTENSION_NAME :: "VK_NV_cooperative_matrix";
|
||||
NV_coverage_reduction_mode :: 1;
|
||||
NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION :: 1;
|
||||
NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME :: "VK_NV_coverage_reduction_mode";
|
||||
EXT_fragment_shader_interlock :: 1;
|
||||
EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION :: 1;
|
||||
EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME :: "VK_EXT_fragment_shader_interlock";
|
||||
EXT_ycbcr_image_arrays :: 1;
|
||||
EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION :: 1;
|
||||
EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME :: "VK_EXT_ycbcr_image_arrays";
|
||||
EXT_provoking_vertex :: 1;
|
||||
EXT_PROVOKING_VERTEX_SPEC_VERSION :: 1;
|
||||
EXT_PROVOKING_VERTEX_EXTENSION_NAME :: "VK_EXT_provoking_vertex";
|
||||
EXT_headless_surface :: 1;
|
||||
EXT_HEADLESS_SURFACE_SPEC_VERSION :: 1;
|
||||
EXT_HEADLESS_SURFACE_EXTENSION_NAME :: "VK_EXT_headless_surface";
|
||||
EXT_line_rasterization :: 1;
|
||||
EXT_LINE_RASTERIZATION_SPEC_VERSION :: 1;
|
||||
EXT_LINE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_line_rasterization";
|
||||
EXT_shader_atomic_float :: 1;
|
||||
EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: "VK_EXT_shader_atomic_float";
|
||||
EXT_host_query_reset :: 1;
|
||||
EXT_HOST_QUERY_RESET_SPEC_VERSION :: 1;
|
||||
EXT_HOST_QUERY_RESET_EXTENSION_NAME :: "VK_EXT_host_query_reset";
|
||||
EXT_index_type_uint8 :: 1;
|
||||
EXT_INDEX_TYPE_UINT8_SPEC_VERSION :: 1;
|
||||
EXT_INDEX_TYPE_UINT8_EXTENSION_NAME :: "VK_EXT_index_type_uint8";
|
||||
EXT_extended_dynamic_state :: 1;
|
||||
EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION :: 1;
|
||||
EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state";
|
||||
EXT_shader_atomic_float2 :: 1;
|
||||
EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME :: "VK_EXT_shader_atomic_float2";
|
||||
EXT_shader_demote_to_helper_invocation :: 1;
|
||||
EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION :: 1;
|
||||
EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME :: "VK_EXT_shader_demote_to_helper_invocation";
|
||||
NV_device_generated_commands :: 1;
|
||||
NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION :: 3;
|
||||
NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: "VK_NV_device_generated_commands";
|
||||
NV_inherited_viewport_scissor :: 1;
|
||||
NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION :: 1;
|
||||
NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME :: "VK_NV_inherited_viewport_scissor";
|
||||
EXT_texel_buffer_alignment :: 1;
|
||||
EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION :: 1;
|
||||
EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME :: "VK_EXT_texel_buffer_alignment";
|
||||
EXT_device_memory_report :: 1;
|
||||
EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION :: 2;
|
||||
EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME :: "VK_EXT_device_memory_report";
|
||||
EXT_acquire_drm_display :: 1;
|
||||
EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION :: 1;
|
||||
EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME :: "VK_EXT_acquire_drm_display";
|
||||
EXT_robustness2 :: 1;
|
||||
EXT_ROBUSTNESS_2_SPEC_VERSION :: 1;
|
||||
EXT_ROBUSTNESS_2_EXTENSION_NAME :: "VK_EXT_robustness2";
|
||||
EXT_custom_border_color :: 1;
|
||||
EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION :: 12;
|
||||
EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME :: "VK_EXT_custom_border_color";
|
||||
GOOGLE_user_type :: 1;
|
||||
GOOGLE_USER_TYPE_SPEC_VERSION :: 1;
|
||||
GOOGLE_USER_TYPE_EXTENSION_NAME :: "VK_GOOGLE_user_type";
|
||||
EXT_private_data :: 1;
|
||||
EXT_PRIVATE_DATA_SPEC_VERSION :: 1;
|
||||
EXT_PRIVATE_DATA_EXTENSION_NAME :: "VK_EXT_private_data";
|
||||
EXT_pipeline_creation_cache_control :: 1;
|
||||
EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION :: 3;
|
||||
EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME :: "VK_EXT_pipeline_creation_cache_control";
|
||||
NV_device_diagnostics_config :: 1;
|
||||
NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION :: 1;
|
||||
NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME :: "VK_NV_device_diagnostics_config";
|
||||
NV_fragment_shading_rate_enums :: 1;
|
||||
NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION :: 1;
|
||||
NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME :: "VK_NV_fragment_shading_rate_enums";
|
||||
NV_ray_tracing_motion_blur :: 1;
|
||||
NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: 1;
|
||||
NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: "VK_NV_ray_tracing_motion_blur";
|
||||
EXT_ycbcr_2plane_444_formats :: 1;
|
||||
EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION :: 1;
|
||||
EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME :: "VK_EXT_ycbcr_2plane_444_formats";
|
||||
EXT_fragment_density_map2 :: 1;
|
||||
EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION :: 1;
|
||||
EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME :: "VK_EXT_fragment_density_map2";
|
||||
EXT_image_robustness :: 1;
|
||||
EXT_IMAGE_ROBUSTNESS_SPEC_VERSION :: 1;
|
||||
EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME :: "VK_EXT_image_robustness";
|
||||
EXT_4444_formats :: 1;
|
||||
EXT_4444_FORMATS_SPEC_VERSION :: 1;
|
||||
EXT_4444_FORMATS_EXTENSION_NAME :: "VK_EXT_4444_formats";
|
||||
NV_acquire_winrt_display :: 1;
|
||||
NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION :: 1;
|
||||
NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME :: "VK_NV_acquire_winrt_display";
|
||||
EXT_vertex_input_dynamic_state :: 1;
|
||||
EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION :: 2;
|
||||
EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_vertex_input_dynamic_state";
|
||||
EXT_physical_device_drm :: 1;
|
||||
EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION :: 1;
|
||||
EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME :: "VK_EXT_physical_device_drm";
|
||||
NV_external_memory_rdma :: 1;
|
||||
NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION :: 1;
|
||||
NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME :: "VK_NV_external_memory_rdma";
|
||||
EXT_extended_dynamic_state2 :: 1;
|
||||
EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION :: 1;
|
||||
EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state2";
|
||||
EXT_color_write_enable :: 1;
|
||||
EXT_COLOR_WRITE_ENABLE_SPEC_VERSION :: 1;
|
||||
EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME :: "VK_EXT_color_write_enable";
|
||||
EXT_global_priority_query :: 1;
|
||||
EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION :: 1;
|
||||
EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME :: "VK_EXT_global_priority_query";
|
||||
EXT_multi_draw :: 1;
|
||||
EXT_MULTI_DRAW_SPEC_VERSION :: 1;
|
||||
EXT_MULTI_DRAW_EXTENSION_NAME :: "VK_EXT_multi_draw";
|
||||
EXT_load_store_op_none :: 1;
|
||||
EXT_LOAD_STORE_OP_NONE_SPEC_VERSION :: 1;
|
||||
EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME :: "VK_EXT_load_store_op_none";
|
||||
KHR_acceleration_structure :: 1;
|
||||
KHR_ACCELERATION_STRUCTURE_SPEC_VERSION :: 12;
|
||||
KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME :: "VK_KHR_acceleration_structure";
|
||||
KHR_ray_tracing_pipeline :: 1;
|
||||
KHR_RAY_TRACING_PIPELINE_SPEC_VERSION :: 1;
|
||||
KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME :: "VK_KHR_ray_tracing_pipeline";
|
||||
KHR_ray_query :: 1;
|
||||
KHR_RAY_QUERY_SPEC_VERSION :: 1;
|
||||
KHR_RAY_QUERY_EXTENSION_NAME :: "VK_KHR_ray_query";
|
||||
KHR_win32_surface :: 1;
|
||||
KHR_WIN32_SURFACE_SPEC_VERSION :: 6;
|
||||
KHR_WIN32_SURFACE_EXTENSION_NAME :: "VK_KHR_win32_surface";
|
||||
KHR_external_memory_win32 :: 1;
|
||||
KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_KHR_external_memory_win32";
|
||||
KHR_win32_keyed_mutex :: 1;
|
||||
KHR_WIN32_KEYED_MUTEX_SPEC_VERSION :: 1;
|
||||
KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_KHR_win32_keyed_mutex";
|
||||
KHR_external_semaphore_win32 :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: "VK_KHR_external_semaphore_win32";
|
||||
KHR_external_fence_win32 :: 1;
|
||||
KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION :: 1;
|
||||
KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: "VK_KHR_external_fence_win32";
|
||||
NV_external_memory_win32 :: 1;
|
||||
NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1;
|
||||
NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_NV_external_memory_win32";
|
||||
NV_win32_keyed_mutex :: 1;
|
||||
NV_WIN32_KEYED_MUTEX_SPEC_VERSION :: 2;
|
||||
NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_NV_win32_keyed_mutex";
|
||||
EXT_full_screen_exclusive :: 1;
|
||||
EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION :: 4;
|
||||
EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME :: "VK_EXT_full_screen_exclusive";
|
||||
EXT_metal_surface :: 1;
|
||||
EXT_METAL_SURFACE_SPEC_VERSION :: 1;
|
||||
EXT_METAL_SURFACE_EXTENSION_NAME :: "VK_EXT_metal_surface";
|
||||
|
||||
// Handles types
|
||||
Instance :: distinct Handle;
|
||||
PhysicalDevice :: distinct Handle;
|
||||
Device :: distinct Handle;
|
||||
Queue :: distinct Handle;
|
||||
CommandBuffer :: distinct Handle;
|
||||
Buffer :: distinct NonDispatchableHandle;
|
||||
Image :: distinct NonDispatchableHandle;
|
||||
Semaphore :: distinct NonDispatchableHandle;
|
||||
Fence :: distinct NonDispatchableHandle;
|
||||
DeviceMemory :: distinct NonDispatchableHandle;
|
||||
Event :: distinct NonDispatchableHandle;
|
||||
QueryPool :: distinct NonDispatchableHandle;
|
||||
BufferView :: distinct NonDispatchableHandle;
|
||||
ImageView :: distinct NonDispatchableHandle;
|
||||
ShaderModule :: distinct NonDispatchableHandle;
|
||||
PipelineCache :: distinct NonDispatchableHandle;
|
||||
PipelineLayout :: distinct NonDispatchableHandle;
|
||||
Pipeline :: distinct NonDispatchableHandle;
|
||||
RenderPass :: distinct NonDispatchableHandle;
|
||||
DescriptorSetLayout :: distinct NonDispatchableHandle;
|
||||
Sampler :: distinct NonDispatchableHandle;
|
||||
DescriptorSet :: distinct NonDispatchableHandle;
|
||||
DescriptorPool :: distinct NonDispatchableHandle;
|
||||
Framebuffer :: distinct NonDispatchableHandle;
|
||||
CommandPool :: distinct NonDispatchableHandle;
|
||||
SamplerYcbcrConversion :: distinct NonDispatchableHandle;
|
||||
DescriptorUpdateTemplate :: distinct NonDispatchableHandle;
|
||||
SurfaceKHR :: distinct NonDispatchableHandle;
|
||||
SwapchainKHR :: distinct NonDispatchableHandle;
|
||||
DisplayKHR :: distinct NonDispatchableHandle;
|
||||
DisplayModeKHR :: distinct NonDispatchableHandle;
|
||||
DeferredOperationKHR :: distinct NonDispatchableHandle;
|
||||
DebugReportCallbackEXT :: distinct NonDispatchableHandle;
|
||||
CuModuleNVX :: distinct NonDispatchableHandle;
|
||||
CuFunctionNVX :: distinct NonDispatchableHandle;
|
||||
DebugUtilsMessengerEXT :: distinct NonDispatchableHandle;
|
||||
ValidationCacheEXT :: distinct NonDispatchableHandle;
|
||||
AccelerationStructureNV :: distinct NonDispatchableHandle;
|
||||
PerformanceConfigurationINTEL :: distinct NonDispatchableHandle;
|
||||
IndirectCommandsLayoutNV :: distinct NonDispatchableHandle;
|
||||
PrivateDataSlotEXT :: distinct NonDispatchableHandle;
|
||||
AccelerationStructureKHR :: distinct NonDispatchableHandle;
|
||||
|
||||
|
||||
2974
vendor/vulkan/enums.odin
vendored
Normal file
2974
vendor/vulkan/enums.odin
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1924
vendor/vulkan/procedures.odin
vendored
Normal file
1924
vendor/vulkan/procedures.odin
vendored
Normal file
File diff suppressed because it is too large
Load Diff
5446
vendor/vulkan/structs.odin
vendored
Normal file
5446
vendor/vulkan/structs.odin
vendored
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user