dymokomi/luce-gpu
Source of release 0.5.3
0.5.3 / tools / generate_vulkan.py
#!/usr/bin/env python3
"""Generate the standard GPU backend's Vulkan ABI subset from Khronos vk.xml.
The generated Base declarations have no C shim or runtime SDK dependency.
Regeneration requires the Vulkan SDK registry; builds use the checked-in output.
"""
import argparse
from pathlib import Path
import re
import xml.etree.ElementTree as ET
ROOT = Path(__file__).resolve().parents[1]
COMMANDS = '''
vkCreateInstance vkDestroyInstance vkEnumeratePhysicalDevices
vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties
vkGetPhysicalDeviceFormatProperties vkCreateDevice vkDestroyDevice vkGetDeviceQueue
vkCreateWin32SurfaceKHR vkGetPhysicalDeviceWin32PresentationSupportKHR vkDestroySurfaceKHR vkGetPhysicalDeviceSurfaceSupportKHR
vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceFormatsKHR
vkCreateSwapchainKHR vkDestroySwapchainKHR vkGetSwapchainImagesKHR
vkAcquireNextImageKHR vkQueuePresentKHR vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle
vkCreateImageView vkDestroyImageView vkCreateImage vkDestroyImage
vkGetImageMemoryRequirements vkAllocateMemory vkFreeMemory vkBindImageMemory
vkCreateBuffer vkDestroyBuffer vkGetBufferMemoryRequirements vkBindBufferMemory
vkMapMemory vkUnmapMemory vkCreateRenderPass vkDestroyRenderPass
vkCreateFramebuffer vkDestroyFramebuffer vkCreateShaderModule vkDestroyShaderModule
vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateGraphicsPipelines vkDestroyPipeline
vkCreateCommandPool vkDestroyCommandPool vkAllocateCommandBuffers vkResetCommandPool
vkBeginCommandBuffer vkEndCommandBuffer vkCmdBeginRenderPass vkCmdEndRenderPass
vkCmdBindPipeline vkCmdSetViewport vkCmdSetScissor vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndirect
vkCreateSemaphore vkDestroySemaphore vkCreateFence vkDestroyFence
vkWaitForFences vkResetFences
vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool
vkAllocateDescriptorSets vkUpdateDescriptorSets vkCmdBindDescriptorSets vkCmdPushConstants
vkGetPhysicalDeviceProperties vkCmdSetDepthBias vkCreateSampler vkDestroySampler vkCmdPipelineBarrier
vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCreateXlibSurfaceKHR
vkEnumerateInstanceVersion vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceFeatures2
vkEnumerateDeviceExtensionProperties vkCreateComputePipelines vkCmdDispatch vkCmdDispatchIndirect vkCmdFillBuffer
vkCreateQueryPool vkDestroyQueryPool vkCmdResetQueryPool vkCmdWriteTimestamp vkGetQueryPoolResults
vkGetBufferDeviceAddress vkGetDeviceProcAddr
vkGetAccelerationStructureBuildSizesKHR vkCreateAccelerationStructureKHR vkDestroyAccelerationStructureKHR
vkCmdBuildAccelerationStructuresKHR vkGetAccelerationStructureDeviceAddressKHR
'''.split()
# Unions emitted as `extern union`: acceleration structure addresses and geometry.
UNIONS = {'VkDeviceOrHostAddressConstKHR', 'VkDeviceOrHostAddressKHR', 'VkAccelerationStructureGeometryDataKHR'}
# Structures reached only through pNext chains, which no command names.
CHAINED = '''
VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceShaderAtomicFloatFeaturesEXT VkPhysicalDeviceSubgroupProperties
VkPhysicalDeviceVulkan12Features VkPhysicalDeviceDescriptorIndexingProperties VkDescriptorSetLayoutBindingFlagsCreateInfo
VkDescriptorSetVariableDescriptorCountAllocateInfo VkMemoryAllocateFlagsInfo
VkPhysicalDeviceAccelerationStructureFeaturesKHR VkPhysicalDeviceRayQueryFeaturesKHR VkPhysicalDeviceAccelerationStructurePropertiesKHR
VkWriteDescriptorSetAccelerationStructureKHR VkAccelerationStructureGeometryTrianglesDataKHR VkAccelerationStructureGeometryInstancesDataKHR
'''.split()
def vulkan(node):
return 'vulkan' in node.get('api', 'vulkan').split(',')
def members(node):
return [member for member in node.findall('member') if vulkan(member)]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('registry', type=Path)
args = parser.parse_args()
registry = ET.parse(args.registry).getroot()
types = {t.get('name') or t.findtext('name'): t for t in registry.findall('types/type') if vulkan(t)}
commands = {c.findtext('proto/name'): c for c in registry.findall('commands/command') if c.find('proto') is not None and vulkan(c)}
values = {}
aliases = {}
result_names = {e.get('name') for e in registry.findall("enums[@name='VkResult']/enum")}
for e in registry.findall('.//enum'):
if e.get('value'):
values[e.get('name')] = e.get('value')
elif e.get('bitpos'):
values[e.get('name')] = str(1 << int(e.get('bitpos')))
elif e.get('alias'):
aliases[e.get('name')] = e.get('alias')
elif e.get('offset'):
extension = e.get('extnumber')
if extension:
value = 1000000000 + (int(extension) - 1) * 1000 + int(e.get('offset'))
values[e.get('name')] = str(-value if e.get('dir') == '-' else value)
if e.get('extends') == 'VkResult':
result_names.add(e.get('name'))
for extension in registry.findall('extensions/extension'):
for e in extension.findall('require/enum'):
if e.get('offset'):
value = 1000000000 + (int(e.get('extnumber', extension.get('number'))) - 1) * 1000 + int(e.get('offset'))
values[e.get('name')] = str(-value if e.get('dir') == '-' else value)
def constant_value(name):
if name in aliases:
return constant_value(aliases[name])
value = values[name]
if value.startswith('"'):
return 'c.str', value
# Registry sentinel constants use C unsigned complements and suffixes.
complement = re.fullmatch(r'\(~(\d+)U\)', value)
if complement:
value = str(0xffffffff ^ int(complement.group(1)))
wide = re.fullmatch(r'\(~(\d+)ULL\)', value)
if wide:
return 'u64', str(0xffffffffffffffff ^ int(wide.group(1)))
value = re.sub(r'[uU]$', '', value)
return ('i32' if name in result_names else 'u32'), value
needed = set()
scalars = {'void': 'void', 'char': 'u8', 'float': 'f32', 'double': 'f64',
'int32_t': 'i32', 'uint32_t': 'u32', 'int64_t': 'i64', 'uint64_t': 'u64',
'uint8_t': 'u8', 'uint16_t': 'u16', 'size_t': 'usize',
'HINSTANCE': 'void*?', 'HWND': 'void*?', 'HANDLE': 'void*?',
'LPCWSTR': 'u16*?', 'SECURITY_ATTRIBUTES': 'void', 'DWORD': 'u32',
'Display': 'void', 'Window': 'u64', 'PFN_vkVoidFunction': 'void*?'}
def base_type(name):
if name in scalars:
return scalars[name]
item = types[name]
if item.get('alias'):
return base_type(item.get('alias'))
category = item.get('category')
if category in ('struct', 'union'):
if name not in needed:
needed.add(name)
for member in members(item):
declaration(member)
return name
if category == 'handle':
return 'u64'
if category == 'enum':
return 'i32' if name == 'VkResult' else 'u32'
if category == 'funcpointer':
return 'void*?'
if category in ('bitmask', 'basetype'):
return base_type(item.findtext('type'))
raise ValueError((name, category))
def declaration(node):
name = node.findtext('name')
kind = node.findtext('type')
# Registry comments can contain brackets such as STORAGE_BUFFER[_DYNAMIC].
# Only declaration tokens may contribute a fixed array extent.
text = (node.text or '') + ''.join(
(''.join(child.itertext()) if child.tag != 'comment' else '') + (child.tail or '')
for child in node)
before = text.split(name)[0]
depth = before.count('*')
if kind == 'VkAllocationCallbacks':
return name, 'void*?'
result = base_type(kind)
if depth:
if kind == 'char':
result = 'c.str' + ('*?' * (depth - 1))
else:
result += '*?' * depth
array = re.search(r'\[([^\]]+)\]', text.split(name, 1)[1])
if array:
length = array.group(1)
length = values.get(length, length)
result += f'[{length}]'
return name, result
functions = []
for name in COMMANDS:
command = commands[name]
parameters = [declaration(p) for p in command.findall('param') if vulkan(p)]
result = base_type(command.findtext('proto/type'))
params = ', '.join(f'{n}: {t}' for n, t in parameters)
# The functions themselves are called through vulkan/entry.lucb's run-time table;
# print their signatures for that file rather than linking them here.
functions.append(f'# func {name}({params})' + (f' -> {result}' if result != 'void' else ''))
for name in CHAINED:
base_type(name)
lines = [
'#==============================================================================================',
'#',
'# bindings - Vulkan structures, handles and functions from the Khronos registry',
'#',
'# DESCRIPTION:',
'# Generated from the Khronos Vulkan registry by tools/generate_vulkan.py.',
'# Handles use the 64-bit Vulkan ABI; no Vulkan headers are required.',
'#',
'#==============================================================================================',
'',
'# mark: Vulkan bindings =======================================================================',
'']
authored = ROOT / 'src/gpu/vulkan'
constants = set()
for source in authored.rglob('*.lucb'):
if source.name not in ('bindings.lucb', 'shaders.lucb'):
constants.update(re.findall(r'\bVK_[A-Z0-9_]+\b', source.read_text(encoding='utf-8')))
constants.discard('VK_MAKE_API_VERSION') # documented expression, not an enum
# Structure tags are emitted alongside their declarations below.
for name in sorted(constants):
if not name.startswith('VK_STRUCTURE_TYPE_'):
kind, value = constant_value(name)
lines.append(f'let {name}: {kind} = {value}')
lines.append('')
for name in sorted(needed):
item = types[name]
# Clear unions have a fixed 16-byte ABI; color floats also store depth/stencil.
if name == 'VkClearValue':
lines += ['extern struct VkClearValue:', ' color: f32[4]', '']
continue
# Unions the bindings use carry their C layout; the others are left out.
if item.get('category') == 'union' and name not in UNIONS:
continue
lines.append(f'extern {item.get("category")} {name}:')
for member in members(item):
n, t = declaration(member)
lines.append(f' {"descriptorType" if n == "type" else n}: {t}')
lines.append('')
tag = item.find('member[@values]')
if tag is not None:
constant = tag.get('values')
lines += [f'let {constant}: u32 = {values[constant]}', '']
lines += functions
output = ROOT / 'src/gpu/vulkan/bindings.lucb'
output.parent.mkdir(parents=True, exist_ok=True)
output.write_bytes(('\n'.join(lines) + '\n').encode("utf-8"))
print(f'wrote {output.relative_to(ROOT)} ({len(needed)} structures, {len(functions)} functions)')
if __name__ == '__main__':
main()